Implement C _FloatN, _FloatNx types

Message ID alpine.DEB.2.20.1606211202040.4526@digraph.polyomino.org.uk
State New
Headers show

Commit Message

Joseph Myers June 21, 2016, 12:06 p.m.
ISO/IEC TS 18661-3:2015 defines C bindings to IEEE interchange and
extended types, in the form of _FloatN and _FloatNx type names with
corresponding fN/FN and fNx/FNx constant suffixes and FLTN_* / FLTNX_*
<float.h> macros.  This patch implements support for this feature in
GCC.

The _FloatN types, for N = 16, 32, 64 or >= 128 and a multiple of 32,
are types encoded according to the corresponding IEEE interchange
format (endianness unspecified).  The _FloatNx types, for N = 32, 64
and 128, are IEEE "extended" types: types extending a narrower format
with range and precision at least as big as those specified in IEEE
754 for each extended type (and with unspecified representation, but
still following IEEE semantics for their values and operations - and
with the set of values being determined by the precision and the
maximum exponent, which means that while Intel "extended" is suitable
for _Float64x, m68k "extended" is not).  These types are always
distinct from and not compatible with each other and the standard
floating types float, double, long double; thus, double, _Float64 and
_Float32x may all have the same ABI, but they are three still distinct
types.  The type names may be used with _Complex to construct
corresponding complex types (unlike __float128, which acts more like a
typedef name than a keyword - thus, this patch may be considered to
fix PR c/32187).  The new suffixes can be combined with GNU "i" and
"j" suffixes for constants of complex types (e.g. 1.0if128, 2.0f64i).

The set of types supported is implementation-defined.  In this GCC
patch, _Float32 is SFmode if that is suitable; _Float32x and _Float64
are DFmode if that is suitable; _Float128 is TFmode if that is
suitable; _Float64x is XFmode if that is suitable, and otherwise
TFmode if that is suitable.  There is a target hook to override the
choices if necessary.  "Suitable" means both conforming to the
requirements of that type, and supported as a scalar type including in
libgcc.  The ABI is whatever the back end does for scalars of that
mode (but note that _Float32 is passed without promotion in variable
arguments, unlike float).  All the existing issues with exceptions and
rounding modes for existing types apply equally to the new type names.

No GCC port supports a floating-point format suitable for _Float128x.
Although there is HFmode support for ARM and AArch64, use of that for
_Float16 is not enabled.  Supporting _Float16 would require additional
work on the excess precision aspects of TS 18661-3: there are new
values of FLT_EVAL_METHOD, which are not currently supported in GCC,
and FLT_EVAL_METHOD == 0 now means that operations and constants on
types narrower than float are evaluated to the range and precision of
float.  Implementing that, so that _Float16 gets evaluated with excess
range and precision, would involve changes to the excess precision
infrastructure so that the _Float16 case is enabled by default, unlike
the x87 case which is only enabled for -fexcess-precision=standard.
Other differences between _Float16 and __fp16 would also need to be
disentangled.

GCC has some prior support for nonstandard floating-point types in the
form of __float80 and __float128.  Where these were previously types
distinct from long double, they are made by this patch into aliases
for _Float64x / _Float128 if those types have the required properties.

In principle the set of possible _FloatN types is infinite.  This
patch hardcodes the four such types for N <= 128, but with as much
code as possible using loops over types to minimize the number of
places with such hardcoding.  I don't think it's likely any further
such types will be of use in future (or indeed that formats suitable
for _Float128x will actually be implemented).  There is a corner case
that all _FloatN, for N >= 128 and a multiple of 32, should be treated
as keywords even when the corresponding type is not supported; I
intend to deal with that in a followup patch.

Tests are added for various functionality of the new types, mostly
using type-generic headers.  PowerPC maintainers should note that the
tests do not do anything regarding passing special options to enable
support for the types, either for the tests themselves or for the
corresponding effective-target tests.  Thus, to run the _Float128
tests on PowerPC, you will need to add such support, { dg-add-options
float128 } or similar and make sure it affects both the
effective-target tests and the tests themselves.  The complex
arithmetic support in libgcc will also be needed, as otherwise the
associated tests will fail.  (The same would apply to _Float16 on ARM
as well if that were enabled with -mfp16-format=ieee required to use
it.  Of course, -mfp16-format=alternative enables use of a format
which is not compatible with the requirements of the _Float16 type.)

C++ note: no support for the new types or constant suffixes is added
for C++.  C++ decimal floating-point support was very different from
the C support, using class types, and the same may well apply to any
future C++ bindings for IEEE interchange and extended types.  There is
a case, however, for supporting at least *f128 constants in C++, so
that code using __float128 can use the newer style for constants
throughout rather than needing to use the older *q constants in C++.
Also, if built-in functions are added that may provide a way in which
the types could leak into C++ code.

Fortran note: I took the conservative approach of renaming the
float128_type_node used in the Fortran front end, since I wasn't sure
if it's safe to make the front end always use the language-independent
node (which follows C rules - thus, being distinct from long double
even if that has binary128 format).

PowerPC note: the back end had an inconsistency that if TFmode was
binary128, *q constants were TFmode instead of KFmode but __float128
was KFmode.  This patch follows the same logic as for *q constants, so
that _Float128 prefers TFmode (and __float128 becomes an alias for
_Float128), but if the KFmode-preferring logic of __float128 is
preferred, of course that can be used (and then I think *q constants
should be fixed to match).

ARM note: __fp16 is promoted to double (by convert_arguments) when
passed without a prototype / in variable arguments.  But this is only
about the argument promotion; it is not handled as promoting in
c-common.c:self_promoting_args_p / c-typeck.c:c_type_promotes_to,
meaning that a K&R function definition for an argument of type __fp16
corresponds to a prototype with an argument of that type, not to one
with an argument of type double, whereas a float argument in a K&R
function definition corresponds to a double prototype argument - and
the same functions are also what's involved in making va_arg give a
warning and generate a call to abort when called with type float.
This is preserved by this patch, while arranging for _Float16 not to
be promoted when passed without a prototype / in variable arguments
(the promotion of float being considered a legacy feature, not applied
to any new types in C99 or later).

TS 18661-3 extends the set of decimal floating-point types similarly,
and adds new constant suffixes for the existing types, but this patch
does not do anything regarding that extension.

This patch does nothing regarding built-in functions, although
type-generic functions such as __builtin_isinf work for the new types
and associated tests are included.  There are at least two levels of
built-in function support possible for these types.  The minimal
level, which I may implement in a followup patch, adds built-in
functions similar to those x86 has for __float128: __builtin_inf*
__builtin_huge_val*, __builtin_nan*, __builtin_nans*, __builtin_fabs*,
__builtin_copysign*.  That would be sufficient for glibc to use the
*f128 names for built-in functions by default with *q used only for
backwards compatibility when using older GCC versions.  That would
also allow c_cpp_builtins's flag_building_libgcc code, defining
__LIBGCC_%s_FUNC_EXT__, to use such suffixes rather than the present
code hardcoding logic about target-specific constant suffixes and how
those relate to function suffixes.

Full built-in function support would cover the full range of built-in
functions for existing floating-point types, adding variants for all
the new types, except for a few obsolescent functions and
non-type-generic variants of type-generic functions.  Some but not all
references to such functions in GCC use macros such as CASE_FLT_FN to
be type-generic; a fair amount of work would be needed to identify all
places to update.  Adding all those functions would enable
optimizations (for constant arguments and otherwise) for TS 18661-3
functions, but it would also substantially expand the enum listing
built-in functions (and we've had problems with the size of that enum
in the past), and increase the amount of built-in function
initialization to do - I don't know what the startup cost involved in
built-in function initialization is, but it would be something to
consider when adding such a large set of functions.

There are also a range of optimizations, in match.pd and elsewhere,
that only operate on the three standard floating-point types.  Ideally
those would be made generic to all floating-point types, but this
patch does nothing in that regard.  Special care would be needed
regarding making sure library functions to which calls are generated
actually exist.  For example, if sqrt is called on an argument of type
_Float32, and the result converted to _Float32, this is equivalent to
doing a square root operation directly on _Float32.  But if the user's
libm does not have the sqrtf32 function, or the name is not reserved
because __STDC_WANT_IEC_60559_TYPES_EXT__ was not defined before
including <math.h>, you can only do that optimization if you convert
to a call to sqrtf instead.

DECIMAL_DIG now relates to all supported floating-point formats, not
just float, double and long double; I've raised the question with WG14
of how this relates to the formula for DECIMAL_DIG in C11 not
considering this.  TS 18661-3 says it also covers non-arithmetic
formats only supported by library conversion functions; this patch
does not add any target hooks to allow for the case where there are
such formats wider than any supported for arithmetic types (where
e.g. libc supports conversions involving the binary128 representation,
but the _Float128 type is not supported).

GCC provides its own <tgmath.h> for some targets.  No attempt is made
to adapt this to handle the new types.

Nothing is done regarding debug info for the new types (see the
"Debugger support for __float128 type?" thread on gcc@, Sep/Oct 2015).

No __SIZEOF_*__ macros are added for the new types.

Nothing is done with do_warn_double_promotion.

Nothing is done to include the new types in those determining
max_align_t, although properly it should be sufficiently aligned for
any of those types.

The logic for usual arithmetic conversions in c_common_type relies on
TYPE_PRECISION for floating-point types, which is less than ideal
(doesn't necessarily correspond to whether one type's values are
subset of another); looking in more detail at the formats might be
better.  But since I included code in build_common_tree_nodes to work
around rs6000 KFmode having precision 113 not 128, I think it should
work.  Ideally one might have errors in generic code for the case
where the two types do not have one type's values a subset of the
other (which is undefined behavior).  But the only case where this can
actually occur is mixing IBM long double with binary128 on powerpc,
and rs6000_invalid_binary_op deals with that at present.  TS 18661-3
does not fully specify the type resulting from the usual arithmetic
conversions in the case where two _FloatNx types have the same set of
values; I arranged the code to prefer the greater value of N in that
case.

The __FP_FAST_FMA* macros are not extended to cover the new types,
since there are no corresponding built-in functions (if built-in
fmafN, fmafNx are added, the macros should be extended, and the new
macros documented).  Also, only a limited set of modes is handled in
mode_has_fma.

Diagnostics relating to the use of the new types with -pedantic do not
try to distinguish them from purely nonstandard types such as __int128
and constant suffixes such as *q.

If you use an unsupported _FloatN / _FloatNx type you get a warning
about the type defaulting to int after the warning about the type not
being supported.  That's less than ideal, but it's also a pre-existing
condition if you use __int128 on a 32-bit system where it's
unsupported.

Bootstrapped with no regressions on x86_64-pc-linux-gnu.  Other
back-end changes minimally tested by building cc1 for ia64-linux-gnu,
powerpc64le-linux-gnu, pdp11-none (the last failed for unrelated
reasons).  OK to commit (non-C-front-end parts)?

gcc:
2016-06-21  Joseph Myers  <joseph@codesourcery.com>

	PR c/32187
	* tree-core.h (TI_COMPLEX_FLOAT16_TYPE)
	(TI_COMPLEX_FLOATN_NX_TYPE_FIRST, TI_COMPLEX_FLOAT32_TYPE)
	(TI_COMPLEX_FLOAT64_TYPE, TI_COMPLEX_FLOAT128_TYPE)
	(TI_COMPLEX_FLOAT32X_TYPE, TI_COMPLEX_FLOAT64X_TYPE)
	(TI_COMPLEX_FLOAT128X_TYPE, TI_FLOAT16_TYPE, TI_FLOATN_TYPE_FIRST)
	(TI_FLOATN_NX_TYPE_FIRST, TI_FLOAT32_TYPE, TI_FLOAT64_TYPE)
	(TI_FLOAT128_TYPE, TI_FLOATN_TYPE_LAST, TI_FLOAT32X_TYPE)
	(TI_FLOATNX_TYPE_FIRST, TI_FLOAT64X_TYPE, TI_FLOAT128X_TYPE)
	(TI_FLOATNX_TYPE_LAST, TI_FLOATN_NX_TYPE_LAST): New enum
	tree_index values.
	(NUM_FLOATN_TYPES, NUM_FLOATNX_TYPES, NUM_FLOATN_NX_TYPES): New
	macros.
	(struct floatn_type_info): New structure type.
	(floatn_nx_types): New variable declaration.
	* tree.h (FLOATN_TYPE_NODE, FLOATN_NX_TYPE_NODE)
	(FLOATNX_TYPE_NODE, float128_type_node, float64x_type_node)
	(COMPLEX_FLOATN_NX_TYPE_NODE): New macros.
	* tree.c (floatn_nx_types): New variable.
	(build_common_tree_nodes): Initialize _FloatN, _FloatNx and
	corresponding complex types.
	* target.def (floatn_mode): New hook.
	* targhooks.c: Include "real.h".
	(default_floatn_mode): New function.
	* targhooks.h (default_floatn_mode): New prototype.
	* doc/extend.texi (Floating Types): Document _FloatN and _FloatNx
	types.
	* doc/sourcebuild.texi (float@var{n}, float@var{n}x): Document new
	effective-target keywords.
	* doc/tm.texi.in (TARGET_FLOATN_MODE): New @hook.
	* doc/tm.texi: Regenerate.
	* ginclude/float.h (LDBL_DECIMAL_DIG): Define to
	__LDBL_DECIMAL_DIG__, not __DECIMAL_DIG__.
	[__STDC_WANT_IEC_60559_TYPES_EXT__]: Define macros from TS
	18661-3.
	* real.h (struct real_format): Add field ieee_bits.
	* real.c (ieee_single_format, mips_single_format)
	(motorola_single_format, spu_single_format, ieee_double_format)
	(mips_double_format, motorola_double_format)
	(ieee_extended_motorola_format, ieee_extended_intel_96_format)
	(ieee_extended_intel_128_format)
	(ieee_extended_intel_96_round_53_format, ibm_extended_format)
	(mips_extended_format, ieee_quad_format, mips_quad_format)
	(vax_f_format, vax_d_format, vax_g_format, decimal_single_format)
	(decimal_double_format, decimal_quad_format, ieee_half_format)
	(arm_half_format, real_internal_format: Initialize ieee_bits
	field.
	* config/i386/i386.c (ix86_init_builtin_types): Do not initialize
	float128_type_node.  Set float80_type_node to float64x_type_node
	if appropriate and long_double_type_node not appropriate.
	* config/ia64/ia64.c (ia64_init_builtins): Likewise.
	* config/pdp11/pdp11.c (pdp11_f_format, pdp11_d_format):
	Initialize ieee_bits field.
	* config/rs6000/rs6000.c (TARGET_FLOATN_MODE): New macro.
	(rs6000_init_builtins): Set ieee128_float_type_node to
	float128_type_node.
	(rs6000_floatn_mode): New function.

gcc/c:
2016-06-21  Joseph Myers  <joseph@codesourcery.com>

	PR c/32187
	* c-tree.h (cts_floatn_nx): New enum c_typespec_keyword value.
	(struct c_declspecs): Add field floatn_nx_idx.
	* c-decl.c (declspecs_add_type, finish_declspecs): Handle _FloatN
	and _FloatNx type specifiers.
	* c-parser.c (c_token_starts_typename, c_token_starts_declspecs)
	(c_parser_declspecs, c_parser_attribute_any_word)
	(c_parser_objc_selector): Use CASE_RID_FLOATN_NX.
	* c-typeck.c (c_common_type): Handle _FloatN and _FloatNx types.
	(convert_arguments): Avoid promoting _FloatN and _FloatNx types
	narrower than double.

gcc/c-family:
2016-06-21  Joseph Myers  <joseph@codesourcery.com>

	PR c/32187
	* c-common.h (RID_FLOAT16, RID_FLOATN_NX_FIRST, RID_FLOAT32)
	(RID_FLOAT64, RID_FLOAT128, RID_FLOAT32X, RID_FLOAT64X)
	(RID_FLOAT128X): New enum rid values.
	(CASE_RID_FLOATN_NX): New macro.
	* c-common.c (c_common_reswords): Add _FloatN and _FloatNx
	keywords.
	(c_common_type_for_mode): Check for _FloatN and _FloatNx and
	corresponding complex types.
	(c_common_nodes_and_builtins): For non-C++, register _FloatN and
	_FloatNx and corresponding complex types.
	(keyword_begins_type_specifier): Use CASE_RID_FLOATN_NX.
	* c-cppbuiltin.c (builtin_define_float_constants): Check _FloatN
	and _FloatNx types for the widest type for determining
	DECIMAL_DIG.  Define __LDBL_DECIMAL_DIG__ as well as
	__DECIMAL_DIG__ for long double.  Handle FMA_SUFFIX being NULL.
	(c_cpp_builtins): Call builtin_define_float_constants for _FloatN
	and _FloatNx types.
	* c-lex.c (interpret_float): Handle _FloatN and _FloatNx
	constants.
	* c-pretty-print.c (pp_c_floating_constant): Handle _FloatN and
	_FloatNx types.

gcc/fortran:
2016-06-21  Joseph Myers  <joseph@codesourcery.com>

	PR c/32187
	* trans-types.h (float128_type_node): Rename to
	gfc_float128_type_node.
	(complex_float128_type_node): Rename to
	gfc_complex_float128_type_node.
	* iso-c-binding.def, trans-intrinsic.c, trans-types.c: All users
	changed.

gcc/testsuite:
2016-06-21  Joseph Myers  <joseph@codesourcery.com>

	PR c/32187
	* lib/target-supports.exp (check_effective_target_float16)
	(check_effective_target_float32, check_effective_target_float64)
	(check_effective_target_float128, check_effective_target_float32x)
	(check_effective_target_float64x)
	(check_effective_target_float128x): New procedures.
	* gcc.dg/dfp/floatn.c, gcc.dg/floatn-arithconv.c,
	gcc.dg/floatn-errs.c, gcc.dg/torture/float128-basic.c,
	gcc.dg/torture/float128-complex.c,
	gcc.dg/torture/float128-floath.c, gcc.dg/torture/float128-tg.c,
	gcc.dg/torture/float128x-basic.c,
	gcc.dg/torture/float128x-complex.c,
	gcc.dg/torture/float128x-floath.c, gcc.dg/torture/float128x-tg.c,
	gcc.dg/torture/float16-basic.c, gcc.dg/torture/float16-complex.c,
	gcc.dg/torture/float16-floath.c, gcc.dg/torture/float16-tg.c,
	gcc.dg/torture/float32-basic.c, gcc.dg/torture/float32-complex.c,
	gcc.dg/torture/float32-floath.c, gcc.dg/torture/float32-tg.c,
	gcc.dg/torture/float32x-basic.c,
	gcc.dg/torture/float32x-complex.c,
	gcc.dg/torture/float32x-floath.c, gcc.dg/torture/float32x-tg.c,
	gcc.dg/torture/float64-basic.c, gcc.dg/torture/float64-complex.c,
	gcc.dg/torture/float64-floath.c, gcc.dg/torture/float64-tg.c,
	gcc.dg/torture/float64x-basic.c,
	gcc.dg/torture/float64x-complex.c,
	gcc.dg/torture/float64x-floath.c, gcc.dg/torture/float64x-tg.c,
	gcc.dg/torture/floatn-basic.h, gcc.dg/torture/floatn-complex.h,
	gcc.dg/torture/floatn-convert.c, gcc.dg/torture/floatn-floath.h,
	gcc.dg/torture/floatn-tg.h,
	gcc.dg/torture/fp-int-convert-float128-ieee-timode.c,
	gcc.dg/torture/fp-int-convert-float128-ieee.c,
	gcc.dg/torture/fp-int-convert-float128x-timode.c,
	gcc.dg/torture/fp-int-convert-float128x.c,
	gcc.dg/torture/fp-int-convert-float16-timode.c,
	gcc.dg/torture/fp-int-convert-float16.c,
	gcc.dg/torture/fp-int-convert-float32-timode.c,
	gcc.dg/torture/fp-int-convert-float32.c,
	gcc.dg/torture/fp-int-convert-float32x-timode.c,
	gcc.dg/torture/fp-int-convert-float32x.c,
	gcc.dg/torture/fp-int-convert-float64-timode.c,
	gcc.dg/torture/fp-int-convert-float64.c,
	gcc.dg/torture/fp-int-convert-float64x-timode.c,
	gcc.dg/torture/fp-int-convert-float64x.c: New tests.

libcpp:
2016-06-21  Joseph Myers  <joseph@codesourcery.com>

	PR c/32187
	* include/cpplib.h (CPP_N_FLOATN, CPP_N_FLOATNX)
	(CPP_N_WIDTH_FLOATN_NX, CPP_FLOATN_SHIFT, CPP_FLOATN_MAX): New
	macros.
	* expr.c (interpret_float_suffix): Handle fN, fNx, FN and FNx
	suffixes.

Comments

FX June 21, 2016, 3:17 p.m. | #1
> Fortran note: I took the conservative approach of renaming the
> float128_type_node used in the Fortran front end, since I wasn't sure
> if it's safe to make the front end always use the language-independent
> node (which follows C rules - thus, being distinct from long double
> even if that has binary128 format).

In the Fortran front-end, float128_type_node is defined as the (expectedly unique) floating-point type for which mode_precision is equal to 128 but not equal to LONG_DOUBLE_TYPE_SIZE. That is, it is garanteed that float128_type_node is not long_double_type_node.

If fact, if there is a long double type with precision of 128, then float128_type_node is NULL.

Would that match the (new) C behavior? I think it does.

FX
Bill Schmidt June 21, 2016, 3:21 p.m. | #2
Hi Joseph,

I haven't read through the patch in detail yet, but thank you for the very thorough description!  For PowerPC, we currently have a lot invested in having __float128 correspond to KFmode for the time being, during the transition while supporting both IEEE-128 and IBM long double.  (I was not aware of the problem with q-suffix constants being treated as TFmode, which will need to be fixed.)  I'm currently in process of developing the minimal set of *f128 built-ins required for glibc, using __float128 and KFmode.

Can we please keep this correspondence for now?  Do you foresee any further concerns with staying on that path until we can fully throw the switch to move away from IBM long double?

Thanks,
Bill

> On Jun 21, 2016, at 7:06 AM, Joseph Myers <joseph@codesourcery.com> wrote:
> 
> ISO/IEC TS 18661-3:2015 defines C bindings to IEEE interchange and
> extended types, in the form of _FloatN and _FloatNx type names with
> corresponding fN/FN and fNx/FNx constant suffixes and FLTN_* / FLTNX_*
> <float.h> macros.  This patch implements support for this feature in
> GCC.
> 
> The _FloatN types, for N = 16, 32, 64 or >= 128 and a multiple of 32,
> are types encoded according to the corresponding IEEE interchange
> format (endianness unspecified).  The _FloatNx types, for N = 32, 64
> and 128, are IEEE "extended" types: types extending a narrower format
> with range and precision at least as big as those specified in IEEE
> 754 for each extended type (and with unspecified representation, but
> still following IEEE semantics for their values and operations - and
> with the set of values being determined by the precision and the
> maximum exponent, which means that while Intel "extended" is suitable
> for _Float64x, m68k "extended" is not).  These types are always
> distinct from and not compatible with each other and the standard
> floating types float, double, long double; thus, double, _Float64 and
> _Float32x may all have the same ABI, but they are three still distinct
> types.  The type names may be used with _Complex to construct
> corresponding complex types (unlike __float128, which acts more like a
> typedef name than a keyword - thus, this patch may be considered to
> fix PR c/32187).  The new suffixes can be combined with GNU "i" and
> "j" suffixes for constants of complex types (e.g. 1.0if128, 2.0f64i).
> 
> The set of types supported is implementation-defined.  In this GCC
> patch, _Float32 is SFmode if that is suitable; _Float32x and _Float64
> are DFmode if that is suitable; _Float128 is TFmode if that is
> suitable; _Float64x is XFmode if that is suitable, and otherwise
> TFmode if that is suitable.  There is a target hook to override the
> choices if necessary.  "Suitable" means both conforming to the
> requirements of that type, and supported as a scalar type including in
> libgcc.  The ABI is whatever the back end does for scalars of that
> mode (but note that _Float32 is passed without promotion in variable
> arguments, unlike float).  All the existing issues with exceptions and
> rounding modes for existing types apply equally to the new type names.
> 
> No GCC port supports a floating-point format suitable for _Float128x.
> Although there is HFmode support for ARM and AArch64, use of that for
> _Float16 is not enabled.  Supporting _Float16 would require additional
> work on the excess precision aspects of TS 18661-3: there are new
> values of FLT_EVAL_METHOD, which are not currently supported in GCC,
> and FLT_EVAL_METHOD == 0 now means that operations and constants on
> types narrower than float are evaluated to the range and precision of
> float.  Implementing that, so that _Float16 gets evaluated with excess
> range and precision, would involve changes to the excess precision
> infrastructure so that the _Float16 case is enabled by default, unlike
> the x87 case which is only enabled for -fexcess-precision=standard.
> Other differences between _Float16 and __fp16 would also need to be
> disentangled.
> 
> GCC has some prior support for nonstandard floating-point types in the
> form of __float80 and __float128.  Where these were previously types
> distinct from long double, they are made by this patch into aliases
> for _Float64x / _Float128 if those types have the required properties.
> 
> In principle the set of possible _FloatN types is infinite.  This
> patch hardcodes the four such types for N <= 128, but with as much
> code as possible using loops over types to minimize the number of
> places with such hardcoding.  I don't think it's likely any further
> such types will be of use in future (or indeed that formats suitable
> for _Float128x will actually be implemented).  There is a corner case
> that all _FloatN, for N >= 128 and a multiple of 32, should be treated
> as keywords even when the corresponding type is not supported; I
> intend to deal with that in a followup patch.
> 
> Tests are added for various functionality of the new types, mostly
> using type-generic headers.  PowerPC maintainers should note that the
> tests do not do anything regarding passing special options to enable
> support for the types, either for the tests themselves or for the
> corresponding effective-target tests.  Thus, to run the _Float128
> tests on PowerPC, you will need to add such support, { dg-add-options
> float128 } or similar and make sure it affects both the
> effective-target tests and the tests themselves.  The complex
> arithmetic support in libgcc will also be needed, as otherwise the
> associated tests will fail.  (The same would apply to _Float16 on ARM
> as well if that were enabled with -mfp16-format=ieee required to use
> it.  Of course, -mfp16-format=alternative enables use of a format
> which is not compatible with the requirements of the _Float16 type.)
> 
> C++ note: no support for the new types or constant suffixes is added
> for C++.  C++ decimal floating-point support was very different from
> the C support, using class types, and the same may well apply to any
> future C++ bindings for IEEE interchange and extended types.  There is
> a case, however, for supporting at least *f128 constants in C++, so
> that code using __float128 can use the newer style for constants
> throughout rather than needing to use the older *q constants in C++.
> Also, if built-in functions are added that may provide a way in which
> the types could leak into C++ code.
> 
> Fortran note: I took the conservative approach of renaming the
> float128_type_node used in the Fortran front end, since I wasn't sure
> if it's safe to make the front end always use the language-independent
> node (which follows C rules - thus, being distinct from long double
> even if that has binary128 format).
> 
> PowerPC note: the back end had an inconsistency that if TFmode was
> binary128, *q constants were TFmode instead of KFmode but __float128
> was KFmode.  This patch follows the same logic as for *q constants, so
> that _Float128 prefers TFmode (and __float128 becomes an alias for
> _Float128), but if the KFmode-preferring logic of __float128 is
> preferred, of course that can be used (and then I think *q constants
> should be fixed to match).
> 
> ARM note: __fp16 is promoted to double (by convert_arguments) when
> passed without a prototype / in variable arguments.  But this is only
> about the argument promotion; it is not handled as promoting in
> c-common.c:self_promoting_args_p / c-typeck.c:c_type_promotes_to,
> meaning that a K&R function definition for an argument of type __fp16
> corresponds to a prototype with an argument of that type, not to one
> with an argument of type double, whereas a float argument in a K&R
> function definition corresponds to a double prototype argument - and
> the same functions are also what's involved in making va_arg give a
> warning and generate a call to abort when called with type float.
> This is preserved by this patch, while arranging for _Float16 not to
> be promoted when passed without a prototype / in variable arguments
> (the promotion of float being considered a legacy feature, not applied
> to any new types in C99 or later).
> 
> TS 18661-3 extends the set of decimal floating-point types similarly,
> and adds new constant suffixes for the existing types, but this patch
> does not do anything regarding that extension.
> 
> This patch does nothing regarding built-in functions, although
> type-generic functions such as __builtin_isinf work for the new types
> and associated tests are included.  There are at least two levels of
> built-in function support possible for these types.  The minimal
> level, which I may implement in a followup patch, adds built-in
> functions similar to those x86 has for __float128: __builtin_inf*
> __builtin_huge_val*, __builtin_nan*, __builtin_nans*, __builtin_fabs*,
> __builtin_copysign*.  That would be sufficient for glibc to use the
> *f128 names for built-in functions by default with *q used only for
> backwards compatibility when using older GCC versions.  That would
> also allow c_cpp_builtins's flag_building_libgcc code, defining
> __LIBGCC_%s_FUNC_EXT__, to use such suffixes rather than the present
> code hardcoding logic about target-specific constant suffixes and how
> those relate to function suffixes.
> 
> Full built-in function support would cover the full range of built-in
> functions for existing floating-point types, adding variants for all
> the new types, except for a few obsolescent functions and
> non-type-generic variants of type-generic functions.  Some but not all
> references to such functions in GCC use macros such as CASE_FLT_FN to
> be type-generic; a fair amount of work would be needed to identify all
> places to update.  Adding all those functions would enable
> optimizations (for constant arguments and otherwise) for TS 18661-3
> functions, but it would also substantially expand the enum listing
> built-in functions (and we've had problems with the size of that enum
> in the past), and increase the amount of built-in function
> initialization to do - I don't know what the startup cost involved in
> built-in function initialization is, but it would be something to
> consider when adding such a large set of functions.
> 
> There are also a range of optimizations, in match.pd and elsewhere,
> that only operate on the three standard floating-point types.  Ideally
> those would be made generic to all floating-point types, but this
> patch does nothing in that regard.  Special care would be needed
> regarding making sure library functions to which calls are generated
> actually exist.  For example, if sqrt is called on an argument of type
> _Float32, and the result converted to _Float32, this is equivalent to
> doing a square root operation directly on _Float32.  But if the user's
> libm does not have the sqrtf32 function, or the name is not reserved
> because __STDC_WANT_IEC_60559_TYPES_EXT__ was not defined before
> including <math.h>, you can only do that optimization if you convert
> to a call to sqrtf instead.
> 
> DECIMAL_DIG now relates to all supported floating-point formats, not
> just float, double and long double; I've raised the question with WG14
> of how this relates to the formula for DECIMAL_DIG in C11 not
> considering this.  TS 18661-3 says it also covers non-arithmetic
> formats only supported by library conversion functions; this patch
> does not add any target hooks to allow for the case where there are
> such formats wider than any supported for arithmetic types (where
> e.g. libc supports conversions involving the binary128 representation,
> but the _Float128 type is not supported).
> 
> GCC provides its own <tgmath.h> for some targets.  No attempt is made
> to adapt this to handle the new types.
> 
> Nothing is done regarding debug info for the new types (see the
> "Debugger support for __float128 type?" thread on gcc@, Sep/Oct 2015).
> 
> No __SIZEOF_*__ macros are added for the new types.
> 
> Nothing is done with do_warn_double_promotion.
> 
> Nothing is done to include the new types in those determining
> max_align_t, although properly it should be sufficiently aligned for
> any of those types.
> 
> The logic for usual arithmetic conversions in c_common_type relies on
> TYPE_PRECISION for floating-point types, which is less than ideal
> (doesn't necessarily correspond to whether one type's values are
> subset of another); looking in more detail at the formats might be
> better.  But since I included code in build_common_tree_nodes to work
> around rs6000 KFmode having precision 113 not 128, I think it should
> work.  Ideally one might have errors in generic code for the case
> where the two types do not have one type's values a subset of the
> other (which is undefined behavior).  But the only case where this can
> actually occur is mixing IBM long double with binary128 on powerpc,
> and rs6000_invalid_binary_op deals with that at present.  TS 18661-3
> does not fully specify the type resulting from the usual arithmetic
> conversions in the case where two _FloatNx types have the same set of
> values; I arranged the code to prefer the greater value of N in that
> case.
> 
> The __FP_FAST_FMA* macros are not extended to cover the new types,
> since there are no corresponding built-in functions (if built-in
> fmafN, fmafNx are added, the macros should be extended, and the new
> macros documented).  Also, only a limited set of modes is handled in
> mode_has_fma.
> 
> Diagnostics relating to the use of the new types with -pedantic do not
> try to distinguish them from purely nonstandard types such as __int128
> and constant suffixes such as *q.
> 
> If you use an unsupported _FloatN / _FloatNx type you get a warning
> about the type defaulting to int after the warning about the type not
> being supported.  That's less than ideal, but it's also a pre-existing
> condition if you use __int128 on a 32-bit system where it's
> unsupported.
> 
> Bootstrapped with no regressions on x86_64-pc-linux-gnu.  Other
> back-end changes minimally tested by building cc1 for ia64-linux-gnu,
> powerpc64le-linux-gnu, pdp11-none (the last failed for unrelated
> reasons).  OK to commit (non-C-front-end parts)?
> 
> gcc:
> 2016-06-21  Joseph Myers  <joseph@codesourcery.com>
> 
> 	PR c/32187
> 	* tree-core.h (TI_COMPLEX_FLOAT16_TYPE)
> 	(TI_COMPLEX_FLOATN_NX_TYPE_FIRST, TI_COMPLEX_FLOAT32_TYPE)
> 	(TI_COMPLEX_FLOAT64_TYPE, TI_COMPLEX_FLOAT128_TYPE)
> 	(TI_COMPLEX_FLOAT32X_TYPE, TI_COMPLEX_FLOAT64X_TYPE)
> 	(TI_COMPLEX_FLOAT128X_TYPE, TI_FLOAT16_TYPE, TI_FLOATN_TYPE_FIRST)
> 	(TI_FLOATN_NX_TYPE_FIRST, TI_FLOAT32_TYPE, TI_FLOAT64_TYPE)
> 	(TI_FLOAT128_TYPE, TI_FLOATN_TYPE_LAST, TI_FLOAT32X_TYPE)
> 	(TI_FLOATNX_TYPE_FIRST, TI_FLOAT64X_TYPE, TI_FLOAT128X_TYPE)
> 	(TI_FLOATNX_TYPE_LAST, TI_FLOATN_NX_TYPE_LAST): New enum
> 	tree_index values.
> 	(NUM_FLOATN_TYPES, NUM_FLOATNX_TYPES, NUM_FLOATN_NX_TYPES): New
> 	macros.
> 	(struct floatn_type_info): New structure type.
> 	(floatn_nx_types): New variable declaration.
> 	* tree.h (FLOATN_TYPE_NODE, FLOATN_NX_TYPE_NODE)
> 	(FLOATNX_TYPE_NODE, float128_type_node, float64x_type_node)
> 	(COMPLEX_FLOATN_NX_TYPE_NODE): New macros.
> 	* tree.c (floatn_nx_types): New variable.
> 	(build_common_tree_nodes): Initialize _FloatN, _FloatNx and
> 	corresponding complex types.
> 	* target.def (floatn_mode): New hook.
> 	* targhooks.c: Include "real.h".
> 	(default_floatn_mode): New function.
> 	* targhooks.h (default_floatn_mode): New prototype.
> 	* doc/extend.texi (Floating Types): Document _FloatN and _FloatNx
> 	types.
> 	* doc/sourcebuild.texi (float@var{n}, float@var{n}x): Document new
> 	effective-target keywords.
> 	* doc/tm.texi.in (TARGET_FLOATN_MODE): New @hook.
> 	* doc/tm.texi: Regenerate.
> 	* ginclude/float.h (LDBL_DECIMAL_DIG): Define to
> 	__LDBL_DECIMAL_DIG__, not __DECIMAL_DIG__.
> 	[__STDC_WANT_IEC_60559_TYPES_EXT__]: Define macros from TS
> 	18661-3.
> 	* real.h (struct real_format): Add field ieee_bits.
> 	* real.c (ieee_single_format, mips_single_format)
> 	(motorola_single_format, spu_single_format, ieee_double_format)
> 	(mips_double_format, motorola_double_format)
> 	(ieee_extended_motorola_format, ieee_extended_intel_96_format)
> 	(ieee_extended_intel_128_format)
> 	(ieee_extended_intel_96_round_53_format, ibm_extended_format)
> 	(mips_extended_format, ieee_quad_format, mips_quad_format)
> 	(vax_f_format, vax_d_format, vax_g_format, decimal_single_format)
> 	(decimal_double_format, decimal_quad_format, ieee_half_format)
> 	(arm_half_format, real_internal_format: Initialize ieee_bits
> 	field.
> 	* config/i386/i386.c (ix86_init_builtin_types): Do not initialize
> 	float128_type_node.  Set float80_type_node to float64x_type_node
> 	if appropriate and long_double_type_node not appropriate.
> 	* config/ia64/ia64.c (ia64_init_builtins): Likewise.
> 	* config/pdp11/pdp11.c (pdp11_f_format, pdp11_d_format):
> 	Initialize ieee_bits field.
> 	* config/rs6000/rs6000.c (TARGET_FLOATN_MODE): New macro.
> 	(rs6000_init_builtins): Set ieee128_float_type_node to
> 	float128_type_node.
> 	(rs6000_floatn_mode): New function.
> 
> gcc/c:
> 2016-06-21  Joseph Myers  <joseph@codesourcery.com>
> 
> 	PR c/32187
> 	* c-tree.h (cts_floatn_nx): New enum c_typespec_keyword value.
> 	(struct c_declspecs): Add field floatn_nx_idx.
> 	* c-decl.c (declspecs_add_type, finish_declspecs): Handle _FloatN
> 	and _FloatNx type specifiers.
> 	* c-parser.c (c_token_starts_typename, c_token_starts_declspecs)
> 	(c_parser_declspecs, c_parser_attribute_any_word)
> 	(c_parser_objc_selector): Use CASE_RID_FLOATN_NX.
> 	* c-typeck.c (c_common_type): Handle _FloatN and _FloatNx types.
> 	(convert_arguments): Avoid promoting _FloatN and _FloatNx types
> 	narrower than double.
> 
> gcc/c-family:
> 2016-06-21  Joseph Myers  <joseph@codesourcery.com>
> 
> 	PR c/32187
> 	* c-common.h (RID_FLOAT16, RID_FLOATN_NX_FIRST, RID_FLOAT32)
> 	(RID_FLOAT64, RID_FLOAT128, RID_FLOAT32X, RID_FLOAT64X)
> 	(RID_FLOAT128X): New enum rid values.
> 	(CASE_RID_FLOATN_NX): New macro.
> 	* c-common.c (c_common_reswords): Add _FloatN and _FloatNx
> 	keywords.
> 	(c_common_type_for_mode): Check for _FloatN and _FloatNx and
> 	corresponding complex types.
> 	(c_common_nodes_and_builtins): For non-C++, register _FloatN and
> 	_FloatNx and corresponding complex types.
> 	(keyword_begins_type_specifier): Use CASE_RID_FLOATN_NX.
> 	* c-cppbuiltin.c (builtin_define_float_constants): Check _FloatN
> 	and _FloatNx types for the widest type for determining
> 	DECIMAL_DIG.  Define __LDBL_DECIMAL_DIG__ as well as
> 	__DECIMAL_DIG__ for long double.  Handle FMA_SUFFIX being NULL.
> 	(c_cpp_builtins): Call builtin_define_float_constants for _FloatN
> 	and _FloatNx types.
> 	* c-lex.c (interpret_float): Handle _FloatN and _FloatNx
> 	constants.
> 	* c-pretty-print.c (pp_c_floating_constant): Handle _FloatN and
> 	_FloatNx types.
> 
> gcc/fortran:
> 2016-06-21  Joseph Myers  <joseph@codesourcery.com>
> 
> 	PR c/32187
> 	* trans-types.h (float128_type_node): Rename to
> 	gfc_float128_type_node.
> 	(complex_float128_type_node): Rename to
> 	gfc_complex_float128_type_node.
> 	* iso-c-binding.def, trans-intrinsic.c, trans-types.c: All users
> 	changed.
> 
> gcc/testsuite:
> 2016-06-21  Joseph Myers  <joseph@codesourcery.com>
> 
> 	PR c/32187
> 	* lib/target-supports.exp (check_effective_target_float16)
> 	(check_effective_target_float32, check_effective_target_float64)
> 	(check_effective_target_float128, check_effective_target_float32x)
> 	(check_effective_target_float64x)
> 	(check_effective_target_float128x): New procedures.
> 	* gcc.dg/dfp/floatn.c, gcc.dg/floatn-arithconv.c,
> 	gcc.dg/floatn-errs.c, gcc.dg/torture/float128-basic.c,
> 	gcc.dg/torture/float128-complex.c,
> 	gcc.dg/torture/float128-floath.c, gcc.dg/torture/float128-tg.c,
> 	gcc.dg/torture/float128x-basic.c,
> 	gcc.dg/torture/float128x-complex.c,
> 	gcc.dg/torture/float128x-floath.c, gcc.dg/torture/float128x-tg.c,
> 	gcc.dg/torture/float16-basic.c, gcc.dg/torture/float16-complex.c,
> 	gcc.dg/torture/float16-floath.c, gcc.dg/torture/float16-tg.c,
> 	gcc.dg/torture/float32-basic.c, gcc.dg/torture/float32-complex.c,
> 	gcc.dg/torture/float32-floath.c, gcc.dg/torture/float32-tg.c,
> 	gcc.dg/torture/float32x-basic.c,
> 	gcc.dg/torture/float32x-complex.c,
> 	gcc.dg/torture/float32x-floath.c, gcc.dg/torture/float32x-tg.c,
> 	gcc.dg/torture/float64-basic.c, gcc.dg/torture/float64-complex.c,
> 	gcc.dg/torture/float64-floath.c, gcc.dg/torture/float64-tg.c,
> 	gcc.dg/torture/float64x-basic.c,
> 	gcc.dg/torture/float64x-complex.c,
> 	gcc.dg/torture/float64x-floath.c, gcc.dg/torture/float64x-tg.c,
> 	gcc.dg/torture/floatn-basic.h, gcc.dg/torture/floatn-complex.h,
> 	gcc.dg/torture/floatn-convert.c, gcc.dg/torture/floatn-floath.h,
> 	gcc.dg/torture/floatn-tg.h,
> 	gcc.dg/torture/fp-int-convert-float128-ieee-timode.c,
> 	gcc.dg/torture/fp-int-convert-float128-ieee.c,
> 	gcc.dg/torture/fp-int-convert-float128x-timode.c,
> 	gcc.dg/torture/fp-int-convert-float128x.c,
> 	gcc.dg/torture/fp-int-convert-float16-timode.c,
> 	gcc.dg/torture/fp-int-convert-float16.c,
> 	gcc.dg/torture/fp-int-convert-float32-timode.c,
> 	gcc.dg/torture/fp-int-convert-float32.c,
> 	gcc.dg/torture/fp-int-convert-float32x-timode.c,
> 	gcc.dg/torture/fp-int-convert-float32x.c,
> 	gcc.dg/torture/fp-int-convert-float64-timode.c,
> 	gcc.dg/torture/fp-int-convert-float64.c,
> 	gcc.dg/torture/fp-int-convert-float64x-timode.c,
> 	gcc.dg/torture/fp-int-convert-float64x.c: New tests.
> 
> libcpp:
> 2016-06-21  Joseph Myers  <joseph@codesourcery.com>
> 
> 	PR c/32187
> 	* include/cpplib.h (CPP_N_FLOATN, CPP_N_FLOATNX)
> 	(CPP_N_WIDTH_FLOATN_NX, CPP_FLOATN_SHIFT, CPP_FLOATN_MAX): New
> 	macros.
> 	* expr.c (interpret_float_suffix): Handle fN, fNx, FN and FNx
> 	suffixes.
> 
> Index: gcc/c/c-decl.c
> ===================================================================
> --- gcc/c/c-decl.c	(revision 237622)
> +++ gcc/c/c-decl.c	(working copy)
> @@ -9642,6 +9642,14 @@ declspecs_add_type (location_t loc, struct c_decls
> 		error_at (loc,
> 			  ("both %<long%> and %<float%> in "
> 			   "declaration specifiers"));
> +	      else if (specs->typespec_word == cts_floatn_nx)
> +		error_at (loc,
> +			  ("both %<long%> and %<_Float%d%s%> in "
> +			   "declaration specifiers"),
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
> 	      else if (specs->typespec_word == cts_dfloat32)
> 		error_at (loc,
> 			  ("both %<long%> and %<_Decimal32%> in "
> @@ -9695,6 +9703,14 @@ declspecs_add_type (location_t loc, struct c_decls
> 		error_at (loc,
> 			  ("both %<short%> and %<double%> in "
> 			   "declaration specifiers"));
> +	      else if (specs->typespec_word == cts_floatn_nx)
> +		error_at (loc,
> +			  ("both %<short%> and %<_Float%d%s%> in "
> +			   "declaration specifiers"),
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
> 	      else if (specs->typespec_word == cts_dfloat32)
>                 error_at (loc,
> 			  ("both %<short%> and %<_Decimal32%> in "
> @@ -9739,6 +9755,14 @@ declspecs_add_type (location_t loc, struct c_decls
> 		error_at (loc,
> 			  ("both %<signed%> and %<double%> in "
> 			   "declaration specifiers"));
> +	      else if (specs->typespec_word == cts_floatn_nx)
> +		error_at (loc,
> +			  ("both %<signed%> and %<_Float%d%s%> in "
> +			   "declaration specifiers"),
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
> 	      else if (specs->typespec_word == cts_dfloat32)
> 		error_at (loc,
> 			  ("both %<signed%> and %<_Decimal32%> in "
> @@ -9783,6 +9807,14 @@ declspecs_add_type (location_t loc, struct c_decls
> 		error_at (loc,
> 			  ("both %<unsigned%> and %<double%> in "
> 			   "declaration specifiers"));
> +	      else if (specs->typespec_word == cts_floatn_nx)
> +		error_at (loc,
> +			  ("both %<unsigned%> and %<_Float%d%s%> in "
> +			   "declaration specifiers"),
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
>               else if (specs->typespec_word == cts_dfloat32)
> 		error_at (loc,
> 			  ("both %<unsigned%> and %<_Decimal32%> in "
> @@ -9887,6 +9919,14 @@ declspecs_add_type (location_t loc, struct c_decls
> 		error_at (loc,
> 			  ("both %<_Sat%> and %<double%> in "
> 			   "declaration specifiers"));
> +	      else if (specs->typespec_word == cts_floatn_nx)
> +		error_at (loc,
> +			  ("both %<_Sat%> and %<_Float%d%s%> in "
> +			   "declaration specifiers"),
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
>               else if (specs->typespec_word == cts_dfloat32)
> 		error_at (loc,
> 			  ("both %<_Sat%> and %<_Decimal32%> in "
> @@ -9920,8 +9960,9 @@ declspecs_add_type (location_t loc, struct c_decls
> 	}
>       else
> 	{
> -	  /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
> -	     "__intN", "_Decimal64", "_Decimal128", "_Fract", "_Accum" or
> +	  /* "void", "_Bool", "char", "int", "float", "double",
> +	     "_FloatN", "_FloatNx", "_Decimal32", "__intN",
> +	     "_Decimal64", "_Decimal128", "_Fract", "_Accum" or
> 	     "__auto_type".  */
> 	  if (specs->typespec_word != cts_none)
> 	    {
> @@ -10146,6 +10187,69 @@ declspecs_add_type (location_t loc, struct c_decls
> 		  specs->locations[cdw_typespec] = loc;
> 		}
> 	      return specs;
> +	    CASE_RID_FLOATN_NX:
> +	      specs->floatn_nx_idx = i - RID_FLOATN_NX_FIRST;
> +	      if (!in_system_header_at (input_location))
> +		pedwarn (loc, OPT_Wpedantic,
> +			 "ISO C does not support the %<_Float%d%s%> type",
> +			 floatn_nx_types[specs->floatn_nx_idx].n,
> +			 (floatn_nx_types[specs->floatn_nx_idx].extended
> +			  ? "x"
> +			  : ""));
> +
> +	      if (specs->long_p)
> +		error_at (loc,
> +			  ("both %<long%> and %<_Float%d%s%> in "
> +			   "declaration specifiers"),
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
> +	      else if (specs->short_p)
> +		error_at (loc,
> +			  ("both %<short%> and %<_Float%d%s%> in "
> +			   "declaration specifiers"),
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
> +	      else if (specs->signed_p)
> +		error_at (loc,
> +			  ("both %<signed%> and %<_Float%d%s%> in "
> +			   "declaration specifiers"),
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
> +	      else if (specs->unsigned_p)
> +		error_at (loc,
> +			  ("both %<unsigned%> and %<_Float%d%s%> in "
> +			   "declaration specifiers"),
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
> +	      else if (specs->saturating_p)
> +		error_at (loc,
> +			  ("both %<_Sat%> and %<_Float%d%s%> in "
> +			   "declaration specifiers"),
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
> +	      else if (FLOATN_NX_TYPE_NODE (specs->floatn_nx_idx) == NULL_TREE)
> +		error_at (loc,
> +			  "%<_Float%d%s%> is not supported on this target",
> +			  floatn_nx_types[specs->floatn_nx_idx].n,
> +			  (floatn_nx_types[specs->floatn_nx_idx].extended
> +			   ? "x"
> +			   : ""));
> +	      else
> +		{
> +		  specs->typespec_word = cts_floatn_nx;
> +		  specs->locations[cdw_typespec] = loc;
> +		}
> +	      return specs;
> 	    case RID_DFLOAT32:
> 	    case RID_DFLOAT64:
> 	    case RID_DFLOAT128:
> @@ -10623,6 +10727,13 @@ finish_declspecs (struct c_declspecs *specs)
> 			 : double_type_node);
> 	}
>       break;
> +    case cts_floatn_nx:
> +      gcc_assert (!specs->long_p && !specs->short_p
> +		  && !specs->signed_p && !specs->unsigned_p);
> +      specs->type = (specs->complex_p
> +		     ? COMPLEX_FLOATN_NX_TYPE_NODE (specs->floatn_nx_idx)
> +		     : FLOATN_NX_TYPE_NODE (specs->floatn_nx_idx));
> +      break;
>     case cts_dfloat32:
>     case cts_dfloat64:
>     case cts_dfloat128:
> Index: gcc/c/c-parser.c
> ===================================================================
> --- gcc/c/c-parser.c	(revision 237622)
> +++ gcc/c/c-parser.c	(working copy)
> @@ -556,6 +556,7 @@ c_token_starts_typename (c_token *token)
> 	case RID_DFLOAT32:
> 	case RID_DFLOAT64:
> 	case RID_DFLOAT128:
> +	CASE_RID_FLOATN_NX:
> 	case RID_BOOL:
> 	case RID_ENUM:
> 	case RID_STRUCT:
> @@ -717,6 +718,7 @@ c_token_starts_declspecs (c_token *token)
> 	case RID_DFLOAT32:
> 	case RID_DFLOAT64:
> 	case RID_DFLOAT128:
> +	CASE_RID_FLOATN_NX:
> 	case RID_BOOL:
> 	case RID_ENUM:
> 	case RID_STRUCT:
> @@ -2488,6 +2490,7 @@ c_parser_declspecs (c_parser *parser, struct c_dec
> 	case RID_DFLOAT32:
> 	case RID_DFLOAT64:
> 	case RID_DFLOAT128:
> +	CASE_RID_FLOATN_NX:
> 	case RID_BOOL:
> 	case RID_FRACT:
> 	case RID_ACCUM:
> @@ -3949,6 +3952,7 @@ c_parser_attribute_any_word (c_parser *parser)
> 	case RID_DFLOAT32:
> 	case RID_DFLOAT64:
> 	case RID_DFLOAT128:
> +	CASE_RID_FLOATN_NX:
> 	case RID_BOOL:
> 	case RID_FRACT:
> 	case RID_ACCUM:
> @@ -9580,6 +9584,7 @@ c_parser_objc_selector (c_parser *parser)
>     case RID_CHAR:
>     case RID_FLOAT:
>     case RID_DOUBLE:
> +    CASE_RID_FLOATN_NX:
>     case RID_VOID:
>     case RID_BOOL:
>     case RID_ATOMIC:
> Index: gcc/c/c-tree.h
> ===================================================================
> --- gcc/c/c-tree.h	(revision 237622)
> +++ gcc/c/c-tree.h	(working copy)
> @@ -230,6 +230,7 @@ enum c_typespec_keyword {
>   cts_dfloat32,
>   cts_dfloat64,
>   cts_dfloat128,
> +  cts_floatn_nx,
>   cts_fract,
>   cts_accum,
>   cts_auto_type
> @@ -295,6 +296,9 @@ struct c_declspecs {
>   int align_log;
>   /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
>   int int_n_idx;
> +  /* For the _FloatN and _FloatNx declspec, this stores the index into
> +     the floatn_nx_types array.  */
> +  int floatn_nx_idx;
>   /* The storage class specifier, or csc_none if none.  */
>   enum c_storage_class storage_class;
>   /* Any type specifier keyword used such as "int", not reflecting
> Index: gcc/c/c-typeck.c
> ===================================================================
> --- gcc/c/c-typeck.c	(revision 237622)
> +++ gcc/c/c-typeck.c	(working copy)
> @@ -927,18 +927,41 @@ c_common_type (tree t1, tree t2)
> 	return long_integer_type_node;
>     }
> 
> +  /* For floating types of the same TYPE_PRECISION (which we here
> +     assume means either the same set of values, or sets of values
> +     neither a subset of the other, with behavior being undefined in
> +     the latter case), follow the rules from TS 18661-3: prefer
> +     interchange types _FloatN, then standard types long double,
> +     double, float, then extended types _FloatNx.  For extended types,
> +     check them starting with _Float128x as that seems most consistent
> +     in spirit with preferring long double to double; for interchange
> +     types, also check in that order for consistency although it's not
> +     possible for more than one of them to have the same
> +     precision.  */
> +  tree mv1 = TYPE_MAIN_VARIANT (t1);
> +  tree mv2 = TYPE_MAIN_VARIANT (t2);
> +
> +  for (int i = NUM_FLOATN_TYPES - 1; i >= 0; i--)
> +    if (mv1 == FLOATN_TYPE_NODE (i) || mv2 == FLOATN_TYPE_NODE (i))
> +      return FLOATN_TYPE_NODE (i);
> +
>   /* Likewise, prefer long double to double even if same size.  */
> -  if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
> -      || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
> +  if (mv1 == long_double_type_node || mv2 == long_double_type_node)
>     return long_double_type_node;
> 
>   /* Likewise, prefer double to float even if same size.
>      We got a couple of embedded targets with 32 bit doubles, and the
>      pdp11 might have 64 bit floats.  */
> -  if (TYPE_MAIN_VARIANT (t1) == double_type_node
> -      || TYPE_MAIN_VARIANT (t2) == double_type_node)
> +  if (mv1 == double_type_node || mv2 == double_type_node)
>     return double_type_node;
> 
> +  if (mv1 == float_type_node || mv2 == float_type_node)
> +    return float_type_node;
> +
> +  for (int i = NUM_FLOATNX_TYPES - 1; i >= 0; i--)
> +    if (mv1 == FLOATNX_TYPE_NODE (i) || mv2 == FLOATNX_TYPE_NODE (i))
> +      return FLOATNX_TYPE_NODE (i);
> +
>   /* Otherwise prefer the unsigned one.  */
> 
>   if (TYPE_UNSIGNED (t1))
> @@ -3283,6 +3306,30 @@ convert_arguments (location_t loc, vec<location_t>
> 
>       val = require_complete_type (ploc, val);
> 
> +      /* Some floating-point arguments must be promoted to double when
> +	 no type is specified by a prototype.  This applies to
> +	 arguments of type float, and to architecture-specific types
> +	 (ARM __fp16), but not to _FloatN or _FloatNx types.  */
> +      bool promote_float_arg = false;
> +      if (type == NULL_TREE
> +	  && TREE_CODE (valtype) == REAL_TYPE
> +	  && (TYPE_PRECISION (valtype)
> +	      <= TYPE_PRECISION (double_type_node))
> +	  && TYPE_MAIN_VARIANT (valtype) != double_type_node
> +	  && TYPE_MAIN_VARIANT (valtype) != long_double_type_node
> +	  && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
> +	{
> +	  /* Promote this argument, unless it has a _FloatN or
> +	     _FloatNx type.  */
> +	  promote_float_arg = true;
> +	  for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +	    if (TYPE_MAIN_VARIANT (valtype) == FLOATN_NX_TYPE_NODE (i))
> +	      {
> +		promote_float_arg = false;
> +		break;
> +	      }
> +	}
> +
>       if (type != 0)
> 	{
> 	  /* Formal parm type is specified by a function prototype.  */
> @@ -3449,12 +3496,7 @@ convert_arguments (location_t loc, vec<location_t>
> 		parmval = default_conversion (parmval);
> 	    }
> 	}
> -      else if (TREE_CODE (valtype) == REAL_TYPE
> -	       && (TYPE_PRECISION (valtype)
> -		   <= TYPE_PRECISION (double_type_node))
> -	       && TYPE_MAIN_VARIANT (valtype) != double_type_node
> -	       && TYPE_MAIN_VARIANT (valtype) != long_double_type_node
> -	       && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
> +      else if (promote_float_arg)
>         {
> 	  if (type_generic)
> 	    parmval = val;
> Index: gcc/c-family/c-common.c
> ===================================================================
> --- gcc/c-family/c-common.c	(revision 237622)
> +++ gcc/c-family/c-common.c	(working copy)
> @@ -430,6 +430,13 @@ const struct c_common_resword c_common_reswords[]
>   { "_Cilk_sync",       RID_CILK_SYNC,  0 },
>   { "_Cilk_for",        RID_CILK_FOR,   0 },
>   { "_Imaginary",	RID_IMAGINARY, D_CONLY },
> +  { "_Float16",         RID_FLOAT16,   D_CONLY },
> +  { "_Float32",         RID_FLOAT32,   D_CONLY },
> +  { "_Float64",         RID_FLOAT64,   D_CONLY },
> +  { "_Float128",        RID_FLOAT128,  D_CONLY },
> +  { "_Float32x",        RID_FLOAT32X,  D_CONLY },
> +  { "_Float64x",        RID_FLOAT64X,  D_CONLY },
> +  { "_Float128x",       RID_FLOAT128X, D_CONLY },
>   { "_Decimal32",       RID_DFLOAT32,  D_CONLY | D_EXT },
>   { "_Decimal64",       RID_DFLOAT64,  D_CONLY | D_EXT },
>   { "_Decimal128",      RID_DFLOAT128, D_CONLY | D_EXT },
> @@ -3408,6 +3415,11 @@ c_common_type_for_mode (machine_mode mode, int uns
>   if (mode == TYPE_MODE (long_double_type_node))
>     return long_double_type_node;
> 
> +  for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +    if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE
> +	&& mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i)))
> +      return FLOATN_NX_TYPE_NODE (i);
> +
>   if (mode == TYPE_MODE (void_type_node))
>     return void_type_node;
> 
> @@ -3433,6 +3445,11 @@ c_common_type_for_mode (machine_mode mode, int uns
>       if (mode == TYPE_MODE (complex_long_double_type_node))
> 	return complex_long_double_type_node;
> 
> +      for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +	if (COMPLEX_FLOATN_NX_TYPE_NODE (i) != NULL_TREE
> +	    && mode == TYPE_MODE (COMPLEX_FLOATN_NX_TYPE_NODE (i)))
> +	  return COMPLEX_FLOATN_NX_TYPE_NODE (i);
> +
>       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
> 	return complex_integer_type_node;
> 
> @@ -5349,6 +5366,12 @@ c_common_nodes_and_builtins (void)
>   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
>   record_builtin_type (RID_MAX, "long double", long_double_type_node);
> 
> +  if (!c_dialect_cxx ())
> +    for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +      if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE)
> +	record_builtin_type ((enum rid) (RID_FLOATN_NX_FIRST + i), NULL,
> +			     FLOATN_NX_TYPE_NODE (i));
> +
>   /* Only supported decimal floating point extension if the target
>      actually supports underlying modes. */
>   if (targetm.scalar_mode_supported_p (SDmode)
> @@ -5438,6 +5461,20 @@ c_common_nodes_and_builtins (void)
> 		 TYPE_DECL, get_identifier ("complex long double"),
> 		 complex_long_double_type_node));
> 
> +  if (!c_dialect_cxx ())
> +    for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +      if (COMPLEX_FLOATN_NX_TYPE_NODE (i) != NULL_TREE)
> +	{
> +	  char buf[30];
> +	  sprintf (buf, "complex _Float%d%s", floatn_nx_types[i].n,
> +		   floatn_nx_types[i].extended ? "x" : "");
> +	  lang_hooks.decls.pushdecl
> +	    (build_decl (UNKNOWN_LOCATION,
> +			 TYPE_DECL,
> +			 get_identifier (buf),
> +			 COMPLEX_FLOATN_NX_TYPE_NODE (i)));
> +	}
> +
>   if (c_dialect_cxx ())
>     /* For C++, make fileptr_type_node a distinct void * type until
>        FILE type is defined.  */
> @@ -12410,6 +12447,7 @@ keyword_begins_type_specifier (enum rid keyword)
>     case RID_LONG:
>     case RID_SHORT:
>     case RID_SIGNED:
> +    CASE_RID_FLOATN_NX:
>     case RID_DFLOAT32:
>     case RID_DFLOAT64:
>     case RID_DFLOAT128:
> Index: gcc/c-family/c-common.h
> ===================================================================
> --- gcc/c-family/c-common.h	(revision 237622)
> +++ gcc/c-family/c-common.h	(working copy)
> @@ -102,6 +102,20 @@ enum rid
>   RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL,      RID_CHOOSE_EXPR,
>   RID_TYPES_COMPATIBLE_P,      RID_BUILTIN_COMPLEX,	     RID_BUILTIN_SHUFFLE,
>   RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128,
> +
> +  /* TS 18661-3 keywords, in the same sequence as the TI_* values.  */
> +  RID_FLOAT16,
> +  RID_FLOATN_NX_FIRST = RID_FLOAT16,
> +  RID_FLOAT32,
> +  RID_FLOAT64,
> +  RID_FLOAT128,
> +  RID_FLOAT32X,
> +  RID_FLOAT64X,
> +  RID_FLOAT128X,
> +#define CASE_RID_FLOATN_NX						\
> +  case RID_FLOAT16: case RID_FLOAT32: case RID_FLOAT64: case RID_FLOAT128: \
> +  case RID_FLOAT32X: case RID_FLOAT64X: case RID_FLOAT128X
> +
>   RID_FRACT, RID_ACCUM, RID_AUTO_TYPE, RID_BUILTIN_CALL_WITH_STATIC_CHAIN,
> 
>   /* C11 */
> Index: gcc/c-family/c-cppbuiltin.c
> ===================================================================
> --- gcc/c-family/c-cppbuiltin.c	(revision 237622)
> +++ gcc/c-family/c-cppbuiltin.c	(working copy)
> @@ -125,7 +125,7 @@ builtin_define_float_constants (const char *name_p
>   const double log10_2 = .30102999566398119521;
>   double log10_b;
>   const struct real_format *fmt;
> -  const struct real_format *ldfmt;
> +  const struct real_format *widefmt;
> 
>   char name[64], buf[128];
>   int dig, min_10_exp, max_10_exp;
> @@ -134,8 +134,20 @@ builtin_define_float_constants (const char *name_p
> 
>   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
>   gcc_assert (fmt->b != 10);
> -  ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
> -  gcc_assert (ldfmt->b != 10);
> +  widefmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
> +  gcc_assert (widefmt->b != 10);
> +  for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +    {
> +      tree wtype = FLOATN_NX_TYPE_NODE (i);
> +      if (wtype != NULL_TREE)
> +	{
> +	  const struct real_format *wfmt
> +	    = REAL_MODE_FORMAT (TYPE_MODE (wtype));
> +	  gcc_assert (wfmt->b != 10);
> +	  if (wfmt->p > widefmt->p)
> +	    widefmt = wfmt;
> +	}
> +    }
> 
>   /* The radix of the exponent representation.  */
>   if (type == float_type_node)
> @@ -219,7 +231,7 @@ builtin_define_float_constants (const char *name_p
>      floating type, but we want this value for rendering constants below.  */
>   {
>     double d_decimal_dig
> -      = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b;
> +      = 1 + (fmt->p < widefmt->p ? widefmt->p : fmt->p) * log10_b;
>     decimal_dig = d_decimal_dig;
>     if (decimal_dig < d_decimal_dig)
>       decimal_dig++;
> @@ -231,13 +243,13 @@ builtin_define_float_constants (const char *name_p
>     if (type_decimal_dig < type_d_decimal_dig)
>       type_decimal_dig++;
>   }
> +  /* Arbitrarily, define __DECIMAL_DIG__ when defining macros for long
> +     double, although it may be greater than the value for long
> +     double.  */
>   if (type == long_double_type_node)
>     builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
> -  else
> -    {
> -      sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
> -      builtin_define_with_int_value (name, type_decimal_dig);
> -    }
> +  sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
> +  builtin_define_with_int_value (name, type_decimal_dig);
> 
>   /* Since, for the supported formats, B is always a power of 2, we
>      construct the following numbers directly as a hexadecimal
> @@ -289,7 +301,7 @@ builtin_define_float_constants (const char *name_p
>   builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
> 
>   /* Note whether we have fast FMA.  */
> -  if (mode_has_fma (TYPE_MODE (type)))
> +  if (mode_has_fma (TYPE_MODE (type)) && fma_suffix != NULL)
>     {
>       sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
>       builtin_define_with_int_value (name, 1);
> @@ -980,6 +992,19 @@ c_cpp_builtins (cpp_reader *pfile)
>   builtin_define_float_constants ("LDBL", "L", "%s", "L",
> 				  long_double_type_node);
> 
> +  for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +    {
> +      if (FLOATN_NX_TYPE_NODE (i) == NULL_TREE)
> +	continue;
> +      char prefix[20], csuffix[20];
> +      sprintf (prefix, "FLT%d%s", floatn_nx_types[i].n,
> +	       floatn_nx_types[i].extended ? "X" : "");
> +      sprintf (csuffix, "F%d%s", floatn_nx_types[i].n,
> +	       floatn_nx_types[i].extended ? "x" : "");
> +      builtin_define_float_constants (prefix, csuffix, "%s", NULL,
> +				      FLOATN_NX_TYPE_NODE (i));
> +    }
> +
>   /* For decfloat.h.  */
>   builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
>   builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
> Index: gcc/c-family/c-lex.c
> ===================================================================
> --- gcc/c-family/c-lex.c	(revision 237622)
> +++ gcc/c-family/c-lex.c	(working copy)
> @@ -839,6 +839,26 @@ interpret_float (const cpp_token *token, unsigned
> 	type = c_common_type_for_mode (mode, 0);
> 	gcc_assert (type);
>       }
> +    else if ((flags & (CPP_N_FLOATN | CPP_N_FLOATNX)) != 0)
> +      {
> +	unsigned int n = (flags & CPP_N_WIDTH_FLOATN_NX) >> CPP_FLOATN_SHIFT;
> +	bool extended = (flags & CPP_N_FLOATNX) != 0;
> +	type = NULL_TREE;
> +	for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +	  if (floatn_nx_types[i].n == (int) n
> +	      && floatn_nx_types[i].extended == extended)
> +	    {
> +	      type = FLOATN_NX_TYPE_NODE (i);
> +	      break;
> +	    }
> +	if (type == NULL_TREE)
> +	  {
> +	    error ("unsupported non-standard suffix on floating constant");
> +	    return error_mark_node;
> +	  }
> +	else
> +	  pedwarn (input_location, OPT_Wpedantic, "non-standard suffix on floating constant");
> +      }
>     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
>       type = long_double_type_node;
>     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
> @@ -867,6 +887,17 @@ interpret_float (const cpp_token *token, unsigned
>       if (flags & CPP_N_IMAGINARY)
> 	/* I or J suffix.  */
> 	copylen--;
> +      if (flags & CPP_N_FLOATNX)
> +	copylen--;
> +      if (flags & (CPP_N_FLOATN | CPP_N_FLOATNX))
> +	{
> +	  unsigned int n = (flags & CPP_N_WIDTH_FLOATN_NX) >> CPP_FLOATN_SHIFT;
> +	  while (n > 0)
> +	    {
> +	      copylen--;
> +	      n /= 10;
> +	    }
> +	}
>     }
> 
>   copy = (char *) alloca (copylen + 1);
> Index: gcc/c-family/c-pretty-print.c
> ===================================================================
> --- gcc/c-family/c-pretty-print.c	(revision 237622)
> +++ gcc/c-family/c-pretty-print.c	(working copy)
> @@ -1045,6 +1045,16 @@ pp_c_floating_constant (c_pretty_printer *pp, tree
>     pp_string (pp, "dd");
>   else if (TREE_TYPE (r) == dfloat32_type_node)
>     pp_string (pp, "df");
> +  else if (TREE_TYPE (r) != double_type_node)
> +    for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +      if (TREE_TYPE (r) == FLOATN_NX_TYPE_NODE (i))
> +	{
> +	  pp_character (pp, 'f');
> +	  pp_decimal_int (pp, floatn_nx_types[i].n);
> +	  if (floatn_nx_types[i].extended)
> +	    pp_character (pp, 'x');
> +	  break;
> +	}
> }
> 
> /* Print out a FIXED value as a decimal-floating-constant.  */
> Index: gcc/config/i386/i386.c
> ===================================================================
> --- gcc/config/i386/i386.c	(revision 237622)
> +++ gcc/config/i386/i386.c	(working copy)
> @@ -38275,24 +38275,29 @@ ix86_init_builtins_va_builtins_abi (void)
> static void
> ix86_init_builtin_types (void)
> {
> -  tree float128_type_node, float80_type_node, const_string_type_node;
> +  tree float80_type_node, const_string_type_node;
> 
>   /* The __float80 type.  */
>   float80_type_node = long_double_type_node;
>   if (TYPE_MODE (float80_type_node) != XFmode)
>     {
> -      /* The __float80 type.  */
> -      float80_type_node = make_node (REAL_TYPE);
> +      if (float64x_type_node != NULL_TREE
> +	  && TYPE_MODE (float64x_type_node) == XFmode)
> +	float80_type_node = float64x_type_node;
> +      else
> +	{
> +	  /* The __float80 type.  */
> +	  float80_type_node = make_node (REAL_TYPE);
> 
> -      TYPE_PRECISION (float80_type_node) = 80;
> -      layout_type (float80_type_node);
> +	  TYPE_PRECISION (float80_type_node) = 80;
> +	  layout_type (float80_type_node);
> +	}
>     }
>   lang_hooks.types.register_builtin_type (float80_type_node, "__float80");
> 
> -  /* The __float128 type.  */
> -  float128_type_node = make_node (REAL_TYPE);
> -  TYPE_PRECISION (float128_type_node) = 128;
> -  layout_type (float128_type_node);
> +  /* The __float128 type.  The node has already been created as
> +     _Float128, so we only need to register the __float128 name for
> +     it.  */
>   lang_hooks.types.register_builtin_type (float128_type_node, "__float128");
> 
>   const_string_type_node
> Index: gcc/config/ia64/ia64.c
> ===================================================================
> --- gcc/config/ia64/ia64.c	(revision 237622)
> +++ gcc/config/ia64/ia64.c	(working copy)
> @@ -10350,9 +10350,15 @@ ia64_init_builtins (void)
>   (*lang_hooks.types.register_builtin_type) (fpreg_type, "__fpreg");
> 
>   /* The __float80 type.  */
> -  float80_type = make_node (REAL_TYPE);
> -  TYPE_PRECISION (float80_type) = 80;
> -  layout_type (float80_type);
> +  if (float64x_type_node != NULL_TREE
> +      && TYPE_MODE (float64x_type_node) == XFmode)
> +    float80_type = float64x_type_node;
> +  else
> +    {
> +      float80_type = make_node (REAL_TYPE);
> +      TYPE_PRECISION (float80_type) = 80;
> +      layout_type (float80_type);
> +    }
>   (*lang_hooks.types.register_builtin_type) (float80_type, "__float80");
> 
>   /* The __float128 type.  */
> @@ -10362,14 +10368,12 @@ ia64_init_builtins (void)
>       tree const_string_type
> 	= build_pointer_type (build_qualified_type
> 			      (char_type_node, TYPE_QUAL_CONST));
> -      tree float128_type = make_node (REAL_TYPE);
> 
> -      TYPE_PRECISION (float128_type) = 128;
> -      layout_type (float128_type);
> -      (*lang_hooks.types.register_builtin_type) (float128_type, "__float128");
> +      (*lang_hooks.types.register_builtin_type) (float128_type_node,
> +						 "__float128");
> 
>       /* TFmode support builtins.  */
> -      ftype = build_function_type_list (float128_type, NULL_TREE);
> +      ftype = build_function_type_list (float128_type_node, NULL_TREE);
>       decl = add_builtin_function ("__builtin_infq", ftype,
> 				   IA64_BUILTIN_INFQ, BUILT_IN_MD,
> 				   NULL, NULL_TREE);
> @@ -10380,7 +10384,7 @@ ia64_init_builtins (void)
> 				   NULL, NULL_TREE);
>       ia64_builtins[IA64_BUILTIN_HUGE_VALQ] = decl;
> 
> -      ftype = build_function_type_list (float128_type,
> +      ftype = build_function_type_list (float128_type_node,
> 					const_string_type,
> 					NULL_TREE);
>       decl = add_builtin_function ("__builtin_nanq", ftype,
> @@ -10395,8 +10399,8 @@ ia64_init_builtins (void)
>       TREE_READONLY (decl) = 1;
>       ia64_builtins[IA64_BUILTIN_NANSQ] = decl;
> 
> -      ftype = build_function_type_list (float128_type,
> -					float128_type,
> +      ftype = build_function_type_list (float128_type_node,
> +					float128_type_node,
> 					NULL_TREE);
>       decl = add_builtin_function ("__builtin_fabsq", ftype,
> 				   IA64_BUILTIN_FABSQ, BUILT_IN_MD,
> @@ -10404,9 +10408,9 @@ ia64_init_builtins (void)
>       TREE_READONLY (decl) = 1;
>       ia64_builtins[IA64_BUILTIN_FABSQ] = decl;
> 
> -      ftype = build_function_type_list (float128_type,
> -					float128_type,
> -					float128_type,
> +      ftype = build_function_type_list (float128_type_node,
> +					float128_type_node,
> +					float128_type_node,
> 					NULL_TREE);
>       decl = add_builtin_function ("__builtin_copysignq", ftype,
> 				   IA64_BUILTIN_COPYSIGNQ, BUILT_IN_MD,
> Index: gcc/config/pdp11/pdp11.c
> ===================================================================
> --- gcc/config/pdp11/pdp11.c	(revision 237622)
> +++ gcc/config/pdp11/pdp11.c	(working copy)
> @@ -69,6 +69,7 @@ const struct real_format pdp11_f_format =
>     127,
>     15,
>     15,
> +    0,
>     false,
>     false,
>     false,
> @@ -91,6 +92,7 @@ const struct real_format pdp11_d_format =
>     127,
>     15,
>     15,
> +    0,
>     false,
>     false,
>     false,
> Index: gcc/config/rs6000/rs6000.c
> ===================================================================
> --- gcc/config/rs6000/rs6000.c	(revision 237622)
> +++ gcc/config/rs6000/rs6000.c	(working copy)
> @@ -1698,6 +1698,9 @@ static const struct attribute_spec rs6000_attribut
> #undef TARGET_VECTOR_MODE_SUPPORTED_P
> #define TARGET_VECTOR_MODE_SUPPORTED_P rs6000_vector_mode_supported_p
> 
> +#undef TARGET_FLOATN_MODE
> +#define TARGET_FLOATN_MODE rs6000_floatn_mode
> +
> #undef TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
> #define TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN invalid_arg_for_unprototyped_fn
> 
> @@ -15820,10 +15823,7 @@ rs6000_init_builtins (void)
>       layout_type (ibm128_float_type_node);
>       SET_TYPE_MODE (ibm128_float_type_node, IFmode);
> 
> -      ieee128_float_type_node = make_node (REAL_TYPE);
> -      TYPE_PRECISION (ieee128_float_type_node) = 128;
> -      layout_type (ieee128_float_type_node);
> -      SET_TYPE_MODE (ieee128_float_type_node, KFmode);
> +      ieee128_float_type_node = float128_type_node;
> 
>       lang_hooks.types.register_builtin_type (ieee128_float_type_node,
> 					      "__float128");
> @@ -35383,6 +35383,54 @@ rs6000_vector_mode_supported_p (machine_mode mode)
>     return false;
> }
> 
> +/* Target hook for floatn_mode.  */
> +static machine_mode
> +rs6000_floatn_mode (int n, bool extended)
> +{
> +  if (extended)
> +    {
> +      switch (n)
> +	{
> +	case 32:
> +	  return DFmode;
> +
> +	case 64:
> +	  if (TARGET_FLOAT128)
> +	    return (FLOAT128_IEEE_P (TFmode)) ? TFmode : KFmode;
> +	  else
> +	    return VOIDmode;
> +
> +	case 128:
> +	  return VOIDmode;
> +
> +	default:
> +	  /* Those are the only valid _FloatNx types.  */
> +	  gcc_unreachable ();
> +	}
> +    }
> +  else
> +    {
> +      switch (n)
> +	{
> +	case 32:
> +	  return SFmode;
> +
> +	case 64:
> +	  return DFmode;
> +
> +	case 128:
> +	  if (TARGET_FLOAT128)
> +	    return (FLOAT128_IEEE_P (TFmode)) ? TFmode : KFmode;
> +	  else
> +	    return VOIDmode;
> +
> +	default:
> +	  return VOIDmode;
> +	}
> +    }
> +
> +}
> +
> /* Target hook for c_mode_for_suffix.  */
> static machine_mode
> rs6000_c_mode_for_suffix (char suffix)
> Index: gcc/doc/extend.texi
> ===================================================================
> --- gcc/doc/extend.texi	(revision 237622)
> +++ gcc/doc/extend.texi	(working copy)
> @@ -927,6 +927,8 @@ examine and set these two fictitious variables wit
> @node Floating Types
> @section Additional Floating Types
> @cindex additional floating types
> +@cindex @code{_Float@var{n}} data types
> +@cindex @code{_Float@var{n}x} data types
> @cindex @code{__float80} data type
> @cindex @code{__float128} data type
> @cindex @code{__ibm128} data type
> @@ -935,9 +937,19 @@ examine and set these two fictitious variables wit
> @cindex @code{W} floating point suffix
> @cindex @code{Q} floating point suffix
> 
> -As an extension, GNU C supports additional floating
> +ISO/IEC TS 18661-3:2015 defines C support for additional floating
> +types @code{_Float@var{n}} and @code{_Float@var{n}x}, and GCC supports
> +these type names; the set of types supported depends on the target
> +architecture.  These types are not supported when compiling C++.
> +Constants with these types use suffixes @code{f@var{n}} or
> +@code{F@var{n}} and @code{f@var{n}x} or @code{F@var{n}x}.  These type
> +names can be used together with @code{_Complex} to declare complex
> +types.
> +
> +As an extension, GNU C and GNU C++ support additional floating
> types, @code{__float80} and @code{__float128} to support 80-bit
> -(@code{XFmode}) and 128-bit (@code{TFmode}) floating types.
> +(@code{XFmode}) and 128-bit (@code{TFmode}) floating types; these are
> +aliases for the type names @code{_Float64x} and @code{_Float128}.
> Support for additional types includes the arithmetic operators:
> add, subtract, multiply, divide; unary arithmetic operators;
> relational operators; equality operators; and conversions to and from
> @@ -954,9 +966,11 @@ typedef _Complex float __attribute__((mode(TC))) _
> typedef _Complex float __attribute__((mode(XC))) _Complex80;
> @end smallexample
> 
> -In order to use @code{__float128} and @code{__ibm128} on PowerPC Linux
> +In order to use @code{_Float128}, @code{__float128} and
> +@code{__ibm128} on PowerPC Linux
> systems, you must use the @option{-mfloat128}. It is expected in
> -future versions of GCC that @code{__float128} will be enabled
> +future versions of GCC that @code{_Float128} and @code{__float128}
> +will be enabled
> automatically.  In addition, there are currently problems in using the
> complex @code{__float128} type.  When these problems are fixed, you
> would use the following syntax to declare @code{_Complex128} to be a
> @@ -976,7 +990,14 @@ Not all targets support additional floating-point
> IA-64 targets.  The @code{__float128} type is supported on hppa HP-UX.
> The @code{__float128} type is supported on PowerPC 64-bit Linux
> systems by default if the vector scalar instruction set (VSX) is
> -enabled.
> +enabled.  The @code{_Float128} type is supported on all systems where
> +@code{__float128} is supported or where @code{long double} has the
> +IEEE binary128 format.  The @code{_Float64x} type is supported on all
> +systems where @code{__float128} is supported.  The @code{_Float32}
> +type is supported on all systems supporting IEEE binary32; the
> +@code{_Float64} and @code{Float32x} types are supported on all systems
> +supporting IEEE binary64.  GCC does not currently support
> +@code{_Float16} or @code{_Float128x} on any systems.
> 
> On the PowerPC, @code{__ibm128} provides access to the IBM extended
> double format, and it is intended to be used by the library functions
> Index: gcc/doc/sourcebuild.texi
> ===================================================================
> --- gcc/doc/sourcebuild.texi	(revision 237622)
> +++ gcc/doc/sourcebuild.texi	(working copy)
> @@ -1321,6 +1321,12 @@ Target supports array and structure sizes that are
> 
> @item 4byte_wchar_t
> Target has @code{wchar_t} that is at least 4 bytes.
> +
> +@item float@var{n}
> +Target has the @code{_Float@var{n}} type.
> +
> +@item float@var{n}x
> +Target has the @code{_Float@var{n}x} type.
> @end table
> 
> @subsubsection Fortran-specific attributes
> Index: gcc/doc/tm.texi
> ===================================================================
> --- gcc/doc/tm.texi	(revision 237622)
> +++ gcc/doc/tm.texi	(working copy)
> @@ -4269,6 +4269,24 @@ hook returns true for all of @code{SFmode}, @code{
> @code{XFmode} and @code{TFmode}, if such modes exist.
> @end deftypefn
> 
> +@deftypefn {Target Hook} machine_mode TARGET_FLOATN_MODE (int @var{n}, bool @var{extended})
> +Define this to return the machine mode to use for the type 
> +@code{_Float@var{n}}, if @var{extended} is false, or the type 
> +@code{_Float@var{n}x}, if @var{extended} is true.  If such a type 
> +is not supported, return @code{VOIDmode}.  The default version of this 
> +hook returns @code{SFmode} for @code{_Float32}, @code{DFmode} for 
> +@code{_Float64} and @code{_Float32x} and @code{TFmode} for 
> +@code{_Float128}, if those modes exist and satisfy the requirements for 
> +those types and pass @code{TARGET_SCALAR_MODE_SUPPORTED_P} and 
> +@code{TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P}; for @code{_Float64x}, it 
> +returns the first of @code{XFmode} and @code{TFmode} that exists and 
> +satisfies the same requirements; for other types, it returns 
> +@code{VOIDmode}.  The hook is only called for values of @var{n} and 
> +@var{extended} that are valid according to ISO/IEC TS 18661-3:2015; that 
> +is, @var{n} is one of 32, 64, 128, or, if @var{extended} is false, 16 or 
> +greater than 128 and a multiple of 32.
> +@end deftypefn
> +
> @deftypefn {Target Hook} bool TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P (machine_mode @var{mode})
> Define this to return nonzero for machine modes for which the port has
> small register classes.  If this target hook returns nonzero for a given
> Index: gcc/doc/tm.texi.in
> ===================================================================
> --- gcc/doc/tm.texi.in	(revision 237622)
> +++ gcc/doc/tm.texi.in	(working copy)
> @@ -3527,6 +3527,8 @@ stack.
> 
> @hook TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P
> 
> +@hook TARGET_FLOATN_MODE
> +
> @hook TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P
> 
> @node Scalar Return
> Index: gcc/fortran/iso-c-binding.def
> ===================================================================
> --- gcc/fortran/iso-c-binding.def	(revision 237622)
> +++ gcc/fortran/iso-c-binding.def	(working copy)
> @@ -115,8 +115,8 @@ NAMED_REALCST (ISOCBINDING_DOUBLE, "c_double", \
> NAMED_REALCST (ISOCBINDING_LONG_DOUBLE, "c_long_double", \
>                get_real_kind_from_node (long_double_type_node), GFC_STD_F2003)
> NAMED_REALCST (ISOCBINDING_FLOAT128, "c_float128", \
> -	       float128_type_node == NULL_TREE \
> -		  ? -4 : get_real_kind_from_node (float128_type_node), \
> +	       gfc_float128_type_node == NULL_TREE \
> +		  ? -4 : get_real_kind_from_node (gfc_float128_type_node), \
> 	       GFC_STD_GNU)
> NAMED_CMPXCST (ISOCBINDING_FLOAT_COMPLEX, "c_float_complex", \
>                get_real_kind_from_node (float_type_node), GFC_STD_F2003)
> @@ -125,8 +125,8 @@ NAMED_CMPXCST (ISOCBINDING_DOUBLE_COMPLEX, "c_doub
> NAMED_CMPXCST (ISOCBINDING_LONG_DOUBLE_COMPLEX, "c_long_double_complex", \
>                get_real_kind_from_node (long_double_type_node), GFC_STD_F2003)
> NAMED_CMPXCST (ISOCBINDING_FLOAT128_COMPLEX, "c_float128_complex", \
> -	       float128_type_node == NULL_TREE \
> -		  ? -4 : get_real_kind_from_node (float128_type_node), \
> +	       gfc_float128_type_node == NULL_TREE \
> +		  ? -4 : get_real_kind_from_node (gfc_float128_type_node), \
> 	       GFC_STD_GNU)
> 
> NAMED_LOGCST (ISOCBINDING_BOOL, "c_bool", \
> Index: gcc/fortran/trans-intrinsic.c
> ===================================================================
> --- gcc/fortran/trans-intrinsic.c	(revision 237622)
> +++ gcc/fortran/trans-intrinsic.c	(working copy)
> @@ -149,7 +149,7 @@ builtin_decl_for_precision (enum built_in_function
>     i = m->double_built_in;
>   else if (precision == TYPE_PRECISION (long_double_type_node))
>     i = m->long_double_built_in;
> -  else if (precision == TYPE_PRECISION (float128_type_node))
> +  else if (precision == TYPE_PRECISION (gfc_float128_type_node))
>     {
>       /* Special treatment, because it is not exactly a built-in, but
> 	 a library function.  */
> @@ -621,8 +621,8 @@ gfc_build_intrinsic_lib_fndecls (void)
> 
>     memset (quad_decls, 0, sizeof(tree) * (END_BUILTINS + 1));
> 
> -    type = float128_type_node;
> -    complex_type = complex_float128_type_node;
> +    type = gfc_float128_type_node;
> +    complex_type = gfc_complex_float128_type_node;
>     /* type (*) (type) */
>     func_1 = build_function_type_list (type, type, NULL_TREE);
>     /* int (*) (type) */
> Index: gcc/fortran/trans-types.c
> ===================================================================
> --- gcc/fortran/trans-types.c	(revision 237622)
> +++ gcc/fortran/trans-types.c	(working copy)
> @@ -62,8 +62,8 @@ tree pfunc_type_node;
> 
> tree gfc_charlen_type_node;
> 
> -tree float128_type_node = NULL_TREE;
> -tree complex_float128_type_node = NULL_TREE;
> +tree gfc_float128_type_node = NULL_TREE;
> +tree gfc_complex_float128_type_node = NULL_TREE;
> 
> bool gfc_real16_is_float128 = false;
> 
> @@ -902,7 +902,7 @@ gfc_init_types (void)
>       PUSH_TYPE (name_buf, type);
> 
>       if (gfc_real_kinds[index].c_float128)
> -	float128_type_node = type;
> +	gfc_float128_type_node = type;
> 
>       type = gfc_build_complex_type (type);
>       gfc_complex_types[index] = type;
> @@ -911,7 +911,7 @@ gfc_init_types (void)
>       PUSH_TYPE (name_buf, type);
> 
>       if (gfc_real_kinds[index].c_float128)
> -	complex_float128_type_node = type;
> +	gfc_complex_float128_type_node = type;
>     }
> 
>   for (index = 0; gfc_character_kinds[index].kind != 0; ++index)
> Index: gcc/fortran/trans-types.h
> ===================================================================
> --- gcc/fortran/trans-types.h	(revision 237622)
> +++ gcc/fortran/trans-types.h	(working copy)
> @@ -30,8 +30,8 @@ extern GTY(()) tree ppvoid_type_node;
> extern GTY(()) tree pvoid_type_node;
> extern GTY(()) tree prvoid_type_node;
> extern GTY(()) tree pchar_type_node;
> -extern GTY(()) tree float128_type_node;
> -extern GTY(()) tree complex_float128_type_node;
> +extern GTY(()) tree gfc_float128_type_node;
> +extern GTY(()) tree gfc_complex_float128_type_node;
> 
> /* This is the type used to hold the lengths of character variables.
>    It must be the same as the corresponding definition in gfortran.h.  */
> Index: gcc/ginclude/float.h
> ===================================================================
> --- gcc/ginclude/float.h	(revision 237622)
> +++ gcc/ginclude/float.h	(working copy)
> @@ -165,7 +165,7 @@ see the files COPYING3 and COPYING.RUNTIME respect
> #undef LDBL_DECIMAL_DIG
> #define FLT_DECIMAL_DIG		__FLT_DECIMAL_DIG__
> #define DBL_DECIMAL_DIG		__DBL_DECIMAL_DIG__
> -#define LDBL_DECIMAL_DIG	__DECIMAL_DIG__
> +#define LDBL_DECIMAL_DIG	__LDBL_DECIMAL_DIG__
> 
> /* Whether types support subnormal numbers.  */
> #undef FLT_HAS_SUBNORM
> @@ -185,6 +185,187 @@ see the files COPYING3 and COPYING.RUNTIME respect
> 
> #endif /* C11 */
> 
> +#ifdef __STDC_WANT_IEC_60559_TYPES_EXT__
> +/* Constants for _FloatN and _FloatNx types from TS 18661-3.  See
> +   comments above for their semantics.  */
> +
> +#ifdef __FLT16_MANT_DIG__
> +#undef FLT16_MANT_DIG
> +#define FLT16_MANT_DIG		__FLT16_MANT_DIG__
> +#undef FLT16_DIG
> +#define FLT16_DIG		__FLT16_DIG__
> +#undef FLT16_MIN_EXP
> +#define FLT16_MIN_EXP		__FLT16_MIN_EXP__
> +#undef FLT16_MIN_10_EXP
> +#define FLT16_MIN_10_EXP	__FLT16_MIN_10_EXP__
> +#undef FLT16_MAX_EXP
> +#define FLT16_MAX_EXP		__FLT16_MAX_EXP__
> +#undef FLT16_MAX_10_EXP
> +#define FLT16_MAX_10_EXP	__FLT16_MAX_10_EXP__
> +#undef FLT16_MAX
> +#define FLT16_MAX		__FLT16_MAX__
> +#undef FLT16_EPSILON
> +#define FLT16_EPSILON		__FLT16_EPSILON__
> +#undef FLT16_MIN
> +#define FLT16_MIN		__FLT16_MIN__
> +#undef FLT16_DECIMAL_DIG
> +#define FLT16_DECIMAL_DIG	__FLT16_DECIMAL_DIG__
> +#undef FLT16_TRUE_MIN
> +#define FLT16_TRUE_MIN		__FLT16_DENORM_MIN__
> +#endif /* __FLT16_MANT_DIG__.  */
> +
> +#ifdef __FLT32_MANT_DIG__
> +#undef FLT32_MANT_DIG
> +#define FLT32_MANT_DIG		__FLT32_MANT_DIG__
> +#undef FLT32_DIG
> +#define FLT32_DIG		__FLT32_DIG__
> +#undef FLT32_MIN_EXP
> +#define FLT32_MIN_EXP		__FLT32_MIN_EXP__
> +#undef FLT32_MIN_10_EXP
> +#define FLT32_MIN_10_EXP	__FLT32_MIN_10_EXP__
> +#undef FLT32_MAX_EXP
> +#define FLT32_MAX_EXP		__FLT32_MAX_EXP__
> +#undef FLT32_MAX_10_EXP
> +#define FLT32_MAX_10_EXP	__FLT32_MAX_10_EXP__
> +#undef FLT32_MAX
> +#define FLT32_MAX		__FLT32_MAX__
> +#undef FLT32_EPSILON
> +#define FLT32_EPSILON		__FLT32_EPSILON__
> +#undef FLT32_MIN
> +#define FLT32_MIN		__FLT32_MIN__
> +#undef FLT32_DECIMAL_DIG
> +#define FLT32_DECIMAL_DIG	__FLT32_DECIMAL_DIG__
> +#undef FLT32_TRUE_MIN
> +#define FLT32_TRUE_MIN		__FLT32_DENORM_MIN__
> +#endif /* __FLT32_MANT_DIG__.  */
> +
> +#ifdef __FLT64_MANT_DIG__
> +#undef FLT64_MANT_DIG
> +#define FLT64_MANT_DIG		__FLT64_MANT_DIG__
> +#undef FLT64_DIG
> +#define FLT64_DIG		__FLT64_DIG__
> +#undef FLT64_MIN_EXP
> +#define FLT64_MIN_EXP		__FLT64_MIN_EXP__
> +#undef FLT64_MIN_10_EXP
> +#define FLT64_MIN_10_EXP	__FLT64_MIN_10_EXP__
> +#undef FLT64_MAX_EXP
> +#define FLT64_MAX_EXP		__FLT64_MAX_EXP__
> +#undef FLT64_MAX_10_EXP
> +#define FLT64_MAX_10_EXP	__FLT64_MAX_10_EXP__
> +#undef FLT64_MAX
> +#define FLT64_MAX		__FLT64_MAX__
> +#undef FLT64_EPSILON
> +#define FLT64_EPSILON		__FLT64_EPSILON__
> +#undef FLT64_MIN
> +#define FLT64_MIN		__FLT64_MIN__
> +#undef FLT64_DECIMAL_DIG
> +#define FLT64_DECIMAL_DIG	__FLT64_DECIMAL_DIG__
> +#undef FLT64_TRUE_MIN
> +#define FLT64_TRUE_MIN		__FLT64_DENORM_MIN__
> +#endif /* __FLT64_MANT_DIG__.  */
> +
> +#ifdef __FLT128_MANT_DIG__
> +#undef FLT128_MANT_DIG
> +#define FLT128_MANT_DIG		__FLT128_MANT_DIG__
> +#undef FLT128_DIG
> +#define FLT128_DIG		__FLT128_DIG__
> +#undef FLT128_MIN_EXP
> +#define FLT128_MIN_EXP		__FLT128_MIN_EXP__
> +#undef FLT128_MIN_10_EXP
> +#define FLT128_MIN_10_EXP	__FLT128_MIN_10_EXP__
> +#undef FLT128_MAX_EXP
> +#define FLT128_MAX_EXP		__FLT128_MAX_EXP__
> +#undef FLT128_MAX_10_EXP
> +#define FLT128_MAX_10_EXP	__FLT128_MAX_10_EXP__
> +#undef FLT128_MAX
> +#define FLT128_MAX		__FLT128_MAX__
> +#undef FLT128_EPSILON
> +#define FLT128_EPSILON		__FLT128_EPSILON__
> +#undef FLT128_MIN
> +#define FLT128_MIN		__FLT128_MIN__
> +#undef FLT128_DECIMAL_DIG
> +#define FLT128_DECIMAL_DIG	__FLT128_DECIMAL_DIG__
> +#undef FLT128_TRUE_MIN
> +#define FLT128_TRUE_MIN		__FLT128_DENORM_MIN__
> +#endif /* __FLT128_MANT_DIG__.  */
> +
> +#ifdef __FLT32X_MANT_DIG__
> +#undef FLT32X_MANT_DIG
> +#define FLT32X_MANT_DIG		__FLT32X_MANT_DIG__
> +#undef FLT32X_DIG
> +#define FLT32X_DIG		__FLT32X_DIG__
> +#undef FLT32X_MIN_EXP
> +#define FLT32X_MIN_EXP		__FLT32X_MIN_EXP__
> +#undef FLT32X_MIN_10_EXP
> +#define FLT32X_MIN_10_EXP	__FLT32X_MIN_10_EXP__
> +#undef FLT32X_MAX_EXP
> +#define FLT32X_MAX_EXP		__FLT32X_MAX_EXP__
> +#undef FLT32X_MAX_10_EXP
> +#define FLT32X_MAX_10_EXP	__FLT32X_MAX_10_EXP__
> +#undef FLT32X_MAX
> +#define FLT32X_MAX		__FLT32X_MAX__
> +#undef FLT32X_EPSILON
> +#define FLT32X_EPSILON		__FLT32X_EPSILON__
> +#undef FLT32X_MIN
> +#define FLT32X_MIN		__FLT32X_MIN__
> +#undef FLT32X_DECIMAL_DIG
> +#define FLT32X_DECIMAL_DIG	__FLT32X_DECIMAL_DIG__
> +#undef FLT32X_TRUE_MIN
> +#define FLT32X_TRUE_MIN		__FLT32X_DENORM_MIN__
> +#endif /* __FLT32X_MANT_DIG__.  */
> +
> +#ifdef __FLT64X_MANT_DIG__
> +#undef FLT64X_MANT_DIG
> +#define FLT64X_MANT_DIG		__FLT64X_MANT_DIG__
> +#undef FLT64X_DIG
> +#define FLT64X_DIG		__FLT64X_DIG__
> +#undef FLT64X_MIN_EXP
> +#define FLT64X_MIN_EXP		__FLT64X_MIN_EXP__
> +#undef FLT64X_MIN_10_EXP
> +#define FLT64X_MIN_10_EXP	__FLT64X_MIN_10_EXP__
> +#undef FLT64X_MAX_EXP
> +#define FLT64X_MAX_EXP		__FLT64X_MAX_EXP__
> +#undef FLT64X_MAX_10_EXP
> +#define FLT64X_MAX_10_EXP	__FLT64X_MAX_10_EXP__
> +#undef FLT64X_MAX
> +#define FLT64X_MAX		__FLT64X_MAX__
> +#undef FLT64X_EPSILON
> +#define FLT64X_EPSILON		__FLT64X_EPSILON__
> +#undef FLT64X_MIN
> +#define FLT64X_MIN		__FLT64X_MIN__
> +#undef FLT64X_DECIMAL_DIG
> +#define FLT64X_DECIMAL_DIG	__FLT64X_DECIMAL_DIG__
> +#undef FLT64X_TRUE_MIN
> +#define FLT64X_TRUE_MIN		__FLT64X_DENORM_MIN__
> +#endif /* __FLT64X_MANT_DIG__.  */
> +
> +#ifdef __FLT128X_MANT_DIG__
> +#undef FLT128X_MANT_DIG
> +#define FLT128X_MANT_DIG	__FLT128X_MANT_DIG__
> +#undef FLT128X_DIG
> +#define FLT128X_DIG		__FLT128X_DIG__
> +#undef FLT128X_MIN_EXP
> +#define FLT128X_MIN_EXP		__FLT128X_MIN_EXP__
> +#undef FLT128X_MIN_10_EXP
> +#define FLT128X_MIN_10_EXP	__FLT128X_MIN_10_EXP__
> +#undef FLT128X_MAX_EXP
> +#define FLT128X_MAX_EXP		__FLT128X_MAX_EXP__
> +#undef FLT128X_MAX_10_EXP
> +#define FLT128X_MAX_10_EXP	__FLT128X_MAX_10_EXP__
> +#undef FLT128X_MAX
> +#define FLT128X_MAX		__FLT128X_MAX__
> +#undef FLT128X_EPSILON
> +#define FLT128X_EPSILON		__FLT128X_EPSILON__
> +#undef FLT128X_MIN
> +#define FLT128X_MIN		__FLT128X_MIN__
> +#undef FLT128X_DECIMAL_DIG
> +#define FLT128X_DECIMAL_DIG	__FLT128X_DECIMAL_DIG__
> +#undef FLT128X_TRUE_MIN
> +#define FLT128X_TRUE_MIN	__FLT128X_DENORM_MIN__
> +#endif /* __FLT128X_MANT_DIG__.  */
> +
> +#endif /* __STDC_WANT_IEC_60559_TYPES_EXT__.  */
> +
> #ifdef __STDC_WANT_DEC_FP__
> /* Draft Technical Report 24732, extension for decimal floating-point
>    arithmetic: Characteristic of decimal floating types <float.h>.  */
> Index: gcc/real.c
> ===================================================================
> --- gcc/real.c	(revision 237622)
> +++ gcc/real.c	(working copy)
> @@ -3042,6 +3042,7 @@ const struct real_format ieee_single_format =
>     128,
>     31,
>     31,
> +    32,
>     false,
>     true,
>     true,
> @@ -3064,6 +3065,7 @@ const struct real_format mips_single_format =
>     128,
>     31,
>     31,
> +    32,
>     false,
>     true,
>     true,
> @@ -3086,6 +3088,7 @@ const struct real_format motorola_single_format =
>     128,
>     31,
>     31,
> +    32,
>     false,
>     true,
>     true,
> @@ -3119,6 +3122,7 @@ const struct real_format spu_single_format =
>     129,
>     31,
>     31,
> +    0,
>     true,
>     false,
>     false,
> @@ -3329,6 +3333,7 @@ const struct real_format ieee_double_format =
>     1024,
>     63,
>     63,
> +    64,
>     false,
>     true,
>     true,
> @@ -3351,6 +3356,7 @@ const struct real_format mips_double_format =
>     1024,
>     63,
>     63,
> +    64,
>     false,
>     true,
>     true,
> @@ -3373,6 +3379,7 @@ const struct real_format motorola_double_format =
>     1024,
>     63,
>     63,
> +    64,
>     false,
>     true,
>     true,
> @@ -3718,6 +3725,7 @@ const struct real_format ieee_extended_motorola_fo
>     16384,
>     95,
>     95,
> +    0,
>     false,
>     true,
>     true,
> @@ -3740,6 +3748,7 @@ const struct real_format ieee_extended_intel_96_fo
>     16384,
>     79,
>     79,
> +    65,
>     false,
>     true,
>     true,
> @@ -3762,6 +3771,7 @@ const struct real_format ieee_extended_intel_128_f
>     16384,
>     79,
>     79,
> +    65,
>     false,
>     true,
>     true,
> @@ -3786,6 +3796,7 @@ const struct real_format ieee_extended_intel_96_ro
>     16384,
>     79,
>     79,
> +    33,
>     false,
>     true,
>     true,
> @@ -3875,6 +3886,7 @@ const struct real_format ibm_extended_format =
>     1024,
>     127,
>     -1,
> +    0,
>     false,
>     true,
>     true,
> @@ -3897,6 +3909,7 @@ const struct real_format mips_extended_format =
>     1024,
>     127,
>     -1,
> +    0,
>     false,
>     true,
>     true,
> @@ -4161,6 +4174,7 @@ const struct real_format ieee_quad_format =
>     16384,
>     127,
>     127,
> +    128,
>     false,
>     true,
>     true,
> @@ -4183,6 +4197,7 @@ const struct real_format mips_quad_format =
>     16384,
>     127,
>     127,
> +    128,
>     false,
>     true,
>     true,
> @@ -4484,6 +4499,7 @@ const struct real_format vax_f_format =
>     127,
>     15,
>     15,
> +    0,
>     false,
>     false,
>     false,
> @@ -4506,6 +4522,7 @@ const struct real_format vax_d_format =
>     127,
>     15,
>     15,
> +    0,
>     false,
>     false,
>     false,
> @@ -4528,6 +4545,7 @@ const struct real_format vax_g_format =
>     1023,
>     15,
>     15,
> +    0,
>     false,
>     false,
>     false,
> @@ -4605,6 +4623,7 @@ const struct real_format decimal_single_format =
>     97,
>     31,
>     31,
> +    32,
>     false,
>     true,
>     true,
> @@ -4628,6 +4647,7 @@ const struct real_format decimal_double_format =
>     385,
>     63,
>     63,
> +    64,
>     false,
>     true,
>     true,
> @@ -4651,6 +4671,7 @@ const struct real_format decimal_quad_format =
>     6145,
>     127,
>     127,
> +    128,
>     false,
>     true,
>     true,
> @@ -4789,6 +4810,7 @@ const struct real_format ieee_half_format =
>     16,
>     15,
>     15,
> +    16,
>     false,
>     true,
>     true,
> @@ -4814,6 +4836,7 @@ const struct real_format arm_half_format =
>     17,
>     15,
>     15,
> +    0,
>     false,
>     true,
>     false,
> @@ -4860,6 +4883,7 @@ const struct real_format real_internal_format =
>     MAX_EXP,
>     -1,
>     -1,
> +    0,
>     false,
>     false,
>     true,
> Index: gcc/real.h
> ===================================================================
> --- gcc/real.h	(revision 237622)
> +++ gcc/real.h	(working copy)
> @@ -139,6 +139,17 @@ struct real_format
>      or -1 for a complex encoding.  */
>   int signbit_rw;
> 
> +  /* If this is an IEEE interchange format, the number of bits in the
> +     format; otherwise, if it is an IEEE extended format, one more
> +     than the greatest number of bits in an interchange format it
> +     extends; otherwise 0.  Formats need not follow the IEEE 754-2008
> +     recommended practice regarding how signaling NaNs are identified,
> +     and may vary in the choice of default NaN, but must follow other
> +     IEEE practice regarding having NaNs, infinities and subnormal
> +     values, and the relation of minimum and maximum exponents, and,
> +     for interchange formats, the details of the encoding.  */
> +  int ieee_bits;
> +
>   /* Default rounding mode for operations on this format.  */
>   bool round_towards_zero;
>   bool has_sign_dependent_rounding;
> Index: gcc/target.def
> ===================================================================
> --- gcc/target.def	(revision 237622)
> +++ gcc/target.def	(working copy)
> @@ -3326,6 +3326,26 @@ hook returns true for all of @code{SFmode}, @code{
>  bool, (machine_mode mode),
>  default_libgcc_floating_mode_supported_p)
> 
> +DEFHOOK
> +(floatn_mode,
> + "Define this to return the machine mode to use for the type \n\
> +@code{_Float@var{n}}, if @var{extended} is false, or the type \n\
> +@code{_Float@var{n}x}, if @var{extended} is true.  If such a type \n\
> +is not supported, return @code{VOIDmode}.  The default version of this \n\
> +hook returns @code{SFmode} for @code{_Float32}, @code{DFmode} for \n\
> +@code{_Float64} and @code{_Float32x} and @code{TFmode} for \n\
> +@code{_Float128}, if those modes exist and satisfy the requirements for \n\
> +those types and pass @code{TARGET_SCALAR_MODE_SUPPORTED_P} and \n\
> +@code{TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P}; for @code{_Float64x}, it \n\
> +returns the first of @code{XFmode} and @code{TFmode} that exists and \n\
> +satisfies the same requirements; for other types, it returns \n\
> +@code{VOIDmode}.  The hook is only called for values of @var{n} and \n\
> +@var{extended} that are valid according to ISO/IEC TS 18661-3:2015; that \n\
> +is, @var{n} is one of 32, 64, 128, or, if @var{extended} is false, 16 or \n\
> +greater than 128 and a multiple of 32.",
> + machine_mode, (int n, bool extended),
> + default_floatn_mode)
> +
> /* Compute cost of moving data from a register of class FROM to one of
>    TO, using MODE.  */
> DEFHOOK
> Index: gcc/targhooks.c
> ===================================================================
> --- gcc/targhooks.c	(revision 237622)
> +++ gcc/targhooks.c	(working copy)
> @@ -74,6 +74,7 @@ along with GCC; see the file COPYING3.  If not see
> #include "intl.h"
> #include "opts.h"
> #include "gimplify.h"
> +#include "real.h"
> 
> 
> bool
> @@ -459,6 +460,92 @@ default_libgcc_floating_mode_supported_p (machine_
>     }
> }
> 
> +/* Return the machine mode to use for the type _FloatN, if EXTENDED is
> +   false, or _FloatNx, if EXTENDED is true, or VOIDmode if not
> +   supported.  */
> +machine_mode
> +default_floatn_mode (int n, bool extended)
> +{
> +  if (extended)
> +    {
> +      machine_mode cand1 = VOIDmode, cand2 = VOIDmode;
> +      switch (n)
> +	{
> +	case 32:
> +#ifdef HAVE_DFmode
> +	  cand1 = DFmode;
> +#endif
> +	  break;
> +
> +	case 64:
> +#ifdef HAVE_XFmode
> +	  cand1 = XFmode;
> +#endif
> +#ifdef HAVE_TFmode
> +	  cand2 = TFmode;
> +#endif
> +	  break;
> +
> +	case 128:
> +	  break;
> +
> +	default:
> +	  /* Those are the only valid _FloatNx types.  */
> +	  gcc_unreachable ();
> +	}
> +      if (cand1 != VOIDmode
> +	  && REAL_MODE_FORMAT (cand1)->ieee_bits > n
> +	  && targetm.scalar_mode_supported_p (cand1)
> +	  && targetm.libgcc_floating_mode_supported_p (cand1))
> +	return cand1;
> +      if (cand2 != VOIDmode
> +	  && REAL_MODE_FORMAT (cand2)->ieee_bits > n
> +	  && targetm.scalar_mode_supported_p (cand2)
> +	  && targetm.libgcc_floating_mode_supported_p (cand2))
> +	return cand2;
> +    }
> +  else
> +    {
> +      machine_mode cand = VOIDmode;
> +      switch (n)
> +	{
> +	case 16:
> +	  /* We do not use HFmode for _Float16 by default because the
> +	     required excess precision support is not present and the
> +	     interactions with promotion of the older __fp16 need to
> +	     be worked out.  */
> +	  break;
> +
> +	case 32:
> +#ifdef HAVE_SFmode
> +	  cand = SFmode;
> +#endif
> +	  break;
> +
> +	case 64:
> +#ifdef HAVE_DFmode
> +	  cand = DFmode;
> +#endif
> +	  break;
> +
> +	case 128:
> +#ifdef HAVE_TFmode
> +	  cand = TFmode;
> +#endif
> +	  break;
> +
> +	default:
> +	  break;
> +	}
> +      if (cand != VOIDmode
> +	  && REAL_MODE_FORMAT (cand)->ieee_bits == n
> +	  && targetm.scalar_mode_supported_p (cand)
> +	  && targetm.libgcc_floating_mode_supported_p (cand))
> +	return cand;
> +    }
> +  return VOIDmode;
> +}
> +
> /* Make some target macros useable by target-independent code.  */
> bool
> targhook_words_big_endian (void)
> Index: gcc/targhooks.h
> ===================================================================
> --- gcc/targhooks.h	(revision 237622)
> +++ gcc/targhooks.h	(working copy)
> @@ -73,6 +73,7 @@ extern tree default_mangle_assembler_name (const c
> 
> extern bool default_scalar_mode_supported_p (machine_mode);
> extern bool default_libgcc_floating_mode_supported_p (machine_mode);
> +extern machine_mode default_floatn_mode (int, bool);
> extern bool targhook_words_big_endian (void);
> extern bool targhook_float_words_big_endian (void);
> extern bool default_float_exceptions_rounding_supported_p (void);
> Index: gcc/testsuite/gcc.dg/dfp/floatn.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/dfp/floatn.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/dfp/floatn.c	(working copy)
> @@ -0,0 +1,18 @@
> +/* Tests for _FloatN / _FloatNx types: test erroneous mixing with DFP.  */
> +/* { dg-do compile } */
> +/* { dg-require-effective-target float32 } */
> +/* { dg-require-effective-target float32x } */
> +/* { dg-options "" } */
> +
> +_Decimal32 d32;
> +_Float32 f32;
> +_Float32x f32x;
> +int i;
> +
> +void
> +f (void)
> +{
> +  (void) (d32 + f32); /* { dg-error "mix operands" } */
> +  (void) (f32x * d32); /* { dg-error "mix operands" } */
> +  (void) (i ? d32 : f32); /* { dg-error "mix operands" } */
> +}
> Index: gcc/testsuite/gcc.dg/floatn-arithconv.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/floatn-arithconv.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/floatn-arithconv.c	(working copy)
> @@ -0,0 +1,47 @@
> +/* Tests for _FloatN / _FloatNx types: test usual arithmetic
> +   conversions.  */
> +/* { dg-do compile } */
> +/* { dg-require-effective-target float32 } */
> +/* { dg-require-effective-target float64 } */
> +/* { dg-require-effective-target float32x } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +
> +int i;
> +
> +#define TEST(VAR, TYPE1, TYPE2, RESTYPE)			\
> +  do								\
> +    {								\
> +      typedef __typeof__ ((TYPE1) 0 + (TYPE2) 1) restype;	\
> +      typedef __typeof__ (i ? (TYPE1) 0 : (TYPE2) 1) restype2;	\
> +      typedef RESTYPE exptype;					\
> +      extern restype VAR;					\
> +      extern restype2 VAR;					\
> +      extern exptype VAR;					\
> +    }								\
> +  while (0)
> +
> +void
> +f (void)
> +{
> +  TEST (v1, float, double, double);
> +#if DBL_MANT_DIG > FLT32_MANT_DIG
> +  TEST (v2, double, _Float32, double);
> +#endif
> +#if DBL_MANT_DIG <= FLT64_MANT_DIG
> +  TEST (v3, double, _Float64, _Float64);
> +#endif
> +#if DBL_MANT_DIG >= FLT32X_MANT_DIG
> +  TEST (v4, double, _Float32x, double);
> +#endif
> +#if FLT_MANT_DIG <= FLT32_MANT_DIG
> +  TEST (v5, float, _Float32, _Float32);
> +#endif
> +#if FLT32X_MANT_DIG <= FLT64_MANT_DIG
> +  TEST (v6, _Float32x, _Float64, _Float64);
> +#endif
> +  TEST (v7, _Float32, _Float64, _Float64);
> +  TEST (v8, _Float32, _Float32x, _Float32x);
> +}
> Index: gcc/testsuite/gcc.dg/floatn-errs.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/floatn-errs.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/floatn-errs.c	(working copy)
> @@ -0,0 +1,41 @@
> +/* Tests for _FloatN / _FloatNx types: test erroneous code.  */
> +/* { dg-do compile } */
> +/* { dg-require-effective-target float32 } */
> +/* { dg-require-effective-target float32x } */
> +/* { dg-require-effective-target float64 } */
> +/* { dg-options "" } */
> +
> +/* _FloatN, _FloatNx and standard types are incompatible even if they
> +   have the same ABI.  */
> +
> +extern float a; /* { dg-message "previous declaration" } */
> +extern _Float32 a; /* { dg-error "conflicting" } */
> +
> +extern double b; /* { dg-message "previous declaration" } */
> +extern _Float32x b; /* { dg-error "conflicting" } */
> +
> +extern _Float64 c; /* { dg-message "previous declaration" } */
> +extern _Float32x c; /* { dg-error "conflicting" } */
> +
> +/* These types are not promoted in old-style function definitions.  */
> +
> +void f (_Float32);
> +void
> +f (x)
> +     _Float32 x;
> +{
> +}
> +
> +void g (double); /* { dg-error "prototype declaration" } */
> +void
> +g (x)
> +     _Float32 x; /* { dg-error "match prototype" } */
> +{
> +}
> +
> +void h (_Float64); /* { dg-error "prototype declaration" } */
> +void
> +h (x)
> +     _Float32 x; /* { dg-error "match prototype" } */
> +{
> +}
> Index: gcc/testsuite/gcc.dg/torture/float128-basic.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float128-basic.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float128-basic.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float128.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 128
> +#define EXT 0
> +#include "floatn-basic.h"
> Index: gcc/testsuite/gcc.dg/torture/float128-complex.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float128-complex.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float128-complex.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float128 complex arithmetic.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 128
> +#define EXT 0
> +#include "floatn-complex.h"
> Index: gcc/testsuite/gcc.dg/torture/float128-floath.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float128-floath.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float128-floath.c	(working copy)
> @@ -0,0 +1,60 @@
> +/* Test _Float128 <float.h> macros.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 128
> +#define EXT 0
> +#include "floatn-floath.h"
> +
> +#ifndef FLT128_MANT_DIG
> +# error "FLT128_MANT_DIG undefined"
> +#endif
> +
> +#ifndef FLT128_DECIMAL_DIG
> +# error "FLT128_DECIMAL_DIG undefined"
> +#endif
> +
> +#ifndef FLT128_DIG
> +# error "FLT128_DIG undefined"
> +#endif
> +
> +#ifndef FLT128_MIN_EXP
> +# error "FLT128_MIN_EXP undefined"
> +#endif
> +
> +#ifndef FLT128_MIN_10_EXP
> +# error "FLT128_MIN_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT128_MAX_EXP
> +# error "FLT128_MAX_EXP undefined"
> +#endif
> +
> +#ifndef FLT128_MAX_10_EXP
> +# error "FLT128_MAX_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT128_MAX
> +# error "FLT128_MAX undefined"
> +#endif
> +
> +#ifndef FLT128_EPSILON
> +# error "FLT128_EPSILON undefined"
> +#endif
> +
> +#ifndef FLT128_MIN
> +# error "FLT128_MIN undefined"
> +#endif
> +
> +#ifndef FLT128_TRUE_MIN
> +# error "FLT128_TRUE_MIN undefined"
> +#endif
> +
> +#if FLT128_DECIMAL_DIG > DECIMAL_DIG
> +# error "FLT128_DECIMAL_DIG > DECIMAL_DIG"
> +#endif
> +
> +#if FLT128_MANT_DIG != 113 || FLT128_MAX_EXP != 16384 || FLT128_MIN_EXP != -16381
> +# error "_Float128 bad format"
> +#endif
> Index: gcc/testsuite/gcc.dg/torture/float128-tg.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float128-tg.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float128-tg.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float128 type-generic built-in functions.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 128
> +#define EXT 0
> +#include "floatn-tg.h"
> Index: gcc/testsuite/gcc.dg/torture/float128x-basic.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float128x-basic.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float128x-basic.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float128x.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 128
> +#define EXT 1
> +#include "floatn-basic.h"
> Index: gcc/testsuite/gcc.dg/torture/float128x-complex.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float128x-complex.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float128x-complex.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float128x complex arithmetic.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 128
> +#define EXT 1
> +#include "floatn-complex.h"
> Index: gcc/testsuite/gcc.dg/torture/float128x-floath.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float128x-floath.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float128x-floath.c	(working copy)
> @@ -0,0 +1,60 @@
> +/* Test _Float128x <float.h> macros.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 128
> +#define EXT 1
> +#include "floatn-floath.h"
> +
> +#ifndef FLT128X_MANT_DIG
> +# error "FLT128X_MANT_DIG undefined"
> +#endif
> +
> +#ifndef FLT128X_DECIMAL_DIG
> +# error "FLT128X_DECIMAL_DIG undefined"
> +#endif
> +
> +#ifndef FLT128X_DIG
> +# error "FLT128X_DIG undefined"
> +#endif
> +
> +#ifndef FLT128X_MIN_EXP
> +# error "FLT128X_MIN_EXP undefined"
> +#endif
> +
> +#ifndef FLT128X_MIN_10_EXP
> +# error "FLT128X_MIN_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT128X_MAX_EXP
> +# error "FLT128X_MAX_EXP undefined"
> +#endif
> +
> +#ifndef FLT128X_MAX_10_EXP
> +# error "FLT128X_MAX_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT128X_MAX
> +# error "FLT128X_MAX undefined"
> +#endif
> +
> +#ifndef FLT128X_EPSILON
> +# error "FLT128X_EPSILON undefined"
> +#endif
> +
> +#ifndef FLT128X_MIN
> +# error "FLT128X_MIN undefined"
> +#endif
> +
> +#ifndef FLT128X_TRUE_MIN
> +# error "FLT128X_TRUE_MIN undefined"
> +#endif
> +
> +#if FLT128X_DECIMAL_DIG > DECIMAL_DIG
> +# error "FLT128X_DECIMAL_DIG > DECIMAL_DIG"
> +#endif
> +
> +#if FLT128X_MANT_DIG < 128 || FLT128X_MAX_EXP < 65536 || FLT128X_MIN_EXP + FLT128X_MAX_EXP != 3
> +# error "_Float128x bad format"
> +#endif
> Index: gcc/testsuite/gcc.dg/torture/float128x-tg.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float128x-tg.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float128x-tg.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float128x type-generic built-in functions.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 128
> +#define EXT 1
> +#include "floatn-tg.h"
> Index: gcc/testsuite/gcc.dg/torture/float16-basic.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float16-basic.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float16-basic.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float16.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float16 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 16
> +#define EXT 0
> +#include "floatn-basic.h"
> Index: gcc/testsuite/gcc.dg/torture/float16-complex.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float16-complex.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float16-complex.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float16 complex arithmetic.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float16 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 16
> +#define EXT 0
> +#include "floatn-complex.h"
> Index: gcc/testsuite/gcc.dg/torture/float16-floath.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float16-floath.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float16-floath.c	(working copy)
> @@ -0,0 +1,60 @@
> +/* Test _Float16 <float.h> macros.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float16 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 16
> +#define EXT 0
> +#include "floatn-floath.h"
> +
> +#ifndef FLT16_MANT_DIG
> +# error "FLT16_MANT_DIG undefined"
> +#endif
> +
> +#ifndef FLT16_DECIMAL_DIG
> +# error "FLT16_DECIMAL_DIG undefined"
> +#endif
> +
> +#ifndef FLT16_DIG
> +# error "FLT16_DIG undefined"
> +#endif
> +
> +#ifndef FLT16_MIN_EXP
> +# error "FLT16_MIN_EXP undefined"
> +#endif
> +
> +#ifndef FLT16_MIN_10_EXP
> +# error "FLT16_MIN_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT16_MAX_EXP
> +# error "FLT16_MAX_EXP undefined"
> +#endif
> +
> +#ifndef FLT16_MAX_10_EXP
> +# error "FLT16_MAX_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT16_MAX
> +# error "FLT16_MAX undefined"
> +#endif
> +
> +#ifndef FLT16_EPSILON
> +# error "FLT16_EPSILON undefined"
> +#endif
> +
> +#ifndef FLT16_MIN
> +# error "FLT16_MIN undefined"
> +#endif
> +
> +#ifndef FLT16_TRUE_MIN
> +# error "FLT16_TRUE_MIN undefined"
> +#endif
> +
> +#if FLT16_DECIMAL_DIG > DECIMAL_DIG
> +# error "FLT16_DECIMAL_DIG > DECIMAL_DIG"
> +#endif
> +
> +#if FLT16_MANT_DIG != 11 || FLT16_MAX_EXP != 16 || FLT16_MIN_EXP != -13
> +# error "_Float16 bad format"
> +#endif
> Index: gcc/testsuite/gcc.dg/torture/float16-tg.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float16-tg.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float16-tg.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float16 type-generic built-in functions.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float16 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 16
> +#define EXT 0
> +#include "floatn-tg.h"
> Index: gcc/testsuite/gcc.dg/torture/float32-basic.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float32-basic.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float32-basic.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float32.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 32
> +#define EXT 0
> +#include "floatn-basic.h"
> Index: gcc/testsuite/gcc.dg/torture/float32-complex.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float32-complex.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float32-complex.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float32 complex arithmetic.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 32
> +#define EXT 0
> +#include "floatn-complex.h"
> Index: gcc/testsuite/gcc.dg/torture/float32-floath.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float32-floath.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float32-floath.c	(working copy)
> @@ -0,0 +1,60 @@
> +/* Test _Float32 <float.h> macros.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 32
> +#define EXT 0
> +#include "floatn-floath.h"
> +
> +#ifndef FLT32_MANT_DIG
> +# error "FLT32_MANT_DIG undefined"
> +#endif
> +
> +#ifndef FLT32_DECIMAL_DIG
> +# error "FLT32_DECIMAL_DIG undefined"
> +#endif
> +
> +#ifndef FLT32_DIG
> +# error "FLT32_DIG undefined"
> +#endif
> +
> +#ifndef FLT32_MIN_EXP
> +# error "FLT32_MIN_EXP undefined"
> +#endif
> +
> +#ifndef FLT32_MIN_10_EXP
> +# error "FLT32_MIN_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT32_MAX_EXP
> +# error "FLT32_MAX_EXP undefined"
> +#endif
> +
> +#ifndef FLT32_MAX_10_EXP
> +# error "FLT32_MAX_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT32_MAX
> +# error "FLT32_MAX undefined"
> +#endif
> +
> +#ifndef FLT32_EPSILON
> +# error "FLT32_EPSILON undefined"
> +#endif
> +
> +#ifndef FLT32_MIN
> +# error "FLT32_MIN undefined"
> +#endif
> +
> +#ifndef FLT32_TRUE_MIN
> +# error "FLT32_TRUE_MIN undefined"
> +#endif
> +
> +#if FLT32_DECIMAL_DIG > DECIMAL_DIG
> +# error "FLT32_DECIMAL_DIG > DECIMAL_DIG"
> +#endif
> +
> +#if FLT32_MANT_DIG != 24 || FLT32_MAX_EXP != 128 || FLT32_MIN_EXP != -125
> +# error "_Float32 bad format"
> +#endif
> Index: gcc/testsuite/gcc.dg/torture/float32-tg.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float32-tg.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float32-tg.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float32 type-generic built-in functions.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 32
> +#define EXT 0
> +#include "floatn-tg.h"
> Index: gcc/testsuite/gcc.dg/torture/float32x-basic.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float32x-basic.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float32x-basic.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float32x.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 32
> +#define EXT 1
> +#include "floatn-basic.h"
> Index: gcc/testsuite/gcc.dg/torture/float32x-complex.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float32x-complex.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float32x-complex.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float32x complex arithmetic.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 32
> +#define EXT 1
> +#include "floatn-complex.h"
> Index: gcc/testsuite/gcc.dg/torture/float32x-floath.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float32x-floath.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float32x-floath.c	(working copy)
> @@ -0,0 +1,60 @@
> +/* Test _Float32x <float.h> macros.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 32
> +#define EXT 1
> +#include "floatn-floath.h"
> +
> +#ifndef FLT32X_MANT_DIG
> +# error "FLT32X_MANT_DIG undefined"
> +#endif
> +
> +#ifndef FLT32X_DECIMAL_DIG
> +# error "FLT32X_DECIMAL_DIG undefined"
> +#endif
> +
> +#ifndef FLT32X_DIG
> +# error "FLT32X_DIG undefined"
> +#endif
> +
> +#ifndef FLT32X_MIN_EXP
> +# error "FLT32X_MIN_EXP undefined"
> +#endif
> +
> +#ifndef FLT32X_MIN_10_EXP
> +# error "FLT32X_MIN_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT32X_MAX_EXP
> +# error "FLT32X_MAX_EXP undefined"
> +#endif
> +
> +#ifndef FLT32X_MAX_10_EXP
> +# error "FLT32X_MAX_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT32X_MAX
> +# error "FLT32X_MAX undefined"
> +#endif
> +
> +#ifndef FLT32X_EPSILON
> +# error "FLT32X_EPSILON undefined"
> +#endif
> +
> +#ifndef FLT32X_MIN
> +# error "FLT32X_MIN undefined"
> +#endif
> +
> +#ifndef FLT32X_TRUE_MIN
> +# error "FLT32X_TRUE_MIN undefined"
> +#endif
> +
> +#if FLT32X_DECIMAL_DIG > DECIMAL_DIG
> +# error "FLT32X_DECIMAL_DIG > DECIMAL_DIG"
> +#endif
> +
> +#if FLT32X_MANT_DIG < 32 || FLT32X_MAX_EXP < 1024 || FLT32X_MIN_EXP + FLT32X_MAX_EXP != 3
> +# error "_Float32x bad format"
> +#endif
> Index: gcc/testsuite/gcc.dg/torture/float32x-tg.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float32x-tg.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float32x-tg.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float32x type-generic built-in functions.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 32
> +#define EXT 1
> +#include "floatn-tg.h"
> Index: gcc/testsuite/gcc.dg/torture/float64-basic.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float64-basic.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float64-basic.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float64.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 64
> +#define EXT 0
> +#include "floatn-basic.h"
> Index: gcc/testsuite/gcc.dg/torture/float64-complex.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float64-complex.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float64-complex.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float64 complex arithmetic.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 64
> +#define EXT 0
> +#include "floatn-complex.h"
> Index: gcc/testsuite/gcc.dg/torture/float64-floath.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float64-floath.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float64-floath.c	(working copy)
> @@ -0,0 +1,60 @@
> +/* Test _Float64 <float.h> macros.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 64
> +#define EXT 0
> +#include "floatn-floath.h"
> +
> +#ifndef FLT64_MANT_DIG
> +# error "FLT64_MANT_DIG undefined"
> +#endif
> +
> +#ifndef FLT64_DECIMAL_DIG
> +# error "FLT64_DECIMAL_DIG undefined"
> +#endif
> +
> +#ifndef FLT64_DIG
> +# error "FLT64_DIG undefined"
> +#endif
> +
> +#ifndef FLT64_MIN_EXP
> +# error "FLT64_MIN_EXP undefined"
> +#endif
> +
> +#ifndef FLT64_MIN_10_EXP
> +# error "FLT64_MIN_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT64_MAX_EXP
> +# error "FLT64_MAX_EXP undefined"
> +#endif
> +
> +#ifndef FLT64_MAX_10_EXP
> +# error "FLT64_MAX_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT64_MAX
> +# error "FLT64_MAX undefined"
> +#endif
> +
> +#ifndef FLT64_EPSILON
> +# error "FLT64_EPSILON undefined"
> +#endif
> +
> +#ifndef FLT64_MIN
> +# error "FLT64_MIN undefined"
> +#endif
> +
> +#ifndef FLT64_TRUE_MIN
> +# error "FLT64_TRUE_MIN undefined"
> +#endif
> +
> +#if FLT64_DECIMAL_DIG > DECIMAL_DIG
> +# error "FLT64_DECIMAL_DIG > DECIMAL_DIG"
> +#endif
> +
> +#if FLT64_MANT_DIG != 53 || FLT64_MAX_EXP != 1024 || FLT64_MIN_EXP != -1021
> +# error "_Float64 bad format"
> +#endif
> Index: gcc/testsuite/gcc.dg/torture/float64-tg.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float64-tg.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float64-tg.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float64 type-generic built-in functions.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64 } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 64
> +#define EXT 0
> +#include "floatn-tg.h"
> Index: gcc/testsuite/gcc.dg/torture/float64x-basic.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float64x-basic.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float64x-basic.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float64x.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 64
> +#define EXT 1
> +#include "floatn-basic.h"
> Index: gcc/testsuite/gcc.dg/torture/float64x-complex.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float64x-complex.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float64x-complex.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float64x complex arithmetic.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 64
> +#define EXT 1
> +#include "floatn-complex.h"
> Index: gcc/testsuite/gcc.dg/torture/float64x-floath.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float64x-floath.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float64x-floath.c	(working copy)
> @@ -0,0 +1,60 @@
> +/* Test _Float64x <float.h> macros.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 64
> +#define EXT 1
> +#include "floatn-floath.h"
> +
> +#ifndef FLT64X_MANT_DIG
> +# error "FLT64X_MANT_DIG undefined"
> +#endif
> +
> +#ifndef FLT64X_DECIMAL_DIG
> +# error "FLT64X_DECIMAL_DIG undefined"
> +#endif
> +
> +#ifndef FLT64X_DIG
> +# error "FLT64X_DIG undefined"
> +#endif
> +
> +#ifndef FLT64X_MIN_EXP
> +# error "FLT64X_MIN_EXP undefined"
> +#endif
> +
> +#ifndef FLT64X_MIN_10_EXP
> +# error "FLT64X_MIN_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT64X_MAX_EXP
> +# error "FLT64X_MAX_EXP undefined"
> +#endif
> +
> +#ifndef FLT64X_MAX_10_EXP
> +# error "FLT64X_MAX_10_EXP undefined"
> +#endif
> +
> +#ifndef FLT64X_MAX
> +# error "FLT64X_MAX undefined"
> +#endif
> +
> +#ifndef FLT64X_EPSILON
> +# error "FLT64X_EPSILON undefined"
> +#endif
> +
> +#ifndef FLT64X_MIN
> +# error "FLT64X_MIN undefined"
> +#endif
> +
> +#ifndef FLT64X_TRUE_MIN
> +# error "FLT64X_TRUE_MIN undefined"
> +#endif
> +
> +#if FLT64X_DECIMAL_DIG > DECIMAL_DIG
> +# error "FLT64X_DECIMAL_DIG > DECIMAL_DIG"
> +#endif
> +
> +#if FLT64X_MANT_DIG < 64 || FLT64X_MAX_EXP < 16384 || FLT64X_MIN_EXP + FLT64X_MAX_EXP != 3
> +# error "_Float64x bad format"
> +#endif
> Index: gcc/testsuite/gcc.dg/torture/float64x-tg.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/float64x-tg.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/float64x-tg.c	(working copy)
> @@ -0,0 +1,8 @@
> +/* Test _Float64x type-generic built-in functions.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64x } */
> +/* { dg-options "" } */
> +
> +#define WIDTH 64
> +#define EXT 1
> +#include "floatn-tg.h"
> Index: gcc/testsuite/gcc.dg/torture/floatn-basic.h
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/floatn-basic.h	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/floatn-basic.h	(working copy)
> @@ -0,0 +1,102 @@
> +/* Basic tests for _FloatN / _FloatNx types: compile and execution
> +   tests for valid code.  Before including this file, define WIDTH as
> +   the value N; define EXT to 1 for _FloatNx and 0 for _FloatN.  */
> +
> +#include <stdarg.h>
> +
> +#define CONCATX(X, Y) X ## Y
> +#define CONCAT(X, Y) CONCATX (X, Y)
> +#define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z)
> +#define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z)
> +
> +#if EXT
> +# define TYPE CONCAT3 (_Float, WIDTH, x)
> +# define CST(C) CONCAT4 (C, f, WIDTH, x)
> +# define CSTU(C) CONCAT4 (C, F, WIDTH, x)
> +#else
> +# define TYPE CONCAT (_Float, WIDTH)
> +# define CST(C) CONCAT3 (C, f, WIDTH)
> +# define CSTU(C) CONCAT3 (C, F, WIDTH)
> +#endif
> +
> +extern void exit (int);
> +extern void abort (void);
> +
> +volatile TYPE a = CST (1.0), b = CSTU (2.5), c = -CST (2.5);
> +
> +/* These types are not subject to default argument promotions.  */
> +
> +TYPE
> +vafn (TYPE arg1, ...)
> +{
> +  va_list ap;
> +  TYPE ret;
> +  va_start (ap, arg1);
> +  ret = arg1 + va_arg (ap, TYPE);
> +  va_end (ap);
> +  return ret;
> +}
> +
> +TYPE
> +krfn (arg)
> +     TYPE arg;
> +{
> +  return arg + 1;
> +}
> +
> +TYPE krprofn (TYPE);
> +TYPE
> +krprofn (arg)
> +     TYPE arg;
> +{
> +  return arg * 3;
> +}
> +
> +TYPE
> +profn (TYPE arg)
> +{
> +  return arg / 4;
> +}
> +
> +int
> +main (void)
> +{
> +  volatile TYPE r;
> +  r = -b;
> +  if (r != c)
> +    abort ();
> +  r = a + b;
> +  if (r != CST (3.5))
> +    abort ();
> +  r = a - b;
> +  if (r != -CST (1.5))
> +    abort ();
> +  r = 2 * c;
> +  if (r != -5)
> +    abort ();
> +  r = b * c;
> +  if (r != -CST (6.25))
> +    abort ();
> +  r = b / (a + a);
> +  if (r != CST (1.25))
> +    abort ();
> +  r = c * 3;
> +  if (r != -CST (7.5))
> +    abort ();
> +  volatile int i = r;
> +  if (i != -7)
> +    abort ();
> +  r = vafn (a, c);
> +  if (r != -CST (1.5))
> +    abort ();
> +  r = krfn (b);
> +  if (r != CST (3.5))
> +    abort ();
> +  r = krprofn (a);
> +  if (r != CST (3.0))
> +    abort ();
> +  r = profn (a);
> +  if (r != CST (0.25))
> +    abort ();
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/floatn-complex.h
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/floatn-complex.h	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/floatn-complex.h	(working copy)
> @@ -0,0 +1,76 @@
> +/* Tests for _FloatN / _FloatNx types: compile and execution tests for
> +   valid code with complex arithmetic.  Before including this file,
> +   define WIDTH as the value N; define EXT to 1 for _FloatNx and 0 for
> +   _FloatN.  */
> +
> +#define CONCATX(X, Y) X ## Y
> +#define CONCAT(X, Y) CONCATX (X, Y)
> +#define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z)
> +#define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z)
> +
> +#if EXT
> +# define TYPE CONCAT3 (_Float, WIDTH, x)
> +# define CST(C) CONCAT4 (C, f, WIDTH, x)
> +# define CSTI(C) CONCAT4 (C, if, WIDTH, x)
> +# define CSTI2(C) CONCAT4 (C, F, WIDTH, xi)
> +#else
> +# define TYPE CONCAT (_Float, WIDTH)
> +# define CST(C) CONCAT3 (C, f, WIDTH)
> +# define CSTI(C) CONCAT3 (C, if, WIDTH)
> +# define CSTI2(C) CONCAT4 (C, F, WIDTH, i)
> +#endif
> +
> +extern void exit (int);
> +extern void abort (void);
> +
> +volatile TYPE a = CST (1.0);
> +volatile _Complex TYPE b = CST (2.0) + CSTI (3.0);
> +volatile _Complex TYPE c = CST (2.0) + CSTI2 (3.0);
> +volatile _Complex TYPE d = __builtin_complex (CST (2.0), CST (3.0));
> +
> +_Complex TYPE
> +fn (_Complex TYPE arg)
> +{
> +  return arg / 4;
> +}
> +
> +int
> +main (void)
> +{
> +  volatile _Complex TYPE r;
> +  if (b != c)
> +    abort ();
> +  if (b != d)
> +    abort ();
> +  r = a + b;
> +  if (__real__ r != CST (3.0) || __imag__ r != CST (3.0))
> +    abort ();
> +  r += d;
> +  if (__real__ r != CST (5.0) || __imag__ r != CST (6.0))
> +    abort ();
> +  r -= a;
> +  if (__real__ r != CST (4.0) || __imag__ r != CST (6.0))
> +    abort ();
> +  r /= (a + a);
> +  if (__real__ r != CST (2.0) || __imag__ r != CST (3.0))
> +    abort ();
> +  r *= (a + a);
> +  if (__real__ r != CST (4.0) || __imag__ r != CST (6.0))
> +    abort ();
> +  r -= b;
> +  if (__real__ r != CST (2.0) || __imag__ r != CST (3.0))
> +    abort ();
> +  r *= r;
> +  if (__real__ r != -CST (5.0) || __imag__ r != CST (12.0))
> +    abort ();
> +  /* Division may not be exact, so round result before comparing.  */
> +  r /= b;
> +  r += __builtin_complex (CST (100.0), CST (100.0));
> +  r -= __builtin_complex (CST (100.0), CST (100.0));
> +  if (r != b)
> +    abort ();
> +  r = fn (r);
> +  if (__real__ r != CST (0.5) || __imag__ r != CST (0.75))
> +    abort ();
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/floatn-convert.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/floatn-convert.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/floatn-convert.c	(working copy)
> @@ -0,0 +1,96 @@
> +/* Tests for _FloatN / _FloatNx types: test conversions.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32 } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +
> +#ifndef FLT16_MAX
> +# define _Float16 _Float32
> +# define FLT16_MAX FLT32_MAX
> +# define FLT16_MANT_DIG FLT32_MANT_DIG
> +# define FLT16_EPSILON FLT32_EPSILON
> +#endif
> +
> +#ifndef FLT64_MAX
> +# define _Float64 _Float32
> +# define FLT64_MAX FLT32_MAX
> +# define FLT64_MANT_DIG FLT32_MANT_DIG
> +# define FLT64_EPSILON FLT32_EPSILON
> +#endif
> +
> +#ifndef FLT128_MAX
> +# define _Float128 _Float32
> +# define FLT128_MAX FLT32_MAX
> +# define FLT128_MANT_DIG FLT32_MANT_DIG
> +# define FLT128_EPSILON FLT32_EPSILON
> +#endif
> +
> +#ifndef FLT32X_MAX
> +# define _Float32x _Float32
> +# define FLT32X_MAX FLT32_MAX
> +# define FLT32X_MANT_DIG FLT32_MANT_DIG
> +# define FLT32X_EPSILON FLT32_EPSILON
> +#endif
> +
> +#ifndef FLT64X_MAX
> +# define _Float64x _Float32
> +# define FLT64X_MAX FLT32_MAX
> +# define FLT64X_MANT_DIG FLT32_MANT_DIG
> +# define FLT64X_EPSILON FLT32_EPSILON
> +#endif
> +
> +#ifndef FLT128X_MAX
> +# define _Float128x _Float32
> +# define FLT128X_MAX FLT32_MAX
> +# define FLT128X_MANT_DIG FLT32_MANT_DIG
> +# define FLT128X_EPSILON FLT32_EPSILON
> +#endif
> +
> +#define CONCATX(X, Y) X ## Y
> +#define CONCAT(X, Y) CONCATX (X, Y)
> +
> +extern void exit (int);
> +extern void abort (void);
> +
> +#define DO_TEST(TYPE1, PFX1, TYPE2, PFX2)			\
> +  do								\
> +    {								\
> +      volatile TYPE1 a = (TYPE1) 1 + CONCAT (PFX1, _EPSILON);	\
> +      volatile TYPE2 b = (TYPE2) a;				\
> +      volatile TYPE2 expected;					\
> +      if (CONCAT (PFX2, _MANT_DIG) < CONCAT (PFX1, _MANT_DIG))	\
> +	expected = (TYPE2) 1;					\
> +      else							\
> +	expected = (TYPE2) 1 + (TYPE2) CONCAT (PFX1, _EPSILON); \
> +      if (b != expected)					\
> +	abort ();						\
> +    }								\
> +  while (0)
> +
> +#define DO_TEST1(TYPE1, PFX1)				\
> +  do							\
> +    {							\
> +      DO_TEST (TYPE1, PFX1, _Float16, FLT16);		\
> +      DO_TEST (TYPE1, PFX1, _Float32, FLT32);		\
> +      DO_TEST (TYPE1, PFX1, _Float64, FLT64);		\
> +      DO_TEST (TYPE1, PFX1, _Float128, FLT128);		\
> +      DO_TEST (TYPE1, PFX1, _Float32x, FLT32X);		\
> +      DO_TEST (TYPE1, PFX1, _Float64x, FLT64X);		\
> +      DO_TEST (TYPE1, PFX1, _Float128x, FLT128X);	\
> +    }							\
> +  while (0)
> +
> +int
> +main (void)
> +{
> +  DO_TEST1 (_Float16, FLT16);
> +  DO_TEST1 (_Float32, FLT32);
> +  DO_TEST1 (_Float64, FLT64);
> +  DO_TEST1 (_Float128, FLT128);
> +  DO_TEST1 (_Float32x, FLT32X);
> +  DO_TEST1 (_Float64x, FLT64X);
> +  DO_TEST1 (_Float128x, FLT128X);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/floatn-floath.h
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/floatn-floath.h	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/floatn-floath.h	(working copy)
> @@ -0,0 +1,52 @@
> +/* Tests for _FloatN / _FloatNx types: compile and execution tests for
> +   <float.h>.  Before including this file, define WIDTH as the value
> +   N; define EXT to 1 for _FloatNx and 0 for _FloatN.  */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +
> +#define CONCATX(X, Y) X ## Y
> +#define CONCAT(X, Y) CONCATX (X, Y)
> +#define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z)
> +#define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z)
> +
> +#if EXT
> +# define TYPE CONCAT3 (_Float, WIDTH, x)
> +# define CST(C) CONCAT4 (C, f, WIDTH, x)
> +# define FMAC(M) CONCAT4 (FLT, WIDTH, X_, M)
> +#else
> +# define TYPE CONCAT (_Float, WIDTH)
> +# define CST(C) CONCAT3 (C, f, WIDTH)
> +# define FMAC(M) CONCAT4 (FLT, WIDTH, _, M)
> +#endif
> +
> +extern void exit (int);
> +extern void abort (void);
> +
> +int
> +main (void)
> +{
> +  volatile TYPE a = CST (1.0);
> +  for (int i = 0; i >= FMAC (MIN_EXP); i--)
> +    a *= CST (0.5);
> +  if (a != FMAC (MIN))
> +    abort ();
> +  for (int i = 0; i < FMAC (MANT_DIG) - 1; i++)
> +    a *= CST (0.5);
> +  if (a != FMAC (TRUE_MIN))
> +    abort ();
> +  a *= CST (0.5);
> +  if (a != CST (0.0))
> +    abort ();
> +  a = FMAC (EPSILON);
> +  for (int i = 0; i < FMAC (MANT_DIG) - 1; i++)
> +    a *= CST (2.0);
> +  if (a != CST (1.0))
> +    abort ();
> +  a = FMAC (MAX);
> +  for (int i = 0; i < FMAC (MAX_EXP); i++)
> +    a *= CST (0.5);
> +  if (a != CST (1.0) - FMAC (EPSILON) * CST (0.5))
> +    abort ();
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/floatn-tg.h
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/floatn-tg.h	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/floatn-tg.h	(working copy)
> @@ -0,0 +1,71 @@
> +/* Tests for _FloatN / _FloatNx types: compile and execution tests for
> +   type-generic built-in functions.  Before including this file,
> +   define WIDTH as the value N; define EXT to 1 for _FloatNx and 0 for
> +   _FloatN.  */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +
> +#define CONCATX(X, Y) X ## Y
> +#define CONCAT(X, Y) CONCATX (X, Y)
> +#define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z)
> +#define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z)
> +
> +#if EXT
> +# define TYPE CONCAT3 (_Float, WIDTH, x)
> +# define CST(C) CONCAT4 (C, f, WIDTH, x)
> +# define TRUE_MIN CONCAT3 (FLT, WIDTH, X_TRUE_MIN)
> +#else
> +# define TYPE CONCAT (_Float, WIDTH)
> +# define CST(C) CONCAT3 (C, f, WIDTH)
> +# define TRUE_MIN CONCAT3 (FLT, WIDTH, _TRUE_MIN)
> +#endif
> +
> +extern void exit (int);
> +extern void abort (void);
> +
> +volatile TYPE inf = __builtin_inf (), nanval = __builtin_nan ("");
> +volatile TYPE zero = CST (0.0), negzero = -CST (0.0), one = CST (1.0);
> +volatile TYPE true_min = TRUE_MIN;
> +
> +int
> +main (void)
> +{
> +  if (__builtin_signbit (inf) != 0)
> +    abort ();
> +  if (__builtin_signbit (zero) != 0)
> +    abort ();
> +  if (__builtin_signbit (negzero) == 0)
> +    abort ();
> +  if (__builtin_isfinite (nanval) != 0)
> +    abort ();
> +  if (__builtin_isfinite (inf) != 0)
> +    abort ();
> +  if (__builtin_isfinite (one) == 0)
> +    abort ();
> +  if (__builtin_isinf (nanval) != 0)
> +    abort ();
> +  if (__builtin_isinf (inf) == 0)
> +    abort ();
> +  if (__builtin_isnan (nanval) == 0)
> +    abort ();
> +  if (__builtin_isnan (inf) != 0)
> +    abort ();
> +  if (__builtin_isnormal (inf) != 0)
> +    abort ();
> +  if (__builtin_isnormal (one) == 0)
> +    abort ();
> +  if (__builtin_isnormal (nanval) != 0)
> +    abort ();
> +  if (__builtin_isnormal (zero) != 0)
> +    abort ();
> +  if (__builtin_isnormal (true_min) != 0)
> +    abort ();
> +  if (__builtin_islessequal (zero, one) != 1)
> +    abort ();
> +  if (__builtin_islessequal (zero, negzero) != 1)
> +    abort ();
> +  if (__builtin_islessequal (zero, nanval) != 0)
> +    abort ();
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee-timode.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee-timode.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee-timode.c	(working copy)
> @@ -0,0 +1,15 @@
> +/* Test floating-point conversions.  _Float128 type with TImode.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128 } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(TItype, UTItype, _Float128, FLT128_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee.c	(working copy)
> @@ -0,0 +1,19 @@
> +/* Test floating-point conversions.  Standard types and _Float128.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128 } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(signed char, unsigned char, _Float128, FLT128_MANT_DIG);
> +  TEST_I_F(signed short, unsigned short, _Float128, FLT128_MANT_DIG);
> +  TEST_I_F(signed int, unsigned int, _Float128, FLT128_MANT_DIG);
> +  TEST_I_F(signed long, unsigned long, _Float128, FLT128_MANT_DIG);
> +  TEST_I_F(signed long long, unsigned long long, _Float128, FLT128_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x-timode.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x-timode.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x-timode.c	(working copy)
> @@ -0,0 +1,15 @@
> +/* Test floating-point conversions.  _Float128x type with TImode.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128x } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(TItype, UTItype, _Float128, FLT128X_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x.c	(working copy)
> @@ -0,0 +1,19 @@
> +/* Test floating-point conversions.  Standard types and _Float128x.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float128x } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(signed char, unsigned char, _Float128x, FLT128X_MANT_DIG);
> +  TEST_I_F(signed short, unsigned short, _Float128x, FLT128X_MANT_DIG);
> +  TEST_I_F(signed int, unsigned int, _Float128x, FLT128X_MANT_DIG);
> +  TEST_I_F(signed long, unsigned long, _Float128x, FLT128X_MANT_DIG);
> +  TEST_I_F(signed long long, unsigned long long, _Float128x, FLT128X_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float16-timode.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float16-timode.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float16-timode.c	(working copy)
> @@ -0,0 +1,15 @@
> +/* Test floating-point conversions.  _Float16 type with TImode.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float16 } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(TItype, UTItype, _Float16, FLT16_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float16.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float16.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float16.c	(working copy)
> @@ -0,0 +1,19 @@
> +/* Test floating-point conversions.  Standard types and _Float16.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float16 } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(signed char, unsigned char, _Float16, FLT16_MANT_DIG);
> +  TEST_I_F(signed short, unsigned short, _Float16, FLT16_MANT_DIG);
> +  TEST_I_F(signed int, unsigned int, _Float16, FLT16_MANT_DIG);
> +  TEST_I_F(signed long, unsigned long, _Float16, FLT16_MANT_DIG);
> +  TEST_I_F(signed long long, unsigned long long, _Float16, FLT16_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float32-timode.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float32-timode.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float32-timode.c	(working copy)
> @@ -0,0 +1,15 @@
> +/* Test floating-point conversions.  _Float32 type with TImode.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32 } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(TItype, UTItype, _Float32, FLT32_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float32.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float32.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float32.c	(working copy)
> @@ -0,0 +1,19 @@
> +/* Test floating-point conversions.  Standard types and _Float32.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32 } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(signed char, unsigned char, _Float32, FLT32_MANT_DIG);
> +  TEST_I_F(signed short, unsigned short, _Float32, FLT32_MANT_DIG);
> +  TEST_I_F(signed int, unsigned int, _Float32, FLT32_MANT_DIG);
> +  TEST_I_F(signed long, unsigned long, _Float32, FLT32_MANT_DIG);
> +  TEST_I_F(signed long long, unsigned long long, _Float32, FLT32_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x-timode.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x-timode.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x-timode.c	(working copy)
> @@ -0,0 +1,15 @@
> +/* Test floating-point conversions.  _Float32x type with TImode.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32x } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(TItype, UTItype, _Float32, FLT32X_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x.c	(working copy)
> @@ -0,0 +1,19 @@
> +/* Test floating-point conversions.  Standard types and _Float32x.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float32x } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(signed char, unsigned char, _Float32x, FLT32X_MANT_DIG);
> +  TEST_I_F(signed short, unsigned short, _Float32x, FLT32X_MANT_DIG);
> +  TEST_I_F(signed int, unsigned int, _Float32x, FLT32X_MANT_DIG);
> +  TEST_I_F(signed long, unsigned long, _Float32x, FLT32X_MANT_DIG);
> +  TEST_I_F(signed long long, unsigned long long, _Float32x, FLT32X_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float64-timode.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float64-timode.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float64-timode.c	(working copy)
> @@ -0,0 +1,15 @@
> +/* Test floating-point conversions.  _Float64 type with TImode.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64 } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(TItype, UTItype, _Float64, FLT64_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float64.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float64.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float64.c	(working copy)
> @@ -0,0 +1,19 @@
> +/* Test floating-point conversions.  Standard types and _Float64.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64 } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(signed char, unsigned char, _Float64, FLT64_MANT_DIG);
> +  TEST_I_F(signed short, unsigned short, _Float64, FLT64_MANT_DIG);
> +  TEST_I_F(signed int, unsigned int, _Float64, FLT64_MANT_DIG);
> +  TEST_I_F(signed long, unsigned long, _Float64, FLT64_MANT_DIG);
> +  TEST_I_F(signed long long, unsigned long long, _Float64, FLT64_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x-timode.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x-timode.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x-timode.c	(working copy)
> @@ -0,0 +1,15 @@
> +/* Test floating-point conversions.  _Float64x type with TImode.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64x } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(TItype, UTItype, _Float64, FLT64X_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x.c	(nonexistent)
> +++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x.c	(working copy)
> @@ -0,0 +1,19 @@
> +/* Test floating-point conversions.  Standard types and _Float64x.  */
> +/* { dg-do run } */
> +/* { dg-require-effective-target float64x } */
> +/* { dg-options "" } */
> +
> +#define __STDC_WANT_IEC_60559_TYPES_EXT__
> +#include <float.h>
> +#include "fp-int-convert.h"
> +
> +int
> +main (void)
> +{
> +  TEST_I_F(signed char, unsigned char, _Float64x, FLT64X_MANT_DIG);
> +  TEST_I_F(signed short, unsigned short, _Float64x, FLT64X_MANT_DIG);
> +  TEST_I_F(signed int, unsigned int, _Float64x, FLT64X_MANT_DIG);
> +  TEST_I_F(signed long, unsigned long, _Float64x, FLT64X_MANT_DIG);
> +  TEST_I_F(signed long long, unsigned long long, _Float64x, FLT64X_MANT_DIG);
> +  exit (0);
> +}
> Index: gcc/testsuite/lib/target-supports.exp
> ===================================================================
> --- gcc/testsuite/lib/target-supports.exp	(revision 237622)
> +++ gcc/testsuite/lib/target-supports.exp	(working copy)
> @@ -2300,6 +2300,52 @@ proc check_effective_target_has_q_floating_suffix
> 	float dummy = 1.0q;
>     } "$opts"]
> }
> +
> +# Return 1 if the target supports the _FloatN / _FloatNx type
> +# indicated in the function name, 0 otherwise.
> +
> +proc check_effective_target_float16 {} {
> +    return [check_no_compiler_messages float16 object {
> +        _Float16 x;
> +    }]
> +}
> +
> +proc check_effective_target_float32 {} {
> +    return [check_no_compiler_messages float32 object {
> +        _Float32 x;
> +    }]
> +}
> +
> +proc check_effective_target_float64 {} {
> +    return [check_no_compiler_messages float64 object {
> +        _Float64 x;
> +    }]
> +}
> +
> +proc check_effective_target_float128 {} {
> +    return [check_no_compiler_messages float128 object {
> +        _Float128 x;
> +    }]
> +}
> +
> +proc check_effective_target_float32x {} {
> +    return [check_no_compiler_messages float32x object {
> +        _Float32x x;
> +    }]
> +}
> +
> +proc check_effective_target_float64x {} {
> +    return [check_no_compiler_messages float64x object {
> +        _Float64x x;
> +    }]
> +}
> +
> +proc check_effective_target_float128x {} {
> +    return [check_no_compiler_messages float128x object {
> +        _Float128x x;
> +    }]
> +}
> +
> # Return 1 if the target supports compiling fixed-point,
> # 0 otherwise.
> 
> Index: gcc/tree-core.h
> ===================================================================
> --- gcc/tree-core.h	(revision 237622)
> +++ gcc/tree-core.h	(working copy)
> @@ -558,10 +558,44 @@ enum tree_index {
>   TI_COMPLEX_DOUBLE_TYPE,
>   TI_COMPLEX_LONG_DOUBLE_TYPE,
> 
> +  TI_COMPLEX_FLOAT16_TYPE,
> +  TI_COMPLEX_FLOATN_NX_TYPE_FIRST = TI_COMPLEX_FLOAT16_TYPE,
> +  TI_COMPLEX_FLOAT32_TYPE,
> +  TI_COMPLEX_FLOAT64_TYPE,
> +  TI_COMPLEX_FLOAT128_TYPE,
> +  TI_COMPLEX_FLOAT32X_TYPE,
> +  TI_COMPLEX_FLOAT64X_TYPE,
> +  TI_COMPLEX_FLOAT128X_TYPE,
> +
>   TI_FLOAT_TYPE,
>   TI_DOUBLE_TYPE,
>   TI_LONG_DOUBLE_TYPE,
> 
> +  /* The _FloatN and _FloatNx types must be consecutive, and in the
> +     same sequence as the corresponding complex types, which must also
> +     be consecutive; _FloatN must come before _FloatNx; the order must
> +     also be the same as in the floatn_nx_types array and the RID_*
> +     values in c-common.h.  This is so that iterations over these
> +     types work as intended.  */
> +  TI_FLOAT16_TYPE,
> +  TI_FLOATN_TYPE_FIRST = TI_FLOAT16_TYPE,
> +  TI_FLOATN_NX_TYPE_FIRST = TI_FLOAT16_TYPE,
> +  TI_FLOAT32_TYPE,
> +  TI_FLOAT64_TYPE,
> +  TI_FLOAT128_TYPE,
> +  TI_FLOATN_TYPE_LAST = TI_FLOAT128_TYPE,
> +#define NUM_FLOATN_TYPES (TI_FLOATN_TYPE_LAST - TI_FLOATN_TYPE_FIRST + 1)
> +  TI_FLOAT32X_TYPE,
> +  TI_FLOATNX_TYPE_FIRST = TI_FLOAT32X_TYPE,
> +  TI_FLOAT64X_TYPE,
> +  TI_FLOAT128X_TYPE,
> +  TI_FLOATNX_TYPE_LAST = TI_FLOAT128X_TYPE,
> +  TI_FLOATN_NX_TYPE_LAST = TI_FLOAT128X_TYPE,
> +#define NUM_FLOATNX_TYPES (TI_FLOATNX_TYPE_LAST - TI_FLOATNX_TYPE_FIRST + 1)
> +#define NUM_FLOATN_NX_TYPES (TI_FLOATN_NX_TYPE_LAST		\
> +			     - TI_FLOATN_NX_TYPE_FIRST		\
> +			     + 1)
> +
>   TI_FLOAT_PTR_TYPE,
>   TI_DOUBLE_PTR_TYPE,
>   TI_LONG_DOUBLE_PTR_TYPE,
> @@ -1961,7 +1995,17 @@ struct GTY(()) builtin_info_type {
>   unsigned declared_p : 1;
> };
> 
> +/* Information about a _FloatN or _FloatNx type that may be
> +   supported.  */
> +struct floatn_type_info {
> +  /* The number N in the type name.  */
> +  int n;
> +  /* Whether it is an extended type _FloatNx (true) or an interchange
> +     type (false).  */
> +  bool extended;
> +};
> 
> +
> /*---------------------------------------------------------------------------
>                                 Global variables
> ---------------------------------------------------------------------------*/
> @@ -2025,4 +2069,7 @@ extern GTY(()) tree current_function_decl;
> /* Nonzero means a FUNC_BEGIN label was emitted.  */
> extern GTY(()) const char * current_function_func_begin_label;
> 
> +/* Information about the _FloatN and _FloatNx types.  */
> +extern const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES];
> +
> #endif  // GCC_TREE_CORE_H
> Index: gcc/tree.c
> ===================================================================
> --- gcc/tree.c	(revision 237622)
> +++ gcc/tree.c	(working copy)
> @@ -10150,6 +10150,20 @@ build_atomic_base (tree type, unsigned int align)
>   return t;
> }
> 
> +/* Information about the _FloatN and _FloatNx types.  This must be in
> +   the same order as the corresponding TI_* enum values.  */
> +const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES] =
> +  {
> +    { 16, false },
> +    { 32, false },
> +    { 64, false },
> +    { 128, false },
> +    { 32, true },
> +    { 64, true },
> +    { 128, true },
> +  };
> +
> +
> /* Create nodes for all integer types (and error_mark_node) using the sizes
>    of C datatypes.  SIGNED_CHAR specifies whether char is signed.  */
> 
> @@ -10322,6 +10336,24 @@ build_common_tree_nodes (bool signed_char)
>   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
>   layout_type (long_double_type_node);
> 
> +  for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +    {
> +      int n = floatn_nx_types[i].n;
> +      bool extended = floatn_nx_types[i].extended;
> +      machine_mode mode = targetm.floatn_mode (n, extended);
> +      if (mode == VOIDmode)
> +	continue;
> +      int precision = GET_MODE_PRECISION (mode);
> +      /* Work around the rs6000 KFmode having precision 113 not
> +	 128.  */
> +      if (precision < n)
> +	precision = n;
> +      FLOATN_NX_TYPE_NODE (i) = make_node (REAL_TYPE);
> +      TYPE_PRECISION (FLOATN_NX_TYPE_NODE (i)) = precision;
> +      layout_type (FLOATN_NX_TYPE_NODE (i));
> +      SET_TYPE_MODE (FLOATN_NX_TYPE_NODE (i), mode);
> +    }
> +
>   float_ptr_type_node = build_pointer_type (float_type_node);
>   double_ptr_type_node = build_pointer_type (double_type_node);
>   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
> @@ -10356,6 +10388,13 @@ build_common_tree_nodes (bool signed_char)
>   complex_double_type_node = build_complex_type (double_type_node);
>   complex_long_double_type_node = build_complex_type (long_double_type_node);
> 
> +  for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
> +    {
> +      if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE)
> +	COMPLEX_FLOATN_NX_TYPE_NODE (i)
> +	  = build_complex_type (FLOATN_NX_TYPE_NODE (i));
> +    }
> +
> /* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
> #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
>   sat_ ## KIND ## _type_node = \
> Index: gcc/tree.h
> ===================================================================
> --- gcc/tree.h	(revision 237622)
> +++ gcc/tree.h	(working copy)
> @@ -3612,6 +3612,17 @@ tree_operand_check_code (const_tree __t, enum tree
> #define double_type_node		global_trees[TI_DOUBLE_TYPE]
> #define long_double_type_node		global_trees[TI_LONG_DOUBLE_TYPE]
> 
> +/* Nodes for particular _FloatN and _FloatNx types in sequence.  */
> +#define FLOATN_TYPE_NODE(IDX)		global_trees[TI_FLOATN_TYPE_FIRST + (IDX)]
> +#define FLOATN_NX_TYPE_NODE(IDX)	global_trees[TI_FLOATN_NX_TYPE_FIRST + (IDX)]
> +#define FLOATNX_TYPE_NODE(IDX)		global_trees[TI_FLOATNX_TYPE_FIRST + (IDX)]
> +
> +/* Names for individual types, where required by back ends
> +   (architecture-independent code should always iterate over all such
> +   types).  */
> +#define float128_type_node		global_trees[TI_FLOAT128_TYPE]
> +#define float64x_type_node		global_trees[TI_FLOAT64X_TYPE]
> +
> #define float_ptr_type_node		global_trees[TI_FLOAT_PTR_TYPE]
> #define double_ptr_type_node		global_trees[TI_DOUBLE_PTR_TYPE]
> #define long_double_ptr_type_node	global_trees[TI_LONG_DOUBLE_PTR_TYPE]
> @@ -3622,6 +3633,8 @@ tree_operand_check_code (const_tree __t, enum tree
> #define complex_double_type_node	global_trees[TI_COMPLEX_DOUBLE_TYPE]
> #define complex_long_double_type_node	global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]
> 
> +#define COMPLEX_FLOATN_NX_TYPE_NODE(IDX)	global_trees[TI_COMPLEX_FLOATN_NX_TYPE_FIRST + (IDX)]
> +
> #define pointer_bounds_type_node        global_trees[TI_POINTER_BOUNDS_TYPE]
> 
> #define void_type_node			global_trees[TI_VOID_TYPE]
> Index: libcpp/expr.c
> ===================================================================
> --- libcpp/expr.c	(revision 237622)
> +++ libcpp/expr.c	(working copy)
> @@ -91,10 +91,10 @@ static unsigned int
> interpret_float_suffix (cpp_reader *pfile, const uchar *s, size_t len)
> {
>   size_t flags;
> -  size_t f, d, l, w, q, i;
> +  size_t f, d, l, w, q, i, fn, fnx, fn_bits;
> 
>   flags = 0;
> -  f = d = l = w = q = i = 0;
> +  f = d = l = w = q = i = fn = fnx = fn_bits = 0;
> 
>   /* Process decimal float suffixes, which are two letters starting
>      with d or D.  Order and case are significant.  */
> @@ -172,21 +172,59 @@ interpret_float_suffix (cpp_reader *pfile, const u
> 
>   /* In any remaining valid suffix, the case and order don't matter.  */
>   while (len--)
> -    switch (s[len])
> -      {
> -      case 'f': case 'F': f++; break;
> -      case 'd': case 'D': d++; break;
> -      case 'l': case 'L': l++; break;
> -      case 'w': case 'W': w++; break;
> -      case 'q': case 'Q': q++; break;
> -      case 'i': case 'I':
> -      case 'j': case 'J': i++; break;
> -      default:
> -	return 0;
> -      }
> +    {
> +      switch (s[0])
> +	{
> +	case 'f': case 'F':
> +	  f++;
> +	  if (len > 0
> +	      && !CPP_OPTION (pfile, cplusplus)
> +	      && s[1] >= '1'
> +	      && s[1] <= '9'
> +	      && fn_bits == 0)
> +	    {
> +	      f--;
> +	      while (len > 0
> +		     && s[1] >= '0'
> +		     && s[1] <= '9'
> +		     && fn_bits < CPP_FLOATN_MAX)
> +		{
> +		  fn_bits = fn_bits * 10 + (s[1] - '0');
> +		  len--;
> +		  s++;
> +		}
> +	      if (len > 0 && s[1] == 'x')
> +		{
> +		  fnx++;
> +		  len--;
> +		  s++;
> +		}
> +	      else
> +		fn++;
> +	    }
> +	  break;
> +	case 'd': case 'D': d++; break;
> +	case 'l': case 'L': l++; break;
> +	case 'w': case 'W': w++; break;
> +	case 'q': case 'Q': q++; break;
> +	case 'i': case 'I':
> +	case 'j': case 'J': i++; break;
> +	default:
> +	  return 0;
> +	}
> +      s++;
> +    }
> 
> -  if (f + d + l + w + q > 1 || i > 1)
> +  if (f + d + l + w + q + fn + fnx > 1 || i > 1)
>     return 0;
> +  if (fn_bits > CPP_FLOATN_MAX)
> +    return 0;
> +  if (fnx && fn_bits != 32 && fn_bits != 64 && fn_bits != 128)
> +    return 0;
> +  if (fn && fn_bits != 16 && fn_bits % 32 != 0)
> +    return 0;
> +  if (fn && fn_bits == 96)
> +    return 0;
> 
>   if (i && !CPP_OPTION (pfile, ext_numeric_literals))
>     return 0;
> @@ -199,7 +237,10 @@ interpret_float_suffix (cpp_reader *pfile, const u
> 	     d ? CPP_N_MEDIUM :
> 	     l ? CPP_N_LARGE :
> 	     w ? CPP_N_MD_W :
> -	     q ? CPP_N_MD_Q : CPP_N_DEFAULT));
> +	     q ? CPP_N_MD_Q :
> +	     fn ? CPP_N_FLOATN | (fn_bits << CPP_FLOATN_SHIFT) :
> +	     fnx ? CPP_N_FLOATNX | (fn_bits << CPP_FLOATN_SHIFT) :
> +	     CPP_N_DEFAULT));
> }
> 
> /* Return the classification flags for a float suffix.  */
> Index: libcpp/include/cpplib.h
> ===================================================================
> --- libcpp/include/cpplib.h	(revision 237622)
> +++ libcpp/include/cpplib.h	(working copy)
> @@ -902,9 +902,16 @@ struct cpp_num
> 
> #define CPP_N_FRACT	0x100000 /* Fract types.  */
> #define CPP_N_ACCUM	0x200000 /* Accum types.  */
> +#define CPP_N_FLOATN	0x400000 /* _FloatN types.  */
> +#define CPP_N_FLOATNX	0x800000 /* _FloatNx types.  */
> 
> #define CPP_N_USERDEF	0x1000000 /* C++0x user-defined literal.  */
> 
> +#define CPP_N_WIDTH_FLOATN_NX	0xF0000000 /* _FloatN / _FloatNx value
> +					      of N, divided by 16.  */
> +#define CPP_FLOATN_SHIFT	24
> +#define CPP_FLOATN_MAX	0xF0
> +
> /* Classify a CPP_NUMBER token.  The return value is a combination of
>    the flags from the above sets.  */
> extern unsigned cpp_classify_number (cpp_reader *, const cpp_token *,
> 
> 
> -- 
> Joseph S. Myers
> joseph@codesourcery.com
>
Joseph Myers June 21, 2016, 3:38 p.m. | #3
On Tue, 21 Jun 2016, FX wrote:

> > Fortran note: I took the conservative approach of renaming the
> > float128_type_node used in the Fortran front end, since I wasn't sure
> > if it's safe to make the front end always use the language-independent
> > node (which follows C rules - thus, being distinct from long double
> > even if that has binary128 format).
> 
> In the Fortran front-end, float128_type_node is defined as the 
> (expectedly unique) floating-point type for which mode_precision is 
> equal to 128 but not equal to LONG_DOUBLE_TYPE_SIZE. That is, it is 
> garanteed that float128_type_node is not long_double_type_node.
> 
> If fact, if there is a long double type with precision of 128, then 
> float128_type_node is NULL.
> 
> Would that match the (new) C behavior? I think it does.

Precision is a poorly defined concept in this context.

Precision of a type is meant to be the number of value bits, which is 128 
not just for binary128 but also for IBM long double.  I think the same 
applies to precision of a mode.  See Richard's comments in 
<https://gcc.gnu.org/ml/gcc-patches/2016-06/msg01140.html> on how the use 
of fractional float modes for IFmode and KFmode is a lie, because those 
modes both have 128 significant bits, not 106 and 113.  To avoid the 
misleading mode precision values becoming misleading type precision 
values, my patch includes a workaround in build_common_tree_nodes to give 
precedence to the N in binaryN (although it occurs to me that this is not 
in fact a sufficient workaround, because _Float64x needs such a fix as 
well) - that keeps _Float128 having type precision 128 in that case, like 
ieee128_float_type_node in the PowerPC back end does.

Language-independent float128_type_node has the following properties: it 
is always of binary128 format, never of another format that might have 
precision 128 (such as IBM long double).  If binary128 is supported, 
float128_type_node is non-NULL, whether or not long double also has 
precision 128.  That does not seem to match your semantics for Fortran in 
the case where long double is binary128, as for Fortran you'd have NULL 
but the language-independent node would be a distinct type from long 
double, not NULL.
Joseph Myers June 21, 2016, 3:43 p.m. | #4
On Tue, 21 Jun 2016, Bill Schmidt wrote:

> I haven't read through the patch in detail yet, but thank you for the 
> very thorough description!  For PowerPC, we currently have a lot 
> invested in having __float128 correspond to KFmode for the time being, 
> during the transition while supporting both IEEE-128 and IBM long 
> double.  (I was not aware of the problem with q-suffix constants being 
> treated as TFmode, which will need to be fixed.)  I'm currently in 
> process of developing the minimal set of *f128 built-ins required for 
> glibc, using __float128 and KFmode.
> 
> Can we please keep this correspondence for now?  Do you foresee any 
> further concerns with staying on that path until we can fully throw the 
> switch to move away from IBM long double?

The question is what mode is used for _Float128 (and thus for __float128, 
which is now a typedef for _Float128) in the FLOAT128_IEEE_P (TFmode) case 
(that is, when TARGET_IEEEQUAD is true).  I see no problems with that mode 
being KFmode instead of TFmode if that's what's preferred; I'll make that 
change in the next revision of my patch.  Of course, you should make *q 
constants match, so that they are consistent with *f128 constants.
Michael Meissner Aug. 5, 2016, 12:09 a.m. | #5
In gcc/c-family/c-prettyprint.c in the function that you modified
pp_c_floating_constant:

It brings up a general complaint that I had when I started the whole PowerPC
__float128 adventure is that we have multiple places in the compiler it goes
through a list of floating point types, and only for the blessed types does it
do something.  If a port happens to have a non-standard type, there really
should be target hooks for doing each of the actions.

But rather than having lots of different hooks, it may be better to have a hash
lookup given a type node (and/or mode) that registers all of the handling in a
central place, rather than continually having:

  if (TREE_TYPE (r) == float_type_node)
    pp_character (pp, 'f');
  else if (TREE_TYPE (r) == long_double_type_node)
    pp_character (pp, 'l');
  else if (TREE_TYPE (r) == dfloat128_type_node)
    pp_string (pp, "dl");
  else if (TREE_TYPE (r) == dfloat64_type_node)
    pp_string (pp, "dd");
  else if (TREE_TYPE (r) == dfloat32_type_node)
    pp_string (pp, "df");

Obviously, there are lots of places in the compiler that do this.  But it has
been my experience, that usually when you have an enumeration like this, either
you miss one in the cut+paste of the same type of code, or when you add a new
type, you have to go through all of the places and update things (and usually
miss one, or get held up trying to get N maintainers to agree with the
patches).

And it may be that like I did, you might decide not to fix the general solution
in order to get what you want in the compiler.
Joseph Myers Aug. 5, 2016, 12:35 a.m. | #6
On Thu, 4 Aug 2016, Michael Meissner wrote:

> It brings up a general complaint that I had when I started the whole PowerPC
> __float128 adventure is that we have multiple places in the compiler it goes
> through a list of floating point types, and only for the blessed types does it
> do something.  If a port happens to have a non-standard type, there really
> should be target hooks for doing each of the actions.

Note that not all the types / modes are necessarily suitable for all those 
places.  Consider IA64 RFmode (__fpreg), for example.  And some things 
such as <float.h> macros aren't defined for nonstandard types.

> But rather than having lots of different hooks, it may be better to have a hash
> lookup given a type node (and/or mode) that registers all of the handling in a
> central place, rather than continually having:

In various places you need to get the right ordering of types, and to 
distinguish types for the same mode (e.g. usual arithmetic conversions 
have a specified ordering); it's not just a lookup table.

This patch is explicitly not trying to improve anything for types that are 
*not* _FloatN / _FloatNx (such as __fp16, or __fpreg).  For the _FloatN 
and _FloatNx types it tries to use the various macros for looping over 
those types as far as possible, not hardcoding a list of them in too many 
places.

It is also explicitly aiming to get support for _FloatN / _FloatNx to a 
minimal functional state (conforming to the TS semantics, to the extent 
that the underlying arithmetic for the relevant machine modes does, and 
apart from the corner case of treating _FloatN as a keyword for arbitrary 
N >= 128 and a multiple of 32) that can be incrementally improved, rather 
than to make it fully equivalent to that for float, double and long double 
(which runs into issues with adding hundreds of new built-in functions, 
among other things) - that is, to be the smallest version of support for 
these types that would be appropriate for GCC, not the maximal version, in 
accordance with the principle of submitting minimal indivisible patches.  
The list of things not done in the notes for this patch is intended to be 
exhaustive as a list of potential future improvements for bringing these 
types to full parity with float, double and long double.

Patch

Index: gcc/c/c-decl.c
===================================================================
--- gcc/c/c-decl.c	(revision 237622)
+++ gcc/c/c-decl.c	(working copy)
@@ -9642,6 +9642,14 @@  declspecs_add_type (location_t loc, struct c_decls
 		error_at (loc,
 			  ("both %<long%> and %<float%> in "
 			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_floatn_nx)
+		error_at (loc,
+			  ("both %<long%> and %<_Float%d%s%> in "
+			   "declaration specifiers"),
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
 	      else if (specs->typespec_word == cts_dfloat32)
 		error_at (loc,
 			  ("both %<long%> and %<_Decimal32%> in "
@@ -9695,6 +9703,14 @@  declspecs_add_type (location_t loc, struct c_decls
 		error_at (loc,
 			  ("both %<short%> and %<double%> in "
 			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_floatn_nx)
+		error_at (loc,
+			  ("both %<short%> and %<_Float%d%s%> in "
+			   "declaration specifiers"),
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
 	      else if (specs->typespec_word == cts_dfloat32)
                 error_at (loc,
 			  ("both %<short%> and %<_Decimal32%> in "
@@ -9739,6 +9755,14 @@  declspecs_add_type (location_t loc, struct c_decls
 		error_at (loc,
 			  ("both %<signed%> and %<double%> in "
 			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_floatn_nx)
+		error_at (loc,
+			  ("both %<signed%> and %<_Float%d%s%> in "
+			   "declaration specifiers"),
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
 	      else if (specs->typespec_word == cts_dfloat32)
 		error_at (loc,
 			  ("both %<signed%> and %<_Decimal32%> in "
@@ -9783,6 +9807,14 @@  declspecs_add_type (location_t loc, struct c_decls
 		error_at (loc,
 			  ("both %<unsigned%> and %<double%> in "
 			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_floatn_nx)
+		error_at (loc,
+			  ("both %<unsigned%> and %<_Float%d%s%> in "
+			   "declaration specifiers"),
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
               else if (specs->typespec_word == cts_dfloat32)
 		error_at (loc,
 			  ("both %<unsigned%> and %<_Decimal32%> in "
@@ -9887,6 +9919,14 @@  declspecs_add_type (location_t loc, struct c_decls
 		error_at (loc,
 			  ("both %<_Sat%> and %<double%> in "
 			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_floatn_nx)
+		error_at (loc,
+			  ("both %<_Sat%> and %<_Float%d%s%> in "
+			   "declaration specifiers"),
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
               else if (specs->typespec_word == cts_dfloat32)
 		error_at (loc,
 			  ("both %<_Sat%> and %<_Decimal32%> in "
@@ -9920,8 +9960,9 @@  declspecs_add_type (location_t loc, struct c_decls
 	}
       else
 	{
-	  /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
-	     "__intN", "_Decimal64", "_Decimal128", "_Fract", "_Accum" or
+	  /* "void", "_Bool", "char", "int", "float", "double",
+	     "_FloatN", "_FloatNx", "_Decimal32", "__intN",
+	     "_Decimal64", "_Decimal128", "_Fract", "_Accum" or
 	     "__auto_type".  */
 	  if (specs->typespec_word != cts_none)
 	    {
@@ -10146,6 +10187,69 @@  declspecs_add_type (location_t loc, struct c_decls
 		  specs->locations[cdw_typespec] = loc;
 		}
 	      return specs;
+	    CASE_RID_FLOATN_NX:
+	      specs->floatn_nx_idx = i - RID_FLOATN_NX_FIRST;
+	      if (!in_system_header_at (input_location))
+		pedwarn (loc, OPT_Wpedantic,
+			 "ISO C does not support the %<_Float%d%s%> type",
+			 floatn_nx_types[specs->floatn_nx_idx].n,
+			 (floatn_nx_types[specs->floatn_nx_idx].extended
+			  ? "x"
+			  : ""));
+
+	      if (specs->long_p)
+		error_at (loc,
+			  ("both %<long%> and %<_Float%d%s%> in "
+			   "declaration specifiers"),
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
+	      else if (specs->short_p)
+		error_at (loc,
+			  ("both %<short%> and %<_Float%d%s%> in "
+			   "declaration specifiers"),
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
+	      else if (specs->signed_p)
+		error_at (loc,
+			  ("both %<signed%> and %<_Float%d%s%> in "
+			   "declaration specifiers"),
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
+	      else if (specs->unsigned_p)
+		error_at (loc,
+			  ("both %<unsigned%> and %<_Float%d%s%> in "
+			   "declaration specifiers"),
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
+	      else if (specs->saturating_p)
+		error_at (loc,
+			  ("both %<_Sat%> and %<_Float%d%s%> in "
+			   "declaration specifiers"),
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
+	      else if (FLOATN_NX_TYPE_NODE (specs->floatn_nx_idx) == NULL_TREE)
+		error_at (loc,
+			  "%<_Float%d%s%> is not supported on this target",
+			  floatn_nx_types[specs->floatn_nx_idx].n,
+			  (floatn_nx_types[specs->floatn_nx_idx].extended
+			   ? "x"
+			   : ""));
+	      else
+		{
+		  specs->typespec_word = cts_floatn_nx;
+		  specs->locations[cdw_typespec] = loc;
+		}
+	      return specs;
 	    case RID_DFLOAT32:
 	    case RID_DFLOAT64:
 	    case RID_DFLOAT128:
@@ -10623,6 +10727,13 @@  finish_declspecs (struct c_declspecs *specs)
 			 : double_type_node);
 	}
       break;
+    case cts_floatn_nx:
+      gcc_assert (!specs->long_p && !specs->short_p
+		  && !specs->signed_p && !specs->unsigned_p);
+      specs->type = (specs->complex_p
+		     ? COMPLEX_FLOATN_NX_TYPE_NODE (specs->floatn_nx_idx)
+		     : FLOATN_NX_TYPE_NODE (specs->floatn_nx_idx));
+      break;
     case cts_dfloat32:
     case cts_dfloat64:
     case cts_dfloat128:
Index: gcc/c/c-parser.c
===================================================================
--- gcc/c/c-parser.c	(revision 237622)
+++ gcc/c/c-parser.c	(working copy)
@@ -556,6 +556,7 @@  c_token_starts_typename (c_token *token)
 	case RID_DFLOAT32:
 	case RID_DFLOAT64:
 	case RID_DFLOAT128:
+	CASE_RID_FLOATN_NX:
 	case RID_BOOL:
 	case RID_ENUM:
 	case RID_STRUCT:
@@ -717,6 +718,7 @@  c_token_starts_declspecs (c_token *token)
 	case RID_DFLOAT32:
 	case RID_DFLOAT64:
 	case RID_DFLOAT128:
+	CASE_RID_FLOATN_NX:
 	case RID_BOOL:
 	case RID_ENUM:
 	case RID_STRUCT:
@@ -2488,6 +2490,7 @@  c_parser_declspecs (c_parser *parser, struct c_dec
 	case RID_DFLOAT32:
 	case RID_DFLOAT64:
 	case RID_DFLOAT128:
+	CASE_RID_FLOATN_NX:
 	case RID_BOOL:
 	case RID_FRACT:
 	case RID_ACCUM:
@@ -3949,6 +3952,7 @@  c_parser_attribute_any_word (c_parser *parser)
 	case RID_DFLOAT32:
 	case RID_DFLOAT64:
 	case RID_DFLOAT128:
+	CASE_RID_FLOATN_NX:
 	case RID_BOOL:
 	case RID_FRACT:
 	case RID_ACCUM:
@@ -9580,6 +9584,7 @@  c_parser_objc_selector (c_parser *parser)
     case RID_CHAR:
     case RID_FLOAT:
     case RID_DOUBLE:
+    CASE_RID_FLOATN_NX:
     case RID_VOID:
     case RID_BOOL:
     case RID_ATOMIC:
Index: gcc/c/c-tree.h
===================================================================
--- gcc/c/c-tree.h	(revision 237622)
+++ gcc/c/c-tree.h	(working copy)
@@ -230,6 +230,7 @@  enum c_typespec_keyword {
   cts_dfloat32,
   cts_dfloat64,
   cts_dfloat128,
+  cts_floatn_nx,
   cts_fract,
   cts_accum,
   cts_auto_type
@@ -295,6 +296,9 @@  struct c_declspecs {
   int align_log;
   /* For the __intN declspec, this stores the index into the int_n_* arrays.  */
   int int_n_idx;
+  /* For the _FloatN and _FloatNx declspec, this stores the index into
+     the floatn_nx_types array.  */
+  int floatn_nx_idx;
   /* The storage class specifier, or csc_none if none.  */
   enum c_storage_class storage_class;
   /* Any type specifier keyword used such as "int", not reflecting
Index: gcc/c/c-typeck.c
===================================================================
--- gcc/c/c-typeck.c	(revision 237622)
+++ gcc/c/c-typeck.c	(working copy)
@@ -927,18 +927,41 @@  c_common_type (tree t1, tree t2)
 	return long_integer_type_node;
     }
 
+  /* For floating types of the same TYPE_PRECISION (which we here
+     assume means either the same set of values, or sets of values
+     neither a subset of the other, with behavior being undefined in
+     the latter case), follow the rules from TS 18661-3: prefer
+     interchange types _FloatN, then standard types long double,
+     double, float, then extended types _FloatNx.  For extended types,
+     check them starting with _Float128x as that seems most consistent
+     in spirit with preferring long double to double; for interchange
+     types, also check in that order for consistency although it's not
+     possible for more than one of them to have the same
+     precision.  */
+  tree mv1 = TYPE_MAIN_VARIANT (t1);
+  tree mv2 = TYPE_MAIN_VARIANT (t2);
+
+  for (int i = NUM_FLOATN_TYPES - 1; i >= 0; i--)
+    if (mv1 == FLOATN_TYPE_NODE (i) || mv2 == FLOATN_TYPE_NODE (i))
+      return FLOATN_TYPE_NODE (i);
+
   /* Likewise, prefer long double to double even if same size.  */
-  if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
-      || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
+  if (mv1 == long_double_type_node || mv2 == long_double_type_node)
     return long_double_type_node;
 
   /* Likewise, prefer double to float even if same size.
      We got a couple of embedded targets with 32 bit doubles, and the
      pdp11 might have 64 bit floats.  */
-  if (TYPE_MAIN_VARIANT (t1) == double_type_node
-      || TYPE_MAIN_VARIANT (t2) == double_type_node)
+  if (mv1 == double_type_node || mv2 == double_type_node)
     return double_type_node;
 
+  if (mv1 == float_type_node || mv2 == float_type_node)
+    return float_type_node;
+
+  for (int i = NUM_FLOATNX_TYPES - 1; i >= 0; i--)
+    if (mv1 == FLOATNX_TYPE_NODE (i) || mv2 == FLOATNX_TYPE_NODE (i))
+      return FLOATNX_TYPE_NODE (i);
+
   /* Otherwise prefer the unsigned one.  */
 
   if (TYPE_UNSIGNED (t1))
@@ -3283,6 +3306,30 @@  convert_arguments (location_t loc, vec<location_t>
 
       val = require_complete_type (ploc, val);
 
+      /* Some floating-point arguments must be promoted to double when
+	 no type is specified by a prototype.  This applies to
+	 arguments of type float, and to architecture-specific types
+	 (ARM __fp16), but not to _FloatN or _FloatNx types.  */
+      bool promote_float_arg = false;
+      if (type == NULL_TREE
+	  && TREE_CODE (valtype) == REAL_TYPE
+	  && (TYPE_PRECISION (valtype)
+	      <= TYPE_PRECISION (double_type_node))
+	  && TYPE_MAIN_VARIANT (valtype) != double_type_node
+	  && TYPE_MAIN_VARIANT (valtype) != long_double_type_node
+	  && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
+	{
+	  /* Promote this argument, unless it has a _FloatN or
+	     _FloatNx type.  */
+	  promote_float_arg = true;
+	  for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+	    if (TYPE_MAIN_VARIANT (valtype) == FLOATN_NX_TYPE_NODE (i))
+	      {
+		promote_float_arg = false;
+		break;
+	      }
+	}
+
       if (type != 0)
 	{
 	  /* Formal parm type is specified by a function prototype.  */
@@ -3449,12 +3496,7 @@  convert_arguments (location_t loc, vec<location_t>
 		parmval = default_conversion (parmval);
 	    }
 	}
-      else if (TREE_CODE (valtype) == REAL_TYPE
-	       && (TYPE_PRECISION (valtype)
-		   <= TYPE_PRECISION (double_type_node))
-	       && TYPE_MAIN_VARIANT (valtype) != double_type_node
-	       && TYPE_MAIN_VARIANT (valtype) != long_double_type_node
-	       && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
+      else if (promote_float_arg)
         {
 	  if (type_generic)
 	    parmval = val;
Index: gcc/c-family/c-common.c
===================================================================
--- gcc/c-family/c-common.c	(revision 237622)
+++ gcc/c-family/c-common.c	(working copy)
@@ -430,6 +430,13 @@  const struct c_common_resword c_common_reswords[]
   { "_Cilk_sync",       RID_CILK_SYNC,  0 },
   { "_Cilk_for",        RID_CILK_FOR,   0 },
   { "_Imaginary",	RID_IMAGINARY, D_CONLY },
+  { "_Float16",         RID_FLOAT16,   D_CONLY },
+  { "_Float32",         RID_FLOAT32,   D_CONLY },
+  { "_Float64",         RID_FLOAT64,   D_CONLY },
+  { "_Float128",        RID_FLOAT128,  D_CONLY },
+  { "_Float32x",        RID_FLOAT32X,  D_CONLY },
+  { "_Float64x",        RID_FLOAT64X,  D_CONLY },
+  { "_Float128x",       RID_FLOAT128X, D_CONLY },
   { "_Decimal32",       RID_DFLOAT32,  D_CONLY | D_EXT },
   { "_Decimal64",       RID_DFLOAT64,  D_CONLY | D_EXT },
   { "_Decimal128",      RID_DFLOAT128, D_CONLY | D_EXT },
@@ -3408,6 +3415,11 @@  c_common_type_for_mode (machine_mode mode, int uns
   if (mode == TYPE_MODE (long_double_type_node))
     return long_double_type_node;
 
+  for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+    if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE
+	&& mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i)))
+      return FLOATN_NX_TYPE_NODE (i);
+
   if (mode == TYPE_MODE (void_type_node))
     return void_type_node;
 
@@ -3433,6 +3445,11 @@  c_common_type_for_mode (machine_mode mode, int uns
       if (mode == TYPE_MODE (complex_long_double_type_node))
 	return complex_long_double_type_node;
 
+      for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+	if (COMPLEX_FLOATN_NX_TYPE_NODE (i) != NULL_TREE
+	    && mode == TYPE_MODE (COMPLEX_FLOATN_NX_TYPE_NODE (i)))
+	  return COMPLEX_FLOATN_NX_TYPE_NODE (i);
+
       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
 	return complex_integer_type_node;
 
@@ -5349,6 +5366,12 @@  c_common_nodes_and_builtins (void)
   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
   record_builtin_type (RID_MAX, "long double", long_double_type_node);
 
+  if (!c_dialect_cxx ())
+    for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+      if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE)
+	record_builtin_type ((enum rid) (RID_FLOATN_NX_FIRST + i), NULL,
+			     FLOATN_NX_TYPE_NODE (i));
+
   /* Only supported decimal floating point extension if the target
      actually supports underlying modes. */
   if (targetm.scalar_mode_supported_p (SDmode)
@@ -5438,6 +5461,20 @@  c_common_nodes_and_builtins (void)
 		 TYPE_DECL, get_identifier ("complex long double"),
 		 complex_long_double_type_node));
 
+  if (!c_dialect_cxx ())
+    for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+      if (COMPLEX_FLOATN_NX_TYPE_NODE (i) != NULL_TREE)
+	{
+	  char buf[30];
+	  sprintf (buf, "complex _Float%d%s", floatn_nx_types[i].n,
+		   floatn_nx_types[i].extended ? "x" : "");
+	  lang_hooks.decls.pushdecl
+	    (build_decl (UNKNOWN_LOCATION,
+			 TYPE_DECL,
+			 get_identifier (buf),
+			 COMPLEX_FLOATN_NX_TYPE_NODE (i)));
+	}
+
   if (c_dialect_cxx ())
     /* For C++, make fileptr_type_node a distinct void * type until
        FILE type is defined.  */
@@ -12410,6 +12447,7 @@  keyword_begins_type_specifier (enum rid keyword)
     case RID_LONG:
     case RID_SHORT:
     case RID_SIGNED:
+    CASE_RID_FLOATN_NX:
     case RID_DFLOAT32:
     case RID_DFLOAT64:
     case RID_DFLOAT128:
Index: gcc/c-family/c-common.h
===================================================================
--- gcc/c-family/c-common.h	(revision 237622)
+++ gcc/c-family/c-common.h	(working copy)
@@ -102,6 +102,20 @@  enum rid
   RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL,      RID_CHOOSE_EXPR,
   RID_TYPES_COMPATIBLE_P,      RID_BUILTIN_COMPLEX,	     RID_BUILTIN_SHUFFLE,
   RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128,
+
+  /* TS 18661-3 keywords, in the same sequence as the TI_* values.  */
+  RID_FLOAT16,
+  RID_FLOATN_NX_FIRST = RID_FLOAT16,
+  RID_FLOAT32,
+  RID_FLOAT64,
+  RID_FLOAT128,
+  RID_FLOAT32X,
+  RID_FLOAT64X,
+  RID_FLOAT128X,
+#define CASE_RID_FLOATN_NX						\
+  case RID_FLOAT16: case RID_FLOAT32: case RID_FLOAT64: case RID_FLOAT128: \
+  case RID_FLOAT32X: case RID_FLOAT64X: case RID_FLOAT128X
+
   RID_FRACT, RID_ACCUM, RID_AUTO_TYPE, RID_BUILTIN_CALL_WITH_STATIC_CHAIN,
 
   /* C11 */
Index: gcc/c-family/c-cppbuiltin.c
===================================================================
--- gcc/c-family/c-cppbuiltin.c	(revision 237622)
+++ gcc/c-family/c-cppbuiltin.c	(working copy)
@@ -125,7 +125,7 @@  builtin_define_float_constants (const char *name_p
   const double log10_2 = .30102999566398119521;
   double log10_b;
   const struct real_format *fmt;
-  const struct real_format *ldfmt;
+  const struct real_format *widefmt;
 
   char name[64], buf[128];
   int dig, min_10_exp, max_10_exp;
@@ -134,8 +134,20 @@  builtin_define_float_constants (const char *name_p
 
   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
   gcc_assert (fmt->b != 10);
-  ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
-  gcc_assert (ldfmt->b != 10);
+  widefmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
+  gcc_assert (widefmt->b != 10);
+  for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+    {
+      tree wtype = FLOATN_NX_TYPE_NODE (i);
+      if (wtype != NULL_TREE)
+	{
+	  const struct real_format *wfmt
+	    = REAL_MODE_FORMAT (TYPE_MODE (wtype));
+	  gcc_assert (wfmt->b != 10);
+	  if (wfmt->p > widefmt->p)
+	    widefmt = wfmt;
+	}
+    }
 
   /* The radix of the exponent representation.  */
   if (type == float_type_node)
@@ -219,7 +231,7 @@  builtin_define_float_constants (const char *name_p
      floating type, but we want this value for rendering constants below.  */
   {
     double d_decimal_dig
-      = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b;
+      = 1 + (fmt->p < widefmt->p ? widefmt->p : fmt->p) * log10_b;
     decimal_dig = d_decimal_dig;
     if (decimal_dig < d_decimal_dig)
       decimal_dig++;
@@ -231,13 +243,13 @@  builtin_define_float_constants (const char *name_p
     if (type_decimal_dig < type_d_decimal_dig)
       type_decimal_dig++;
   }
+  /* Arbitrarily, define __DECIMAL_DIG__ when defining macros for long
+     double, although it may be greater than the value for long
+     double.  */
   if (type == long_double_type_node)
     builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
-  else
-    {
-      sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
-      builtin_define_with_int_value (name, type_decimal_dig);
-    }
+  sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
+  builtin_define_with_int_value (name, type_decimal_dig);
 
   /* Since, for the supported formats, B is always a power of 2, we
      construct the following numbers directly as a hexadecimal
@@ -289,7 +301,7 @@  builtin_define_float_constants (const char *name_p
   builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
 
   /* Note whether we have fast FMA.  */
-  if (mode_has_fma (TYPE_MODE (type)))
+  if (mode_has_fma (TYPE_MODE (type)) && fma_suffix != NULL)
     {
       sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
       builtin_define_with_int_value (name, 1);
@@ -980,6 +992,19 @@  c_cpp_builtins (cpp_reader *pfile)
   builtin_define_float_constants ("LDBL", "L", "%s", "L",
 				  long_double_type_node);
 
+  for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+    {
+      if (FLOATN_NX_TYPE_NODE (i) == NULL_TREE)
+	continue;
+      char prefix[20], csuffix[20];
+      sprintf (prefix, "FLT%d%s", floatn_nx_types[i].n,
+	       floatn_nx_types[i].extended ? "X" : "");
+      sprintf (csuffix, "F%d%s", floatn_nx_types[i].n,
+	       floatn_nx_types[i].extended ? "x" : "");
+      builtin_define_float_constants (prefix, csuffix, "%s", NULL,
+				      FLOATN_NX_TYPE_NODE (i));
+    }
+
   /* For decfloat.h.  */
   builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
   builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
Index: gcc/c-family/c-lex.c
===================================================================
--- gcc/c-family/c-lex.c	(revision 237622)
+++ gcc/c-family/c-lex.c	(working copy)
@@ -839,6 +839,26 @@  interpret_float (const cpp_token *token, unsigned
 	type = c_common_type_for_mode (mode, 0);
 	gcc_assert (type);
       }
+    else if ((flags & (CPP_N_FLOATN | CPP_N_FLOATNX)) != 0)
+      {
+	unsigned int n = (flags & CPP_N_WIDTH_FLOATN_NX) >> CPP_FLOATN_SHIFT;
+	bool extended = (flags & CPP_N_FLOATNX) != 0;
+	type = NULL_TREE;
+	for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+	  if (floatn_nx_types[i].n == (int) n
+	      && floatn_nx_types[i].extended == extended)
+	    {
+	      type = FLOATN_NX_TYPE_NODE (i);
+	      break;
+	    }
+	if (type == NULL_TREE)
+	  {
+	    error ("unsupported non-standard suffix on floating constant");
+	    return error_mark_node;
+	  }
+	else
+	  pedwarn (input_location, OPT_Wpedantic, "non-standard suffix on floating constant");
+      }
     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
       type = long_double_type_node;
     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
@@ -867,6 +887,17 @@  interpret_float (const cpp_token *token, unsigned
       if (flags & CPP_N_IMAGINARY)
 	/* I or J suffix.  */
 	copylen--;
+      if (flags & CPP_N_FLOATNX)
+	copylen--;
+      if (flags & (CPP_N_FLOATN | CPP_N_FLOATNX))
+	{
+	  unsigned int n = (flags & CPP_N_WIDTH_FLOATN_NX) >> CPP_FLOATN_SHIFT;
+	  while (n > 0)
+	    {
+	      copylen--;
+	      n /= 10;
+	    }
+	}
     }
 
   copy = (char *) alloca (copylen + 1);
Index: gcc/c-family/c-pretty-print.c
===================================================================
--- gcc/c-family/c-pretty-print.c	(revision 237622)
+++ gcc/c-family/c-pretty-print.c	(working copy)
@@ -1045,6 +1045,16 @@  pp_c_floating_constant (c_pretty_printer *pp, tree
     pp_string (pp, "dd");
   else if (TREE_TYPE (r) == dfloat32_type_node)
     pp_string (pp, "df");
+  else if (TREE_TYPE (r) != double_type_node)
+    for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+      if (TREE_TYPE (r) == FLOATN_NX_TYPE_NODE (i))
+	{
+	  pp_character (pp, 'f');
+	  pp_decimal_int (pp, floatn_nx_types[i].n);
+	  if (floatn_nx_types[i].extended)
+	    pp_character (pp, 'x');
+	  break;
+	}
 }
 
 /* Print out a FIXED value as a decimal-floating-constant.  */
Index: gcc/config/i386/i386.c
===================================================================
--- gcc/config/i386/i386.c	(revision 237622)
+++ gcc/config/i386/i386.c	(working copy)
@@ -38275,24 +38275,29 @@  ix86_init_builtins_va_builtins_abi (void)
 static void
 ix86_init_builtin_types (void)
 {
-  tree float128_type_node, float80_type_node, const_string_type_node;
+  tree float80_type_node, const_string_type_node;
 
   /* The __float80 type.  */
   float80_type_node = long_double_type_node;
   if (TYPE_MODE (float80_type_node) != XFmode)
     {
-      /* The __float80 type.  */
-      float80_type_node = make_node (REAL_TYPE);
+      if (float64x_type_node != NULL_TREE
+	  && TYPE_MODE (float64x_type_node) == XFmode)
+	float80_type_node = float64x_type_node;
+      else
+	{
+	  /* The __float80 type.  */
+	  float80_type_node = make_node (REAL_TYPE);
 
-      TYPE_PRECISION (float80_type_node) = 80;
-      layout_type (float80_type_node);
+	  TYPE_PRECISION (float80_type_node) = 80;
+	  layout_type (float80_type_node);
+	}
     }
   lang_hooks.types.register_builtin_type (float80_type_node, "__float80");
 
-  /* The __float128 type.  */
-  float128_type_node = make_node (REAL_TYPE);
-  TYPE_PRECISION (float128_type_node) = 128;
-  layout_type (float128_type_node);
+  /* The __float128 type.  The node has already been created as
+     _Float128, so we only need to register the __float128 name for
+     it.  */
   lang_hooks.types.register_builtin_type (float128_type_node, "__float128");
 
   const_string_type_node
Index: gcc/config/ia64/ia64.c
===================================================================
--- gcc/config/ia64/ia64.c	(revision 237622)
+++ gcc/config/ia64/ia64.c	(working copy)
@@ -10350,9 +10350,15 @@  ia64_init_builtins (void)
   (*lang_hooks.types.register_builtin_type) (fpreg_type, "__fpreg");
 
   /* The __float80 type.  */
-  float80_type = make_node (REAL_TYPE);
-  TYPE_PRECISION (float80_type) = 80;
-  layout_type (float80_type);
+  if (float64x_type_node != NULL_TREE
+      && TYPE_MODE (float64x_type_node) == XFmode)
+    float80_type = float64x_type_node;
+  else
+    {
+      float80_type = make_node (REAL_TYPE);
+      TYPE_PRECISION (float80_type) = 80;
+      layout_type (float80_type);
+    }
   (*lang_hooks.types.register_builtin_type) (float80_type, "__float80");
 
   /* The __float128 type.  */
@@ -10362,14 +10368,12 @@  ia64_init_builtins (void)
       tree const_string_type
 	= build_pointer_type (build_qualified_type
 			      (char_type_node, TYPE_QUAL_CONST));
-      tree float128_type = make_node (REAL_TYPE);
 
-      TYPE_PRECISION (float128_type) = 128;
-      layout_type (float128_type);
-      (*lang_hooks.types.register_builtin_type) (float128_type, "__float128");
+      (*lang_hooks.types.register_builtin_type) (float128_type_node,
+						 "__float128");
 
       /* TFmode support builtins.  */
-      ftype = build_function_type_list (float128_type, NULL_TREE);
+      ftype = build_function_type_list (float128_type_node, NULL_TREE);
       decl = add_builtin_function ("__builtin_infq", ftype,
 				   IA64_BUILTIN_INFQ, BUILT_IN_MD,
 				   NULL, NULL_TREE);
@@ -10380,7 +10384,7 @@  ia64_init_builtins (void)
 				   NULL, NULL_TREE);
       ia64_builtins[IA64_BUILTIN_HUGE_VALQ] = decl;
 
-      ftype = build_function_type_list (float128_type,
+      ftype = build_function_type_list (float128_type_node,
 					const_string_type,
 					NULL_TREE);
       decl = add_builtin_function ("__builtin_nanq", ftype,
@@ -10395,8 +10399,8 @@  ia64_init_builtins (void)
       TREE_READONLY (decl) = 1;
       ia64_builtins[IA64_BUILTIN_NANSQ] = decl;
 
-      ftype = build_function_type_list (float128_type,
-					float128_type,
+      ftype = build_function_type_list (float128_type_node,
+					float128_type_node,
 					NULL_TREE);
       decl = add_builtin_function ("__builtin_fabsq", ftype,
 				   IA64_BUILTIN_FABSQ, BUILT_IN_MD,
@@ -10404,9 +10408,9 @@  ia64_init_builtins (void)
       TREE_READONLY (decl) = 1;
       ia64_builtins[IA64_BUILTIN_FABSQ] = decl;
 
-      ftype = build_function_type_list (float128_type,
-					float128_type,
-					float128_type,
+      ftype = build_function_type_list (float128_type_node,
+					float128_type_node,
+					float128_type_node,
 					NULL_TREE);
       decl = add_builtin_function ("__builtin_copysignq", ftype,
 				   IA64_BUILTIN_COPYSIGNQ, BUILT_IN_MD,
Index: gcc/config/pdp11/pdp11.c
===================================================================
--- gcc/config/pdp11/pdp11.c	(revision 237622)
+++ gcc/config/pdp11/pdp11.c	(working copy)
@@ -69,6 +69,7 @@  const struct real_format pdp11_f_format =
     127,
     15,
     15,
+    0,
     false,
     false,
     false,
@@ -91,6 +92,7 @@  const struct real_format pdp11_d_format =
     127,
     15,
     15,
+    0,
     false,
     false,
     false,
Index: gcc/config/rs6000/rs6000.c
===================================================================
--- gcc/config/rs6000/rs6000.c	(revision 237622)
+++ gcc/config/rs6000/rs6000.c	(working copy)
@@ -1698,6 +1698,9 @@  static const struct attribute_spec rs6000_attribut
 #undef TARGET_VECTOR_MODE_SUPPORTED_P
 #define TARGET_VECTOR_MODE_SUPPORTED_P rs6000_vector_mode_supported_p
 
+#undef TARGET_FLOATN_MODE
+#define TARGET_FLOATN_MODE rs6000_floatn_mode
+
 #undef TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
 #define TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN invalid_arg_for_unprototyped_fn
 
@@ -15820,10 +15823,7 @@  rs6000_init_builtins (void)
       layout_type (ibm128_float_type_node);
       SET_TYPE_MODE (ibm128_float_type_node, IFmode);
 
-      ieee128_float_type_node = make_node (REAL_TYPE);
-      TYPE_PRECISION (ieee128_float_type_node) = 128;
-      layout_type (ieee128_float_type_node);
-      SET_TYPE_MODE (ieee128_float_type_node, KFmode);
+      ieee128_float_type_node = float128_type_node;
 
       lang_hooks.types.register_builtin_type (ieee128_float_type_node,
 					      "__float128");
@@ -35383,6 +35383,54 @@  rs6000_vector_mode_supported_p (machine_mode mode)
     return false;
 }
 
+/* Target hook for floatn_mode.  */
+static machine_mode
+rs6000_floatn_mode (int n, bool extended)
+{
+  if (extended)
+    {
+      switch (n)
+	{
+	case 32:
+	  return DFmode;
+
+	case 64:
+	  if (TARGET_FLOAT128)
+	    return (FLOAT128_IEEE_P (TFmode)) ? TFmode : KFmode;
+	  else
+	    return VOIDmode;
+
+	case 128:
+	  return VOIDmode;
+
+	default:
+	  /* Those are the only valid _FloatNx types.  */
+	  gcc_unreachable ();
+	}
+    }
+  else
+    {
+      switch (n)
+	{
+	case 32:
+	  return SFmode;
+
+	case 64:
+	  return DFmode;
+
+	case 128:
+	  if (TARGET_FLOAT128)
+	    return (FLOAT128_IEEE_P (TFmode)) ? TFmode : KFmode;
+	  else
+	    return VOIDmode;
+
+	default:
+	  return VOIDmode;
+	}
+    }
+
+}
+
 /* Target hook for c_mode_for_suffix.  */
 static machine_mode
 rs6000_c_mode_for_suffix (char suffix)
Index: gcc/doc/extend.texi
===================================================================
--- gcc/doc/extend.texi	(revision 237622)
+++ gcc/doc/extend.texi	(working copy)
@@ -927,6 +927,8 @@  examine and set these two fictitious variables wit
 @node Floating Types
 @section Additional Floating Types
 @cindex additional floating types
+@cindex @code{_Float@var{n}} data types
+@cindex @code{_Float@var{n}x} data types
 @cindex @code{__float80} data type
 @cindex @code{__float128} data type
 @cindex @code{__ibm128} data type
@@ -935,9 +937,19 @@  examine and set these two fictitious variables wit
 @cindex @code{W} floating point suffix
 @cindex @code{Q} floating point suffix
 
-As an extension, GNU C supports additional floating
+ISO/IEC TS 18661-3:2015 defines C support for additional floating
+types @code{_Float@var{n}} and @code{_Float@var{n}x}, and GCC supports
+these type names; the set of types supported depends on the target
+architecture.  These types are not supported when compiling C++.
+Constants with these types use suffixes @code{f@var{n}} or
+@code{F@var{n}} and @code{f@var{n}x} or @code{F@var{n}x}.  These type
+names can be used together with @code{_Complex} to declare complex
+types.
+
+As an extension, GNU C and GNU C++ support additional floating
 types, @code{__float80} and @code{__float128} to support 80-bit
-(@code{XFmode}) and 128-bit (@code{TFmode}) floating types.
+(@code{XFmode}) and 128-bit (@code{TFmode}) floating types; these are
+aliases for the type names @code{_Float64x} and @code{_Float128}.
 Support for additional types includes the arithmetic operators:
 add, subtract, multiply, divide; unary arithmetic operators;
 relational operators; equality operators; and conversions to and from
@@ -954,9 +966,11 @@  typedef _Complex float __attribute__((mode(TC))) _
 typedef _Complex float __attribute__((mode(XC))) _Complex80;
 @end smallexample
 
-In order to use @code{__float128} and @code{__ibm128} on PowerPC Linux
+In order to use @code{_Float128}, @code{__float128} and
+@code{__ibm128} on PowerPC Linux
 systems, you must use the @option{-mfloat128}. It is expected in
-future versions of GCC that @code{__float128} will be enabled
+future versions of GCC that @code{_Float128} and @code{__float128}
+will be enabled
 automatically.  In addition, there are currently problems in using the
 complex @code{__float128} type.  When these problems are fixed, you
 would use the following syntax to declare @code{_Complex128} to be a
@@ -976,7 +990,14 @@  Not all targets support additional floating-point
 IA-64 targets.  The @code{__float128} type is supported on hppa HP-UX.
 The @code{__float128} type is supported on PowerPC 64-bit Linux
 systems by default if the vector scalar instruction set (VSX) is
-enabled.
+enabled.  The @code{_Float128} type is supported on all systems where
+@code{__float128} is supported or where @code{long double} has the
+IEEE binary128 format.  The @code{_Float64x} type is supported on all
+systems where @code{__float128} is supported.  The @code{_Float32}
+type is supported on all systems supporting IEEE binary32; the
+@code{_Float64} and @code{Float32x} types are supported on all systems
+supporting IEEE binary64.  GCC does not currently support
+@code{_Float16} or @code{_Float128x} on any systems.
 
 On the PowerPC, @code{__ibm128} provides access to the IBM extended
 double format, and it is intended to be used by the library functions
Index: gcc/doc/sourcebuild.texi
===================================================================
--- gcc/doc/sourcebuild.texi	(revision 237622)
+++ gcc/doc/sourcebuild.texi	(working copy)
@@ -1321,6 +1321,12 @@  Target supports array and structure sizes that are
 
 @item 4byte_wchar_t
 Target has @code{wchar_t} that is at least 4 bytes.
+
+@item float@var{n}
+Target has the @code{_Float@var{n}} type.
+
+@item float@var{n}x
+Target has the @code{_Float@var{n}x} type.
 @end table
 
 @subsubsection Fortran-specific attributes
Index: gcc/doc/tm.texi
===================================================================
--- gcc/doc/tm.texi	(revision 237622)
+++ gcc/doc/tm.texi	(working copy)
@@ -4269,6 +4269,24 @@  hook returns true for all of @code{SFmode}, @code{
 @code{XFmode} and @code{TFmode}, if such modes exist.
 @end deftypefn
 
+@deftypefn {Target Hook} machine_mode TARGET_FLOATN_MODE (int @var{n}, bool @var{extended})
+Define this to return the machine mode to use for the type 
+@code{_Float@var{n}}, if @var{extended} is false, or the type 
+@code{_Float@var{n}x}, if @var{extended} is true.  If such a type 
+is not supported, return @code{VOIDmode}.  The default version of this 
+hook returns @code{SFmode} for @code{_Float32}, @code{DFmode} for 
+@code{_Float64} and @code{_Float32x} and @code{TFmode} for 
+@code{_Float128}, if those modes exist and satisfy the requirements for 
+those types and pass @code{TARGET_SCALAR_MODE_SUPPORTED_P} and 
+@code{TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P}; for @code{_Float64x}, it 
+returns the first of @code{XFmode} and @code{TFmode} that exists and 
+satisfies the same requirements; for other types, it returns 
+@code{VOIDmode}.  The hook is only called for values of @var{n} and 
+@var{extended} that are valid according to ISO/IEC TS 18661-3:2015; that 
+is, @var{n} is one of 32, 64, 128, or, if @var{extended} is false, 16 or 
+greater than 128 and a multiple of 32.
+@end deftypefn
+
 @deftypefn {Target Hook} bool TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P (machine_mode @var{mode})
 Define this to return nonzero for machine modes for which the port has
 small register classes.  If this target hook returns nonzero for a given
Index: gcc/doc/tm.texi.in
===================================================================
--- gcc/doc/tm.texi.in	(revision 237622)
+++ gcc/doc/tm.texi.in	(working copy)
@@ -3527,6 +3527,8 @@  stack.
 
 @hook TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P
 
+@hook TARGET_FLOATN_MODE
+
 @hook TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P
 
 @node Scalar Return
Index: gcc/fortran/iso-c-binding.def
===================================================================
--- gcc/fortran/iso-c-binding.def	(revision 237622)
+++ gcc/fortran/iso-c-binding.def	(working copy)
@@ -115,8 +115,8 @@  NAMED_REALCST (ISOCBINDING_DOUBLE, "c_double", \
 NAMED_REALCST (ISOCBINDING_LONG_DOUBLE, "c_long_double", \
                get_real_kind_from_node (long_double_type_node), GFC_STD_F2003)
 NAMED_REALCST (ISOCBINDING_FLOAT128, "c_float128", \
-	       float128_type_node == NULL_TREE \
-		  ? -4 : get_real_kind_from_node (float128_type_node), \
+	       gfc_float128_type_node == NULL_TREE \
+		  ? -4 : get_real_kind_from_node (gfc_float128_type_node), \
 	       GFC_STD_GNU)
 NAMED_CMPXCST (ISOCBINDING_FLOAT_COMPLEX, "c_float_complex", \
                get_real_kind_from_node (float_type_node), GFC_STD_F2003)
@@ -125,8 +125,8 @@  NAMED_CMPXCST (ISOCBINDING_DOUBLE_COMPLEX, "c_doub
 NAMED_CMPXCST (ISOCBINDING_LONG_DOUBLE_COMPLEX, "c_long_double_complex", \
                get_real_kind_from_node (long_double_type_node), GFC_STD_F2003)
 NAMED_CMPXCST (ISOCBINDING_FLOAT128_COMPLEX, "c_float128_complex", \
-	       float128_type_node == NULL_TREE \
-		  ? -4 : get_real_kind_from_node (float128_type_node), \
+	       gfc_float128_type_node == NULL_TREE \
+		  ? -4 : get_real_kind_from_node (gfc_float128_type_node), \
 	       GFC_STD_GNU)
 
 NAMED_LOGCST (ISOCBINDING_BOOL, "c_bool", \
Index: gcc/fortran/trans-intrinsic.c
===================================================================
--- gcc/fortran/trans-intrinsic.c	(revision 237622)
+++ gcc/fortran/trans-intrinsic.c	(working copy)
@@ -149,7 +149,7 @@  builtin_decl_for_precision (enum built_in_function
     i = m->double_built_in;
   else if (precision == TYPE_PRECISION (long_double_type_node))
     i = m->long_double_built_in;
-  else if (precision == TYPE_PRECISION (float128_type_node))
+  else if (precision == TYPE_PRECISION (gfc_float128_type_node))
     {
       /* Special treatment, because it is not exactly a built-in, but
 	 a library function.  */
@@ -621,8 +621,8 @@  gfc_build_intrinsic_lib_fndecls (void)
 
     memset (quad_decls, 0, sizeof(tree) * (END_BUILTINS + 1));
 
-    type = float128_type_node;
-    complex_type = complex_float128_type_node;
+    type = gfc_float128_type_node;
+    complex_type = gfc_complex_float128_type_node;
     /* type (*) (type) */
     func_1 = build_function_type_list (type, type, NULL_TREE);
     /* int (*) (type) */
Index: gcc/fortran/trans-types.c
===================================================================
--- gcc/fortran/trans-types.c	(revision 237622)
+++ gcc/fortran/trans-types.c	(working copy)
@@ -62,8 +62,8 @@  tree pfunc_type_node;
 
 tree gfc_charlen_type_node;
 
-tree float128_type_node = NULL_TREE;
-tree complex_float128_type_node = NULL_TREE;
+tree gfc_float128_type_node = NULL_TREE;
+tree gfc_complex_float128_type_node = NULL_TREE;
 
 bool gfc_real16_is_float128 = false;
 
@@ -902,7 +902,7 @@  gfc_init_types (void)
       PUSH_TYPE (name_buf, type);
 
       if (gfc_real_kinds[index].c_float128)
-	float128_type_node = type;
+	gfc_float128_type_node = type;
 
       type = gfc_build_complex_type (type);
       gfc_complex_types[index] = type;
@@ -911,7 +911,7 @@  gfc_init_types (void)
       PUSH_TYPE (name_buf, type);
 
       if (gfc_real_kinds[index].c_float128)
-	complex_float128_type_node = type;
+	gfc_complex_float128_type_node = type;
     }
 
   for (index = 0; gfc_character_kinds[index].kind != 0; ++index)
Index: gcc/fortran/trans-types.h
===================================================================
--- gcc/fortran/trans-types.h	(revision 237622)
+++ gcc/fortran/trans-types.h	(working copy)
@@ -30,8 +30,8 @@  extern GTY(()) tree ppvoid_type_node;
 extern GTY(()) tree pvoid_type_node;
 extern GTY(()) tree prvoid_type_node;
 extern GTY(()) tree pchar_type_node;
-extern GTY(()) tree float128_type_node;
-extern GTY(()) tree complex_float128_type_node;
+extern GTY(()) tree gfc_float128_type_node;
+extern GTY(()) tree gfc_complex_float128_type_node;
 
 /* This is the type used to hold the lengths of character variables.
    It must be the same as the corresponding definition in gfortran.h.  */
Index: gcc/ginclude/float.h
===================================================================
--- gcc/ginclude/float.h	(revision 237622)
+++ gcc/ginclude/float.h	(working copy)
@@ -165,7 +165,7 @@  see the files COPYING3 and COPYING.RUNTIME respect
 #undef LDBL_DECIMAL_DIG
 #define FLT_DECIMAL_DIG		__FLT_DECIMAL_DIG__
 #define DBL_DECIMAL_DIG		__DBL_DECIMAL_DIG__
-#define LDBL_DECIMAL_DIG	__DECIMAL_DIG__
+#define LDBL_DECIMAL_DIG	__LDBL_DECIMAL_DIG__
 
 /* Whether types support subnormal numbers.  */
 #undef FLT_HAS_SUBNORM
@@ -185,6 +185,187 @@  see the files COPYING3 and COPYING.RUNTIME respect
 
 #endif /* C11 */
 
+#ifdef __STDC_WANT_IEC_60559_TYPES_EXT__
+/* Constants for _FloatN and _FloatNx types from TS 18661-3.  See
+   comments above for their semantics.  */
+
+#ifdef __FLT16_MANT_DIG__
+#undef FLT16_MANT_DIG
+#define FLT16_MANT_DIG		__FLT16_MANT_DIG__
+#undef FLT16_DIG
+#define FLT16_DIG		__FLT16_DIG__
+#undef FLT16_MIN_EXP
+#define FLT16_MIN_EXP		__FLT16_MIN_EXP__
+#undef FLT16_MIN_10_EXP
+#define FLT16_MIN_10_EXP	__FLT16_MIN_10_EXP__
+#undef FLT16_MAX_EXP
+#define FLT16_MAX_EXP		__FLT16_MAX_EXP__
+#undef FLT16_MAX_10_EXP
+#define FLT16_MAX_10_EXP	__FLT16_MAX_10_EXP__
+#undef FLT16_MAX
+#define FLT16_MAX		__FLT16_MAX__
+#undef FLT16_EPSILON
+#define FLT16_EPSILON		__FLT16_EPSILON__
+#undef FLT16_MIN
+#define FLT16_MIN		__FLT16_MIN__
+#undef FLT16_DECIMAL_DIG
+#define FLT16_DECIMAL_DIG	__FLT16_DECIMAL_DIG__
+#undef FLT16_TRUE_MIN
+#define FLT16_TRUE_MIN		__FLT16_DENORM_MIN__
+#endif /* __FLT16_MANT_DIG__.  */
+
+#ifdef __FLT32_MANT_DIG__
+#undef FLT32_MANT_DIG
+#define FLT32_MANT_DIG		__FLT32_MANT_DIG__
+#undef FLT32_DIG
+#define FLT32_DIG		__FLT32_DIG__
+#undef FLT32_MIN_EXP
+#define FLT32_MIN_EXP		__FLT32_MIN_EXP__
+#undef FLT32_MIN_10_EXP
+#define FLT32_MIN_10_EXP	__FLT32_MIN_10_EXP__
+#undef FLT32_MAX_EXP
+#define FLT32_MAX_EXP		__FLT32_MAX_EXP__
+#undef FLT32_MAX_10_EXP
+#define FLT32_MAX_10_EXP	__FLT32_MAX_10_EXP__
+#undef FLT32_MAX
+#define FLT32_MAX		__FLT32_MAX__
+#undef FLT32_EPSILON
+#define FLT32_EPSILON		__FLT32_EPSILON__
+#undef FLT32_MIN
+#define FLT32_MIN		__FLT32_MIN__
+#undef FLT32_DECIMAL_DIG
+#define FLT32_DECIMAL_DIG	__FLT32_DECIMAL_DIG__
+#undef FLT32_TRUE_MIN
+#define FLT32_TRUE_MIN		__FLT32_DENORM_MIN__
+#endif /* __FLT32_MANT_DIG__.  */
+
+#ifdef __FLT64_MANT_DIG__
+#undef FLT64_MANT_DIG
+#define FLT64_MANT_DIG		__FLT64_MANT_DIG__
+#undef FLT64_DIG
+#define FLT64_DIG		__FLT64_DIG__
+#undef FLT64_MIN_EXP
+#define FLT64_MIN_EXP		__FLT64_MIN_EXP__
+#undef FLT64_MIN_10_EXP
+#define FLT64_MIN_10_EXP	__FLT64_MIN_10_EXP__
+#undef FLT64_MAX_EXP
+#define FLT64_MAX_EXP		__FLT64_MAX_EXP__
+#undef FLT64_MAX_10_EXP
+#define FLT64_MAX_10_EXP	__FLT64_MAX_10_EXP__
+#undef FLT64_MAX
+#define FLT64_MAX		__FLT64_MAX__
+#undef FLT64_EPSILON
+#define FLT64_EPSILON		__FLT64_EPSILON__
+#undef FLT64_MIN
+#define FLT64_MIN		__FLT64_MIN__
+#undef FLT64_DECIMAL_DIG
+#define FLT64_DECIMAL_DIG	__FLT64_DECIMAL_DIG__
+#undef FLT64_TRUE_MIN
+#define FLT64_TRUE_MIN		__FLT64_DENORM_MIN__
+#endif /* __FLT64_MANT_DIG__.  */
+
+#ifdef __FLT128_MANT_DIG__
+#undef FLT128_MANT_DIG
+#define FLT128_MANT_DIG		__FLT128_MANT_DIG__
+#undef FLT128_DIG
+#define FLT128_DIG		__FLT128_DIG__
+#undef FLT128_MIN_EXP
+#define FLT128_MIN_EXP		__FLT128_MIN_EXP__
+#undef FLT128_MIN_10_EXP
+#define FLT128_MIN_10_EXP	__FLT128_MIN_10_EXP__
+#undef FLT128_MAX_EXP
+#define FLT128_MAX_EXP		__FLT128_MAX_EXP__
+#undef FLT128_MAX_10_EXP
+#define FLT128_MAX_10_EXP	__FLT128_MAX_10_EXP__
+#undef FLT128_MAX
+#define FLT128_MAX		__FLT128_MAX__
+#undef FLT128_EPSILON
+#define FLT128_EPSILON		__FLT128_EPSILON__
+#undef FLT128_MIN
+#define FLT128_MIN		__FLT128_MIN__
+#undef FLT128_DECIMAL_DIG
+#define FLT128_DECIMAL_DIG	__FLT128_DECIMAL_DIG__
+#undef FLT128_TRUE_MIN
+#define FLT128_TRUE_MIN		__FLT128_DENORM_MIN__
+#endif /* __FLT128_MANT_DIG__.  */
+
+#ifdef __FLT32X_MANT_DIG__
+#undef FLT32X_MANT_DIG
+#define FLT32X_MANT_DIG		__FLT32X_MANT_DIG__
+#undef FLT32X_DIG
+#define FLT32X_DIG		__FLT32X_DIG__
+#undef FLT32X_MIN_EXP
+#define FLT32X_MIN_EXP		__FLT32X_MIN_EXP__
+#undef FLT32X_MIN_10_EXP
+#define FLT32X_MIN_10_EXP	__FLT32X_MIN_10_EXP__
+#undef FLT32X_MAX_EXP
+#define FLT32X_MAX_EXP		__FLT32X_MAX_EXP__
+#undef FLT32X_MAX_10_EXP
+#define FLT32X_MAX_10_EXP	__FLT32X_MAX_10_EXP__
+#undef FLT32X_MAX
+#define FLT32X_MAX		__FLT32X_MAX__
+#undef FLT32X_EPSILON
+#define FLT32X_EPSILON		__FLT32X_EPSILON__
+#undef FLT32X_MIN
+#define FLT32X_MIN		__FLT32X_MIN__
+#undef FLT32X_DECIMAL_DIG
+#define FLT32X_DECIMAL_DIG	__FLT32X_DECIMAL_DIG__
+#undef FLT32X_TRUE_MIN
+#define FLT32X_TRUE_MIN		__FLT32X_DENORM_MIN__
+#endif /* __FLT32X_MANT_DIG__.  */
+
+#ifdef __FLT64X_MANT_DIG__
+#undef FLT64X_MANT_DIG
+#define FLT64X_MANT_DIG		__FLT64X_MANT_DIG__
+#undef FLT64X_DIG
+#define FLT64X_DIG		__FLT64X_DIG__
+#undef FLT64X_MIN_EXP
+#define FLT64X_MIN_EXP		__FLT64X_MIN_EXP__
+#undef FLT64X_MIN_10_EXP
+#define FLT64X_MIN_10_EXP	__FLT64X_MIN_10_EXP__
+#undef FLT64X_MAX_EXP
+#define FLT64X_MAX_EXP		__FLT64X_MAX_EXP__
+#undef FLT64X_MAX_10_EXP
+#define FLT64X_MAX_10_EXP	__FLT64X_MAX_10_EXP__
+#undef FLT64X_MAX
+#define FLT64X_MAX		__FLT64X_MAX__
+#undef FLT64X_EPSILON
+#define FLT64X_EPSILON		__FLT64X_EPSILON__
+#undef FLT64X_MIN
+#define FLT64X_MIN		__FLT64X_MIN__
+#undef FLT64X_DECIMAL_DIG
+#define FLT64X_DECIMAL_DIG	__FLT64X_DECIMAL_DIG__
+#undef FLT64X_TRUE_MIN
+#define FLT64X_TRUE_MIN		__FLT64X_DENORM_MIN__
+#endif /* __FLT64X_MANT_DIG__.  */
+
+#ifdef __FLT128X_MANT_DIG__
+#undef FLT128X_MANT_DIG
+#define FLT128X_MANT_DIG	__FLT128X_MANT_DIG__
+#undef FLT128X_DIG
+#define FLT128X_DIG		__FLT128X_DIG__
+#undef FLT128X_MIN_EXP
+#define FLT128X_MIN_EXP		__FLT128X_MIN_EXP__
+#undef FLT128X_MIN_10_EXP
+#define FLT128X_MIN_10_EXP	__FLT128X_MIN_10_EXP__
+#undef FLT128X_MAX_EXP
+#define FLT128X_MAX_EXP		__FLT128X_MAX_EXP__
+#undef FLT128X_MAX_10_EXP
+#define FLT128X_MAX_10_EXP	__FLT128X_MAX_10_EXP__
+#undef FLT128X_MAX
+#define FLT128X_MAX		__FLT128X_MAX__
+#undef FLT128X_EPSILON
+#define FLT128X_EPSILON		__FLT128X_EPSILON__
+#undef FLT128X_MIN
+#define FLT128X_MIN		__FLT128X_MIN__
+#undef FLT128X_DECIMAL_DIG
+#define FLT128X_DECIMAL_DIG	__FLT128X_DECIMAL_DIG__
+#undef FLT128X_TRUE_MIN
+#define FLT128X_TRUE_MIN	__FLT128X_DENORM_MIN__
+#endif /* __FLT128X_MANT_DIG__.  */
+
+#endif /* __STDC_WANT_IEC_60559_TYPES_EXT__.  */
+
 #ifdef __STDC_WANT_DEC_FP__
 /* Draft Technical Report 24732, extension for decimal floating-point
    arithmetic: Characteristic of decimal floating types <float.h>.  */
Index: gcc/real.c
===================================================================
--- gcc/real.c	(revision 237622)
+++ gcc/real.c	(working copy)
@@ -3042,6 +3042,7 @@  const struct real_format ieee_single_format =
     128,
     31,
     31,
+    32,
     false,
     true,
     true,
@@ -3064,6 +3065,7 @@  const struct real_format mips_single_format =
     128,
     31,
     31,
+    32,
     false,
     true,
     true,
@@ -3086,6 +3088,7 @@  const struct real_format motorola_single_format =
     128,
     31,
     31,
+    32,
     false,
     true,
     true,
@@ -3119,6 +3122,7 @@  const struct real_format spu_single_format =
     129,
     31,
     31,
+    0,
     true,
     false,
     false,
@@ -3329,6 +3333,7 @@  const struct real_format ieee_double_format =
     1024,
     63,
     63,
+    64,
     false,
     true,
     true,
@@ -3351,6 +3356,7 @@  const struct real_format mips_double_format =
     1024,
     63,
     63,
+    64,
     false,
     true,
     true,
@@ -3373,6 +3379,7 @@  const struct real_format motorola_double_format =
     1024,
     63,
     63,
+    64,
     false,
     true,
     true,
@@ -3718,6 +3725,7 @@  const struct real_format ieee_extended_motorola_fo
     16384,
     95,
     95,
+    0,
     false,
     true,
     true,
@@ -3740,6 +3748,7 @@  const struct real_format ieee_extended_intel_96_fo
     16384,
     79,
     79,
+    65,
     false,
     true,
     true,
@@ -3762,6 +3771,7 @@  const struct real_format ieee_extended_intel_128_f
     16384,
     79,
     79,
+    65,
     false,
     true,
     true,
@@ -3786,6 +3796,7 @@  const struct real_format ieee_extended_intel_96_ro
     16384,
     79,
     79,
+    33,
     false,
     true,
     true,
@@ -3875,6 +3886,7 @@  const struct real_format ibm_extended_format =
     1024,
     127,
     -1,
+    0,
     false,
     true,
     true,
@@ -3897,6 +3909,7 @@  const struct real_format mips_extended_format =
     1024,
     127,
     -1,
+    0,
     false,
     true,
     true,
@@ -4161,6 +4174,7 @@  const struct real_format ieee_quad_format =
     16384,
     127,
     127,
+    128,
     false,
     true,
     true,
@@ -4183,6 +4197,7 @@  const struct real_format mips_quad_format =
     16384,
     127,
     127,
+    128,
     false,
     true,
     true,
@@ -4484,6 +4499,7 @@  const struct real_format vax_f_format =
     127,
     15,
     15,
+    0,
     false,
     false,
     false,
@@ -4506,6 +4522,7 @@  const struct real_format vax_d_format =
     127,
     15,
     15,
+    0,
     false,
     false,
     false,
@@ -4528,6 +4545,7 @@  const struct real_format vax_g_format =
     1023,
     15,
     15,
+    0,
     false,
     false,
     false,
@@ -4605,6 +4623,7 @@  const struct real_format decimal_single_format =
     97,
     31,
     31,
+    32,
     false,
     true,
     true,
@@ -4628,6 +4647,7 @@  const struct real_format decimal_double_format =
     385,
     63,
     63,
+    64,
     false,
     true,
     true,
@@ -4651,6 +4671,7 @@  const struct real_format decimal_quad_format =
     6145,
     127,
     127,
+    128,
     false,
     true,
     true,
@@ -4789,6 +4810,7 @@  const struct real_format ieee_half_format =
     16,
     15,
     15,
+    16,
     false,
     true,
     true,
@@ -4814,6 +4836,7 @@  const struct real_format arm_half_format =
     17,
     15,
     15,
+    0,
     false,
     true,
     false,
@@ -4860,6 +4883,7 @@  const struct real_format real_internal_format =
     MAX_EXP,
     -1,
     -1,
+    0,
     false,
     false,
     true,
Index: gcc/real.h
===================================================================
--- gcc/real.h	(revision 237622)
+++ gcc/real.h	(working copy)
@@ -139,6 +139,17 @@  struct real_format
      or -1 for a complex encoding.  */
   int signbit_rw;
 
+  /* If this is an IEEE interchange format, the number of bits in the
+     format; otherwise, if it is an IEEE extended format, one more
+     than the greatest number of bits in an interchange format it
+     extends; otherwise 0.  Formats need not follow the IEEE 754-2008
+     recommended practice regarding how signaling NaNs are identified,
+     and may vary in the choice of default NaN, but must follow other
+     IEEE practice regarding having NaNs, infinities and subnormal
+     values, and the relation of minimum and maximum exponents, and,
+     for interchange formats, the details of the encoding.  */
+  int ieee_bits;
+
   /* Default rounding mode for operations on this format.  */
   bool round_towards_zero;
   bool has_sign_dependent_rounding;
Index: gcc/target.def
===================================================================
--- gcc/target.def	(revision 237622)
+++ gcc/target.def	(working copy)
@@ -3326,6 +3326,26 @@  hook returns true for all of @code{SFmode}, @code{
  bool, (machine_mode mode),
  default_libgcc_floating_mode_supported_p)
 
+DEFHOOK
+(floatn_mode,
+ "Define this to return the machine mode to use for the type \n\
+@code{_Float@var{n}}, if @var{extended} is false, or the type \n\
+@code{_Float@var{n}x}, if @var{extended} is true.  If such a type \n\
+is not supported, return @code{VOIDmode}.  The default version of this \n\
+hook returns @code{SFmode} for @code{_Float32}, @code{DFmode} for \n\
+@code{_Float64} and @code{_Float32x} and @code{TFmode} for \n\
+@code{_Float128}, if those modes exist and satisfy the requirements for \n\
+those types and pass @code{TARGET_SCALAR_MODE_SUPPORTED_P} and \n\
+@code{TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P}; for @code{_Float64x}, it \n\
+returns the first of @code{XFmode} and @code{TFmode} that exists and \n\
+satisfies the same requirements; for other types, it returns \n\
+@code{VOIDmode}.  The hook is only called for values of @var{n} and \n\
+@var{extended} that are valid according to ISO/IEC TS 18661-3:2015; that \n\
+is, @var{n} is one of 32, 64, 128, or, if @var{extended} is false, 16 or \n\
+greater than 128 and a multiple of 32.",
+ machine_mode, (int n, bool extended),
+ default_floatn_mode)
+
 /* Compute cost of moving data from a register of class FROM to one of
    TO, using MODE.  */
 DEFHOOK
Index: gcc/targhooks.c
===================================================================
--- gcc/targhooks.c	(revision 237622)
+++ gcc/targhooks.c	(working copy)
@@ -74,6 +74,7 @@  along with GCC; see the file COPYING3.  If not see
 #include "intl.h"
 #include "opts.h"
 #include "gimplify.h"
+#include "real.h"
 
 
 bool
@@ -459,6 +460,92 @@  default_libgcc_floating_mode_supported_p (machine_
     }
 }
 
+/* Return the machine mode to use for the type _FloatN, if EXTENDED is
+   false, or _FloatNx, if EXTENDED is true, or VOIDmode if not
+   supported.  */
+machine_mode
+default_floatn_mode (int n, bool extended)
+{
+  if (extended)
+    {
+      machine_mode cand1 = VOIDmode, cand2 = VOIDmode;
+      switch (n)
+	{
+	case 32:
+#ifdef HAVE_DFmode
+	  cand1 = DFmode;
+#endif
+	  break;
+
+	case 64:
+#ifdef HAVE_XFmode
+	  cand1 = XFmode;
+#endif
+#ifdef HAVE_TFmode
+	  cand2 = TFmode;
+#endif
+	  break;
+
+	case 128:
+	  break;
+
+	default:
+	  /* Those are the only valid _FloatNx types.  */
+	  gcc_unreachable ();
+	}
+      if (cand1 != VOIDmode
+	  && REAL_MODE_FORMAT (cand1)->ieee_bits > n
+	  && targetm.scalar_mode_supported_p (cand1)
+	  && targetm.libgcc_floating_mode_supported_p (cand1))
+	return cand1;
+      if (cand2 != VOIDmode
+	  && REAL_MODE_FORMAT (cand2)->ieee_bits > n
+	  && targetm.scalar_mode_supported_p (cand2)
+	  && targetm.libgcc_floating_mode_supported_p (cand2))
+	return cand2;
+    }
+  else
+    {
+      machine_mode cand = VOIDmode;
+      switch (n)
+	{
+	case 16:
+	  /* We do not use HFmode for _Float16 by default because the
+	     required excess precision support is not present and the
+	     interactions with promotion of the older __fp16 need to
+	     be worked out.  */
+	  break;
+
+	case 32:
+#ifdef HAVE_SFmode
+	  cand = SFmode;
+#endif
+	  break;
+
+	case 64:
+#ifdef HAVE_DFmode
+	  cand = DFmode;
+#endif
+	  break;
+
+	case 128:
+#ifdef HAVE_TFmode
+	  cand = TFmode;
+#endif
+	  break;
+
+	default:
+	  break;
+	}
+      if (cand != VOIDmode
+	  && REAL_MODE_FORMAT (cand)->ieee_bits == n
+	  && targetm.scalar_mode_supported_p (cand)
+	  && targetm.libgcc_floating_mode_supported_p (cand))
+	return cand;
+    }
+  return VOIDmode;
+}
+
 /* Make some target macros useable by target-independent code.  */
 bool
 targhook_words_big_endian (void)
Index: gcc/targhooks.h
===================================================================
--- gcc/targhooks.h	(revision 237622)
+++ gcc/targhooks.h	(working copy)
@@ -73,6 +73,7 @@  extern tree default_mangle_assembler_name (const c
 
 extern bool default_scalar_mode_supported_p (machine_mode);
 extern bool default_libgcc_floating_mode_supported_p (machine_mode);
+extern machine_mode default_floatn_mode (int, bool);
 extern bool targhook_words_big_endian (void);
 extern bool targhook_float_words_big_endian (void);
 extern bool default_float_exceptions_rounding_supported_p (void);
Index: gcc/testsuite/gcc.dg/dfp/floatn.c
===================================================================
--- gcc/testsuite/gcc.dg/dfp/floatn.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/dfp/floatn.c	(working copy)
@@ -0,0 +1,18 @@ 
+/* Tests for _FloatN / _FloatNx types: test erroneous mixing with DFP.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target float32 } */
+/* { dg-require-effective-target float32x } */
+/* { dg-options "" } */
+
+_Decimal32 d32;
+_Float32 f32;
+_Float32x f32x;
+int i;
+
+void
+f (void)
+{
+  (void) (d32 + f32); /* { dg-error "mix operands" } */
+  (void) (f32x * d32); /* { dg-error "mix operands" } */
+  (void) (i ? d32 : f32); /* { dg-error "mix operands" } */
+}
Index: gcc/testsuite/gcc.dg/floatn-arithconv.c
===================================================================
--- gcc/testsuite/gcc.dg/floatn-arithconv.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/floatn-arithconv.c	(working copy)
@@ -0,0 +1,47 @@ 
+/* Tests for _FloatN / _FloatNx types: test usual arithmetic
+   conversions.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target float32 } */
+/* { dg-require-effective-target float64 } */
+/* { dg-require-effective-target float32x } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+
+int i;
+
+#define TEST(VAR, TYPE1, TYPE2, RESTYPE)			\
+  do								\
+    {								\
+      typedef __typeof__ ((TYPE1) 0 + (TYPE2) 1) restype;	\
+      typedef __typeof__ (i ? (TYPE1) 0 : (TYPE2) 1) restype2;	\
+      typedef RESTYPE exptype;					\
+      extern restype VAR;					\
+      extern restype2 VAR;					\
+      extern exptype VAR;					\
+    }								\
+  while (0)
+
+void
+f (void)
+{
+  TEST (v1, float, double, double);
+#if DBL_MANT_DIG > FLT32_MANT_DIG
+  TEST (v2, double, _Float32, double);
+#endif
+#if DBL_MANT_DIG <= FLT64_MANT_DIG
+  TEST (v3, double, _Float64, _Float64);
+#endif
+#if DBL_MANT_DIG >= FLT32X_MANT_DIG
+  TEST (v4, double, _Float32x, double);
+#endif
+#if FLT_MANT_DIG <= FLT32_MANT_DIG
+  TEST (v5, float, _Float32, _Float32);
+#endif
+#if FLT32X_MANT_DIG <= FLT64_MANT_DIG
+  TEST (v6, _Float32x, _Float64, _Float64);
+#endif
+  TEST (v7, _Float32, _Float64, _Float64);
+  TEST (v8, _Float32, _Float32x, _Float32x);
+}
Index: gcc/testsuite/gcc.dg/floatn-errs.c
===================================================================
--- gcc/testsuite/gcc.dg/floatn-errs.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/floatn-errs.c	(working copy)
@@ -0,0 +1,41 @@ 
+/* Tests for _FloatN / _FloatNx types: test erroneous code.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target float32 } */
+/* { dg-require-effective-target float32x } */
+/* { dg-require-effective-target float64 } */
+/* { dg-options "" } */
+
+/* _FloatN, _FloatNx and standard types are incompatible even if they
+   have the same ABI.  */
+
+extern float a; /* { dg-message "previous declaration" } */
+extern _Float32 a; /* { dg-error "conflicting" } */
+
+extern double b; /* { dg-message "previous declaration" } */
+extern _Float32x b; /* { dg-error "conflicting" } */
+
+extern _Float64 c; /* { dg-message "previous declaration" } */
+extern _Float32x c; /* { dg-error "conflicting" } */
+
+/* These types are not promoted in old-style function definitions.  */
+
+void f (_Float32);
+void
+f (x)
+     _Float32 x;
+{
+}
+
+void g (double); /* { dg-error "prototype declaration" } */
+void
+g (x)
+     _Float32 x; /* { dg-error "match prototype" } */
+{
+}
+
+void h (_Float64); /* { dg-error "prototype declaration" } */
+void
+h (x)
+     _Float32 x; /* { dg-error "match prototype" } */
+{
+}
Index: gcc/testsuite/gcc.dg/torture/float128-basic.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float128-basic.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float128-basic.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float128.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128 } */
+/* { dg-options "" } */
+
+#define WIDTH 128
+#define EXT 0
+#include "floatn-basic.h"
Index: gcc/testsuite/gcc.dg/torture/float128-complex.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float128-complex.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float128-complex.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float128 complex arithmetic.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128 } */
+/* { dg-options "" } */
+
+#define WIDTH 128
+#define EXT 0
+#include "floatn-complex.h"
Index: gcc/testsuite/gcc.dg/torture/float128-floath.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float128-floath.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float128-floath.c	(working copy)
@@ -0,0 +1,60 @@ 
+/* Test _Float128 <float.h> macros.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128 } */
+/* { dg-options "" } */
+
+#define WIDTH 128
+#define EXT 0
+#include "floatn-floath.h"
+
+#ifndef FLT128_MANT_DIG
+# error "FLT128_MANT_DIG undefined"
+#endif
+
+#ifndef FLT128_DECIMAL_DIG
+# error "FLT128_DECIMAL_DIG undefined"
+#endif
+
+#ifndef FLT128_DIG
+# error "FLT128_DIG undefined"
+#endif
+
+#ifndef FLT128_MIN_EXP
+# error "FLT128_MIN_EXP undefined"
+#endif
+
+#ifndef FLT128_MIN_10_EXP
+# error "FLT128_MIN_10_EXP undefined"
+#endif
+
+#ifndef FLT128_MAX_EXP
+# error "FLT128_MAX_EXP undefined"
+#endif
+
+#ifndef FLT128_MAX_10_EXP
+# error "FLT128_MAX_10_EXP undefined"
+#endif
+
+#ifndef FLT128_MAX
+# error "FLT128_MAX undefined"
+#endif
+
+#ifndef FLT128_EPSILON
+# error "FLT128_EPSILON undefined"
+#endif
+
+#ifndef FLT128_MIN
+# error "FLT128_MIN undefined"
+#endif
+
+#ifndef FLT128_TRUE_MIN
+# error "FLT128_TRUE_MIN undefined"
+#endif
+
+#if FLT128_DECIMAL_DIG > DECIMAL_DIG
+# error "FLT128_DECIMAL_DIG > DECIMAL_DIG"
+#endif
+
+#if FLT128_MANT_DIG != 113 || FLT128_MAX_EXP != 16384 || FLT128_MIN_EXP != -16381
+# error "_Float128 bad format"
+#endif
Index: gcc/testsuite/gcc.dg/torture/float128-tg.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float128-tg.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float128-tg.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float128 type-generic built-in functions.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128 } */
+/* { dg-options "" } */
+
+#define WIDTH 128
+#define EXT 0
+#include "floatn-tg.h"
Index: gcc/testsuite/gcc.dg/torture/float128x-basic.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float128x-basic.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float128x-basic.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float128x.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128x } */
+/* { dg-options "" } */
+
+#define WIDTH 128
+#define EXT 1
+#include "floatn-basic.h"
Index: gcc/testsuite/gcc.dg/torture/float128x-complex.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float128x-complex.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float128x-complex.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float128x complex arithmetic.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128x } */
+/* { dg-options "" } */
+
+#define WIDTH 128
+#define EXT 1
+#include "floatn-complex.h"
Index: gcc/testsuite/gcc.dg/torture/float128x-floath.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float128x-floath.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float128x-floath.c	(working copy)
@@ -0,0 +1,60 @@ 
+/* Test _Float128x <float.h> macros.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128x } */
+/* { dg-options "" } */
+
+#define WIDTH 128
+#define EXT 1
+#include "floatn-floath.h"
+
+#ifndef FLT128X_MANT_DIG
+# error "FLT128X_MANT_DIG undefined"
+#endif
+
+#ifndef FLT128X_DECIMAL_DIG
+# error "FLT128X_DECIMAL_DIG undefined"
+#endif
+
+#ifndef FLT128X_DIG
+# error "FLT128X_DIG undefined"
+#endif
+
+#ifndef FLT128X_MIN_EXP
+# error "FLT128X_MIN_EXP undefined"
+#endif
+
+#ifndef FLT128X_MIN_10_EXP
+# error "FLT128X_MIN_10_EXP undefined"
+#endif
+
+#ifndef FLT128X_MAX_EXP
+# error "FLT128X_MAX_EXP undefined"
+#endif
+
+#ifndef FLT128X_MAX_10_EXP
+# error "FLT128X_MAX_10_EXP undefined"
+#endif
+
+#ifndef FLT128X_MAX
+# error "FLT128X_MAX undefined"
+#endif
+
+#ifndef FLT128X_EPSILON
+# error "FLT128X_EPSILON undefined"
+#endif
+
+#ifndef FLT128X_MIN
+# error "FLT128X_MIN undefined"
+#endif
+
+#ifndef FLT128X_TRUE_MIN
+# error "FLT128X_TRUE_MIN undefined"
+#endif
+
+#if FLT128X_DECIMAL_DIG > DECIMAL_DIG
+# error "FLT128X_DECIMAL_DIG > DECIMAL_DIG"
+#endif
+
+#if FLT128X_MANT_DIG < 128 || FLT128X_MAX_EXP < 65536 || FLT128X_MIN_EXP + FLT128X_MAX_EXP != 3
+# error "_Float128x bad format"
+#endif
Index: gcc/testsuite/gcc.dg/torture/float128x-tg.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float128x-tg.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float128x-tg.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float128x type-generic built-in functions.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128x } */
+/* { dg-options "" } */
+
+#define WIDTH 128
+#define EXT 1
+#include "floatn-tg.h"
Index: gcc/testsuite/gcc.dg/torture/float16-basic.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float16-basic.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float16-basic.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float16.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float16 } */
+/* { dg-options "" } */
+
+#define WIDTH 16
+#define EXT 0
+#include "floatn-basic.h"
Index: gcc/testsuite/gcc.dg/torture/float16-complex.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float16-complex.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float16-complex.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float16 complex arithmetic.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float16 } */
+/* { dg-options "" } */
+
+#define WIDTH 16
+#define EXT 0
+#include "floatn-complex.h"
Index: gcc/testsuite/gcc.dg/torture/float16-floath.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float16-floath.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float16-floath.c	(working copy)
@@ -0,0 +1,60 @@ 
+/* Test _Float16 <float.h> macros.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float16 } */
+/* { dg-options "" } */
+
+#define WIDTH 16
+#define EXT 0
+#include "floatn-floath.h"
+
+#ifndef FLT16_MANT_DIG
+# error "FLT16_MANT_DIG undefined"
+#endif
+
+#ifndef FLT16_DECIMAL_DIG
+# error "FLT16_DECIMAL_DIG undefined"
+#endif
+
+#ifndef FLT16_DIG
+# error "FLT16_DIG undefined"
+#endif
+
+#ifndef FLT16_MIN_EXP
+# error "FLT16_MIN_EXP undefined"
+#endif
+
+#ifndef FLT16_MIN_10_EXP
+# error "FLT16_MIN_10_EXP undefined"
+#endif
+
+#ifndef FLT16_MAX_EXP
+# error "FLT16_MAX_EXP undefined"
+#endif
+
+#ifndef FLT16_MAX_10_EXP
+# error "FLT16_MAX_10_EXP undefined"
+#endif
+
+#ifndef FLT16_MAX
+# error "FLT16_MAX undefined"
+#endif
+
+#ifndef FLT16_EPSILON
+# error "FLT16_EPSILON undefined"
+#endif
+
+#ifndef FLT16_MIN
+# error "FLT16_MIN undefined"
+#endif
+
+#ifndef FLT16_TRUE_MIN
+# error "FLT16_TRUE_MIN undefined"
+#endif
+
+#if FLT16_DECIMAL_DIG > DECIMAL_DIG
+# error "FLT16_DECIMAL_DIG > DECIMAL_DIG"
+#endif
+
+#if FLT16_MANT_DIG != 11 || FLT16_MAX_EXP != 16 || FLT16_MIN_EXP != -13
+# error "_Float16 bad format"
+#endif
Index: gcc/testsuite/gcc.dg/torture/float16-tg.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float16-tg.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float16-tg.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float16 type-generic built-in functions.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float16 } */
+/* { dg-options "" } */
+
+#define WIDTH 16
+#define EXT 0
+#include "floatn-tg.h"
Index: gcc/testsuite/gcc.dg/torture/float32-basic.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float32-basic.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float32-basic.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float32.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32 } */
+/* { dg-options "" } */
+
+#define WIDTH 32
+#define EXT 0
+#include "floatn-basic.h"
Index: gcc/testsuite/gcc.dg/torture/float32-complex.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float32-complex.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float32-complex.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float32 complex arithmetic.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32 } */
+/* { dg-options "" } */
+
+#define WIDTH 32
+#define EXT 0
+#include "floatn-complex.h"
Index: gcc/testsuite/gcc.dg/torture/float32-floath.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float32-floath.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float32-floath.c	(working copy)
@@ -0,0 +1,60 @@ 
+/* Test _Float32 <float.h> macros.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32 } */
+/* { dg-options "" } */
+
+#define WIDTH 32
+#define EXT 0
+#include "floatn-floath.h"
+
+#ifndef FLT32_MANT_DIG
+# error "FLT32_MANT_DIG undefined"
+#endif
+
+#ifndef FLT32_DECIMAL_DIG
+# error "FLT32_DECIMAL_DIG undefined"
+#endif
+
+#ifndef FLT32_DIG
+# error "FLT32_DIG undefined"
+#endif
+
+#ifndef FLT32_MIN_EXP
+# error "FLT32_MIN_EXP undefined"
+#endif
+
+#ifndef FLT32_MIN_10_EXP
+# error "FLT32_MIN_10_EXP undefined"
+#endif
+
+#ifndef FLT32_MAX_EXP
+# error "FLT32_MAX_EXP undefined"
+#endif
+
+#ifndef FLT32_MAX_10_EXP
+# error "FLT32_MAX_10_EXP undefined"
+#endif
+
+#ifndef FLT32_MAX
+# error "FLT32_MAX undefined"
+#endif
+
+#ifndef FLT32_EPSILON
+# error "FLT32_EPSILON undefined"
+#endif
+
+#ifndef FLT32_MIN
+# error "FLT32_MIN undefined"
+#endif
+
+#ifndef FLT32_TRUE_MIN
+# error "FLT32_TRUE_MIN undefined"
+#endif
+
+#if FLT32_DECIMAL_DIG > DECIMAL_DIG
+# error "FLT32_DECIMAL_DIG > DECIMAL_DIG"
+#endif
+
+#if FLT32_MANT_DIG != 24 || FLT32_MAX_EXP != 128 || FLT32_MIN_EXP != -125
+# error "_Float32 bad format"
+#endif
Index: gcc/testsuite/gcc.dg/torture/float32-tg.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float32-tg.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float32-tg.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float32 type-generic built-in functions.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32 } */
+/* { dg-options "" } */
+
+#define WIDTH 32
+#define EXT 0
+#include "floatn-tg.h"
Index: gcc/testsuite/gcc.dg/torture/float32x-basic.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float32x-basic.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float32x-basic.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float32x.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32x } */
+/* { dg-options "" } */
+
+#define WIDTH 32
+#define EXT 1
+#include "floatn-basic.h"
Index: gcc/testsuite/gcc.dg/torture/float32x-complex.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float32x-complex.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float32x-complex.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float32x complex arithmetic.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32x } */
+/* { dg-options "" } */
+
+#define WIDTH 32
+#define EXT 1
+#include "floatn-complex.h"
Index: gcc/testsuite/gcc.dg/torture/float32x-floath.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float32x-floath.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float32x-floath.c	(working copy)
@@ -0,0 +1,60 @@ 
+/* Test _Float32x <float.h> macros.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32x } */
+/* { dg-options "" } */
+
+#define WIDTH 32
+#define EXT 1
+#include "floatn-floath.h"
+
+#ifndef FLT32X_MANT_DIG
+# error "FLT32X_MANT_DIG undefined"
+#endif
+
+#ifndef FLT32X_DECIMAL_DIG
+# error "FLT32X_DECIMAL_DIG undefined"
+#endif
+
+#ifndef FLT32X_DIG
+# error "FLT32X_DIG undefined"
+#endif
+
+#ifndef FLT32X_MIN_EXP
+# error "FLT32X_MIN_EXP undefined"
+#endif
+
+#ifndef FLT32X_MIN_10_EXP
+# error "FLT32X_MIN_10_EXP undefined"
+#endif
+
+#ifndef FLT32X_MAX_EXP
+# error "FLT32X_MAX_EXP undefined"
+#endif
+
+#ifndef FLT32X_MAX_10_EXP
+# error "FLT32X_MAX_10_EXP undefined"
+#endif
+
+#ifndef FLT32X_MAX
+# error "FLT32X_MAX undefined"
+#endif
+
+#ifndef FLT32X_EPSILON
+# error "FLT32X_EPSILON undefined"
+#endif
+
+#ifndef FLT32X_MIN
+# error "FLT32X_MIN undefined"
+#endif
+
+#ifndef FLT32X_TRUE_MIN
+# error "FLT32X_TRUE_MIN undefined"
+#endif
+
+#if FLT32X_DECIMAL_DIG > DECIMAL_DIG
+# error "FLT32X_DECIMAL_DIG > DECIMAL_DIG"
+#endif
+
+#if FLT32X_MANT_DIG < 32 || FLT32X_MAX_EXP < 1024 || FLT32X_MIN_EXP + FLT32X_MAX_EXP != 3
+# error "_Float32x bad format"
+#endif
Index: gcc/testsuite/gcc.dg/torture/float32x-tg.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float32x-tg.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float32x-tg.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float32x type-generic built-in functions.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32x } */
+/* { dg-options "" } */
+
+#define WIDTH 32
+#define EXT 1
+#include "floatn-tg.h"
Index: gcc/testsuite/gcc.dg/torture/float64-basic.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float64-basic.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float64-basic.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float64.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64 } */
+/* { dg-options "" } */
+
+#define WIDTH 64
+#define EXT 0
+#include "floatn-basic.h"
Index: gcc/testsuite/gcc.dg/torture/float64-complex.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float64-complex.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float64-complex.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float64 complex arithmetic.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64 } */
+/* { dg-options "" } */
+
+#define WIDTH 64
+#define EXT 0
+#include "floatn-complex.h"
Index: gcc/testsuite/gcc.dg/torture/float64-floath.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float64-floath.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float64-floath.c	(working copy)
@@ -0,0 +1,60 @@ 
+/* Test _Float64 <float.h> macros.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64 } */
+/* { dg-options "" } */
+
+#define WIDTH 64
+#define EXT 0
+#include "floatn-floath.h"
+
+#ifndef FLT64_MANT_DIG
+# error "FLT64_MANT_DIG undefined"
+#endif
+
+#ifndef FLT64_DECIMAL_DIG
+# error "FLT64_DECIMAL_DIG undefined"
+#endif
+
+#ifndef FLT64_DIG
+# error "FLT64_DIG undefined"
+#endif
+
+#ifndef FLT64_MIN_EXP
+# error "FLT64_MIN_EXP undefined"
+#endif
+
+#ifndef FLT64_MIN_10_EXP
+# error "FLT64_MIN_10_EXP undefined"
+#endif
+
+#ifndef FLT64_MAX_EXP
+# error "FLT64_MAX_EXP undefined"
+#endif
+
+#ifndef FLT64_MAX_10_EXP
+# error "FLT64_MAX_10_EXP undefined"
+#endif
+
+#ifndef FLT64_MAX
+# error "FLT64_MAX undefined"
+#endif
+
+#ifndef FLT64_EPSILON
+# error "FLT64_EPSILON undefined"
+#endif
+
+#ifndef FLT64_MIN
+# error "FLT64_MIN undefined"
+#endif
+
+#ifndef FLT64_TRUE_MIN
+# error "FLT64_TRUE_MIN undefined"
+#endif
+
+#if FLT64_DECIMAL_DIG > DECIMAL_DIG
+# error "FLT64_DECIMAL_DIG > DECIMAL_DIG"
+#endif
+
+#if FLT64_MANT_DIG != 53 || FLT64_MAX_EXP != 1024 || FLT64_MIN_EXP != -1021
+# error "_Float64 bad format"
+#endif
Index: gcc/testsuite/gcc.dg/torture/float64-tg.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float64-tg.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float64-tg.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float64 type-generic built-in functions.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64 } */
+/* { dg-options "" } */
+
+#define WIDTH 64
+#define EXT 0
+#include "floatn-tg.h"
Index: gcc/testsuite/gcc.dg/torture/float64x-basic.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float64x-basic.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float64x-basic.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float64x.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64x } */
+/* { dg-options "" } */
+
+#define WIDTH 64
+#define EXT 1
+#include "floatn-basic.h"
Index: gcc/testsuite/gcc.dg/torture/float64x-complex.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float64x-complex.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float64x-complex.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float64x complex arithmetic.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64x } */
+/* { dg-options "" } */
+
+#define WIDTH 64
+#define EXT 1
+#include "floatn-complex.h"
Index: gcc/testsuite/gcc.dg/torture/float64x-floath.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float64x-floath.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float64x-floath.c	(working copy)
@@ -0,0 +1,60 @@ 
+/* Test _Float64x <float.h> macros.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64x } */
+/* { dg-options "" } */
+
+#define WIDTH 64
+#define EXT 1
+#include "floatn-floath.h"
+
+#ifndef FLT64X_MANT_DIG
+# error "FLT64X_MANT_DIG undefined"
+#endif
+
+#ifndef FLT64X_DECIMAL_DIG
+# error "FLT64X_DECIMAL_DIG undefined"
+#endif
+
+#ifndef FLT64X_DIG
+# error "FLT64X_DIG undefined"
+#endif
+
+#ifndef FLT64X_MIN_EXP
+# error "FLT64X_MIN_EXP undefined"
+#endif
+
+#ifndef FLT64X_MIN_10_EXP
+# error "FLT64X_MIN_10_EXP undefined"
+#endif
+
+#ifndef FLT64X_MAX_EXP
+# error "FLT64X_MAX_EXP undefined"
+#endif
+
+#ifndef FLT64X_MAX_10_EXP
+# error "FLT64X_MAX_10_EXP undefined"
+#endif
+
+#ifndef FLT64X_MAX
+# error "FLT64X_MAX undefined"
+#endif
+
+#ifndef FLT64X_EPSILON
+# error "FLT64X_EPSILON undefined"
+#endif
+
+#ifndef FLT64X_MIN
+# error "FLT64X_MIN undefined"
+#endif
+
+#ifndef FLT64X_TRUE_MIN
+# error "FLT64X_TRUE_MIN undefined"
+#endif
+
+#if FLT64X_DECIMAL_DIG > DECIMAL_DIG
+# error "FLT64X_DECIMAL_DIG > DECIMAL_DIG"
+#endif
+
+#if FLT64X_MANT_DIG < 64 || FLT64X_MAX_EXP < 16384 || FLT64X_MIN_EXP + FLT64X_MAX_EXP != 3
+# error "_Float64x bad format"
+#endif
Index: gcc/testsuite/gcc.dg/torture/float64x-tg.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/float64x-tg.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/float64x-tg.c	(working copy)
@@ -0,0 +1,8 @@ 
+/* Test _Float64x type-generic built-in functions.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64x } */
+/* { dg-options "" } */
+
+#define WIDTH 64
+#define EXT 1
+#include "floatn-tg.h"
Index: gcc/testsuite/gcc.dg/torture/floatn-basic.h
===================================================================
--- gcc/testsuite/gcc.dg/torture/floatn-basic.h	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/floatn-basic.h	(working copy)
@@ -0,0 +1,102 @@ 
+/* Basic tests for _FloatN / _FloatNx types: compile and execution
+   tests for valid code.  Before including this file, define WIDTH as
+   the value N; define EXT to 1 for _FloatNx and 0 for _FloatN.  */
+
+#include <stdarg.h>
+
+#define CONCATX(X, Y) X ## Y
+#define CONCAT(X, Y) CONCATX (X, Y)
+#define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z)
+#define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z)
+
+#if EXT
+# define TYPE CONCAT3 (_Float, WIDTH, x)
+# define CST(C) CONCAT4 (C, f, WIDTH, x)
+# define CSTU(C) CONCAT4 (C, F, WIDTH, x)
+#else
+# define TYPE CONCAT (_Float, WIDTH)
+# define CST(C) CONCAT3 (C, f, WIDTH)
+# define CSTU(C) CONCAT3 (C, F, WIDTH)
+#endif
+
+extern void exit (int);
+extern void abort (void);
+
+volatile TYPE a = CST (1.0), b = CSTU (2.5), c = -CST (2.5);
+
+/* These types are not subject to default argument promotions.  */
+
+TYPE
+vafn (TYPE arg1, ...)
+{
+  va_list ap;
+  TYPE ret;
+  va_start (ap, arg1);
+  ret = arg1 + va_arg (ap, TYPE);
+  va_end (ap);
+  return ret;
+}
+
+TYPE
+krfn (arg)
+     TYPE arg;
+{
+  return arg + 1;
+}
+
+TYPE krprofn (TYPE);
+TYPE
+krprofn (arg)
+     TYPE arg;
+{
+  return arg * 3;
+}
+
+TYPE
+profn (TYPE arg)
+{
+  return arg / 4;
+}
+
+int
+main (void)
+{
+  volatile TYPE r;
+  r = -b;
+  if (r != c)
+    abort ();
+  r = a + b;
+  if (r != CST (3.5))
+    abort ();
+  r = a - b;
+  if (r != -CST (1.5))
+    abort ();
+  r = 2 * c;
+  if (r != -5)
+    abort ();
+  r = b * c;
+  if (r != -CST (6.25))
+    abort ();
+  r = b / (a + a);
+  if (r != CST (1.25))
+    abort ();
+  r = c * 3;
+  if (r != -CST (7.5))
+    abort ();
+  volatile int i = r;
+  if (i != -7)
+    abort ();
+  r = vafn (a, c);
+  if (r != -CST (1.5))
+    abort ();
+  r = krfn (b);
+  if (r != CST (3.5))
+    abort ();
+  r = krprofn (a);
+  if (r != CST (3.0))
+    abort ();
+  r = profn (a);
+  if (r != CST (0.25))
+    abort ();
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/floatn-complex.h
===================================================================
--- gcc/testsuite/gcc.dg/torture/floatn-complex.h	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/floatn-complex.h	(working copy)
@@ -0,0 +1,76 @@ 
+/* Tests for _FloatN / _FloatNx types: compile and execution tests for
+   valid code with complex arithmetic.  Before including this file,
+   define WIDTH as the value N; define EXT to 1 for _FloatNx and 0 for
+   _FloatN.  */
+
+#define CONCATX(X, Y) X ## Y
+#define CONCAT(X, Y) CONCATX (X, Y)
+#define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z)
+#define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z)
+
+#if EXT
+# define TYPE CONCAT3 (_Float, WIDTH, x)
+# define CST(C) CONCAT4 (C, f, WIDTH, x)
+# define CSTI(C) CONCAT4 (C, if, WIDTH, x)
+# define CSTI2(C) CONCAT4 (C, F, WIDTH, xi)
+#else
+# define TYPE CONCAT (_Float, WIDTH)
+# define CST(C) CONCAT3 (C, f, WIDTH)
+# define CSTI(C) CONCAT3 (C, if, WIDTH)
+# define CSTI2(C) CONCAT4 (C, F, WIDTH, i)
+#endif
+
+extern void exit (int);
+extern void abort (void);
+
+volatile TYPE a = CST (1.0);
+volatile _Complex TYPE b = CST (2.0) + CSTI (3.0);
+volatile _Complex TYPE c = CST (2.0) + CSTI2 (3.0);
+volatile _Complex TYPE d = __builtin_complex (CST (2.0), CST (3.0));
+
+_Complex TYPE
+fn (_Complex TYPE arg)
+{
+  return arg / 4;
+}
+
+int
+main (void)
+{
+  volatile _Complex TYPE r;
+  if (b != c)
+    abort ();
+  if (b != d)
+    abort ();
+  r = a + b;
+  if (__real__ r != CST (3.0) || __imag__ r != CST (3.0))
+    abort ();
+  r += d;
+  if (__real__ r != CST (5.0) || __imag__ r != CST (6.0))
+    abort ();
+  r -= a;
+  if (__real__ r != CST (4.0) || __imag__ r != CST (6.0))
+    abort ();
+  r /= (a + a);
+  if (__real__ r != CST (2.0) || __imag__ r != CST (3.0))
+    abort ();
+  r *= (a + a);
+  if (__real__ r != CST (4.0) || __imag__ r != CST (6.0))
+    abort ();
+  r -= b;
+  if (__real__ r != CST (2.0) || __imag__ r != CST (3.0))
+    abort ();
+  r *= r;
+  if (__real__ r != -CST (5.0) || __imag__ r != CST (12.0))
+    abort ();
+  /* Division may not be exact, so round result before comparing.  */
+  r /= b;
+  r += __builtin_complex (CST (100.0), CST (100.0));
+  r -= __builtin_complex (CST (100.0), CST (100.0));
+  if (r != b)
+    abort ();
+  r = fn (r);
+  if (__real__ r != CST (0.5) || __imag__ r != CST (0.75))
+    abort ();
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/floatn-convert.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/floatn-convert.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/floatn-convert.c	(working copy)
@@ -0,0 +1,96 @@ 
+/* Tests for _FloatN / _FloatNx types: test conversions.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32 } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+
+#ifndef FLT16_MAX
+# define _Float16 _Float32
+# define FLT16_MAX FLT32_MAX
+# define FLT16_MANT_DIG FLT32_MANT_DIG
+# define FLT16_EPSILON FLT32_EPSILON
+#endif
+
+#ifndef FLT64_MAX
+# define _Float64 _Float32
+# define FLT64_MAX FLT32_MAX
+# define FLT64_MANT_DIG FLT32_MANT_DIG
+# define FLT64_EPSILON FLT32_EPSILON
+#endif
+
+#ifndef FLT128_MAX
+# define _Float128 _Float32
+# define FLT128_MAX FLT32_MAX
+# define FLT128_MANT_DIG FLT32_MANT_DIG
+# define FLT128_EPSILON FLT32_EPSILON
+#endif
+
+#ifndef FLT32X_MAX
+# define _Float32x _Float32
+# define FLT32X_MAX FLT32_MAX
+# define FLT32X_MANT_DIG FLT32_MANT_DIG
+# define FLT32X_EPSILON FLT32_EPSILON
+#endif
+
+#ifndef FLT64X_MAX
+# define _Float64x _Float32
+# define FLT64X_MAX FLT32_MAX
+# define FLT64X_MANT_DIG FLT32_MANT_DIG
+# define FLT64X_EPSILON FLT32_EPSILON
+#endif
+
+#ifndef FLT128X_MAX
+# define _Float128x _Float32
+# define FLT128X_MAX FLT32_MAX
+# define FLT128X_MANT_DIG FLT32_MANT_DIG
+# define FLT128X_EPSILON FLT32_EPSILON
+#endif
+
+#define CONCATX(X, Y) X ## Y
+#define CONCAT(X, Y) CONCATX (X, Y)
+
+extern void exit (int);
+extern void abort (void);
+
+#define DO_TEST(TYPE1, PFX1, TYPE2, PFX2)			\
+  do								\
+    {								\
+      volatile TYPE1 a = (TYPE1) 1 + CONCAT (PFX1, _EPSILON);	\
+      volatile TYPE2 b = (TYPE2) a;				\
+      volatile TYPE2 expected;					\
+      if (CONCAT (PFX2, _MANT_DIG) < CONCAT (PFX1, _MANT_DIG))	\
+	expected = (TYPE2) 1;					\
+      else							\
+	expected = (TYPE2) 1 + (TYPE2) CONCAT (PFX1, _EPSILON); \
+      if (b != expected)					\
+	abort ();						\
+    }								\
+  while (0)
+
+#define DO_TEST1(TYPE1, PFX1)				\
+  do							\
+    {							\
+      DO_TEST (TYPE1, PFX1, _Float16, FLT16);		\
+      DO_TEST (TYPE1, PFX1, _Float32, FLT32);		\
+      DO_TEST (TYPE1, PFX1, _Float64, FLT64);		\
+      DO_TEST (TYPE1, PFX1, _Float128, FLT128);		\
+      DO_TEST (TYPE1, PFX1, _Float32x, FLT32X);		\
+      DO_TEST (TYPE1, PFX1, _Float64x, FLT64X);		\
+      DO_TEST (TYPE1, PFX1, _Float128x, FLT128X);	\
+    }							\
+  while (0)
+
+int
+main (void)
+{
+  DO_TEST1 (_Float16, FLT16);
+  DO_TEST1 (_Float32, FLT32);
+  DO_TEST1 (_Float64, FLT64);
+  DO_TEST1 (_Float128, FLT128);
+  DO_TEST1 (_Float32x, FLT32X);
+  DO_TEST1 (_Float64x, FLT64X);
+  DO_TEST1 (_Float128x, FLT128X);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/floatn-floath.h
===================================================================
--- gcc/testsuite/gcc.dg/torture/floatn-floath.h	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/floatn-floath.h	(working copy)
@@ -0,0 +1,52 @@ 
+/* Tests for _FloatN / _FloatNx types: compile and execution tests for
+   <float.h>.  Before including this file, define WIDTH as the value
+   N; define EXT to 1 for _FloatNx and 0 for _FloatN.  */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+
+#define CONCATX(X, Y) X ## Y
+#define CONCAT(X, Y) CONCATX (X, Y)
+#define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z)
+#define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z)
+
+#if EXT
+# define TYPE CONCAT3 (_Float, WIDTH, x)
+# define CST(C) CONCAT4 (C, f, WIDTH, x)
+# define FMAC(M) CONCAT4 (FLT, WIDTH, X_, M)
+#else
+# define TYPE CONCAT (_Float, WIDTH)
+# define CST(C) CONCAT3 (C, f, WIDTH)
+# define FMAC(M) CONCAT4 (FLT, WIDTH, _, M)
+#endif
+
+extern void exit (int);
+extern void abort (void);
+
+int
+main (void)
+{
+  volatile TYPE a = CST (1.0);
+  for (int i = 0; i >= FMAC (MIN_EXP); i--)
+    a *= CST (0.5);
+  if (a != FMAC (MIN))
+    abort ();
+  for (int i = 0; i < FMAC (MANT_DIG) - 1; i++)
+    a *= CST (0.5);
+  if (a != FMAC (TRUE_MIN))
+    abort ();
+  a *= CST (0.5);
+  if (a != CST (0.0))
+    abort ();
+  a = FMAC (EPSILON);
+  for (int i = 0; i < FMAC (MANT_DIG) - 1; i++)
+    a *= CST (2.0);
+  if (a != CST (1.0))
+    abort ();
+  a = FMAC (MAX);
+  for (int i = 0; i < FMAC (MAX_EXP); i++)
+    a *= CST (0.5);
+  if (a != CST (1.0) - FMAC (EPSILON) * CST (0.5))
+    abort ();
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/floatn-tg.h
===================================================================
--- gcc/testsuite/gcc.dg/torture/floatn-tg.h	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/floatn-tg.h	(working copy)
@@ -0,0 +1,71 @@ 
+/* Tests for _FloatN / _FloatNx types: compile and execution tests for
+   type-generic built-in functions.  Before including this file,
+   define WIDTH as the value N; define EXT to 1 for _FloatNx and 0 for
+   _FloatN.  */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+
+#define CONCATX(X, Y) X ## Y
+#define CONCAT(X, Y) CONCATX (X, Y)
+#define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z)
+#define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z)
+
+#if EXT
+# define TYPE CONCAT3 (_Float, WIDTH, x)
+# define CST(C) CONCAT4 (C, f, WIDTH, x)
+# define TRUE_MIN CONCAT3 (FLT, WIDTH, X_TRUE_MIN)
+#else
+# define TYPE CONCAT (_Float, WIDTH)
+# define CST(C) CONCAT3 (C, f, WIDTH)
+# define TRUE_MIN CONCAT3 (FLT, WIDTH, _TRUE_MIN)
+#endif
+
+extern void exit (int);
+extern void abort (void);
+
+volatile TYPE inf = __builtin_inf (), nanval = __builtin_nan ("");
+volatile TYPE zero = CST (0.0), negzero = -CST (0.0), one = CST (1.0);
+volatile TYPE true_min = TRUE_MIN;
+
+int
+main (void)
+{
+  if (__builtin_signbit (inf) != 0)
+    abort ();
+  if (__builtin_signbit (zero) != 0)
+    abort ();
+  if (__builtin_signbit (negzero) == 0)
+    abort ();
+  if (__builtin_isfinite (nanval) != 0)
+    abort ();
+  if (__builtin_isfinite (inf) != 0)
+    abort ();
+  if (__builtin_isfinite (one) == 0)
+    abort ();
+  if (__builtin_isinf (nanval) != 0)
+    abort ();
+  if (__builtin_isinf (inf) == 0)
+    abort ();
+  if (__builtin_isnan (nanval) == 0)
+    abort ();
+  if (__builtin_isnan (inf) != 0)
+    abort ();
+  if (__builtin_isnormal (inf) != 0)
+    abort ();
+  if (__builtin_isnormal (one) == 0)
+    abort ();
+  if (__builtin_isnormal (nanval) != 0)
+    abort ();
+  if (__builtin_isnormal (zero) != 0)
+    abort ();
+  if (__builtin_isnormal (true_min) != 0)
+    abort ();
+  if (__builtin_islessequal (zero, one) != 1)
+    abort ();
+  if (__builtin_islessequal (zero, negzero) != 1)
+    abort ();
+  if (__builtin_islessequal (zero, nanval) != 0)
+    abort ();
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee-timode.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee-timode.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee-timode.c	(working copy)
@@ -0,0 +1,15 @@ 
+/* Test floating-point conversions.  _Float128 type with TImode.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128 } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(TItype, UTItype, _Float128, FLT128_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float128-ieee.c	(working copy)
@@ -0,0 +1,19 @@ 
+/* Test floating-point conversions.  Standard types and _Float128.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128 } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, _Float128, FLT128_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, _Float128, FLT128_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, _Float128, FLT128_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, _Float128, FLT128_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, _Float128, FLT128_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x-timode.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x-timode.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x-timode.c	(working copy)
@@ -0,0 +1,15 @@ 
+/* Test floating-point conversions.  _Float128x type with TImode.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128x } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(TItype, UTItype, _Float128, FLT128X_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float128x.c	(working copy)
@@ -0,0 +1,19 @@ 
+/* Test floating-point conversions.  Standard types and _Float128x.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float128x } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, _Float128x, FLT128X_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, _Float128x, FLT128X_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, _Float128x, FLT128X_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, _Float128x, FLT128X_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, _Float128x, FLT128X_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float16-timode.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float16-timode.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float16-timode.c	(working copy)
@@ -0,0 +1,15 @@ 
+/* Test floating-point conversions.  _Float16 type with TImode.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float16 } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(TItype, UTItype, _Float16, FLT16_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float16.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float16.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float16.c	(working copy)
@@ -0,0 +1,19 @@ 
+/* Test floating-point conversions.  Standard types and _Float16.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float16 } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, _Float16, FLT16_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, _Float16, FLT16_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, _Float16, FLT16_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, _Float16, FLT16_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, _Float16, FLT16_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float32-timode.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float32-timode.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float32-timode.c	(working copy)
@@ -0,0 +1,15 @@ 
+/* Test floating-point conversions.  _Float32 type with TImode.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32 } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(TItype, UTItype, _Float32, FLT32_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float32.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float32.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float32.c	(working copy)
@@ -0,0 +1,19 @@ 
+/* Test floating-point conversions.  Standard types and _Float32.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32 } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, _Float32, FLT32_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, _Float32, FLT32_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, _Float32, FLT32_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, _Float32, FLT32_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, _Float32, FLT32_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x-timode.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x-timode.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x-timode.c	(working copy)
@@ -0,0 +1,15 @@ 
+/* Test floating-point conversions.  _Float32x type with TImode.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32x } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(TItype, UTItype, _Float32, FLT32X_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float32x.c	(working copy)
@@ -0,0 +1,19 @@ 
+/* Test floating-point conversions.  Standard types and _Float32x.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float32x } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, _Float32x, FLT32X_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, _Float32x, FLT32X_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, _Float32x, FLT32X_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, _Float32x, FLT32X_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, _Float32x, FLT32X_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float64-timode.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float64-timode.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float64-timode.c	(working copy)
@@ -0,0 +1,15 @@ 
+/* Test floating-point conversions.  _Float64 type with TImode.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64 } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(TItype, UTItype, _Float64, FLT64_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float64.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float64.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float64.c	(working copy)
@@ -0,0 +1,19 @@ 
+/* Test floating-point conversions.  Standard types and _Float64.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64 } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, _Float64, FLT64_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, _Float64, FLT64_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, _Float64, FLT64_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, _Float64, FLT64_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, _Float64, FLT64_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x-timode.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x-timode.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x-timode.c	(working copy)
@@ -0,0 +1,15 @@ 
+/* Test floating-point conversions.  _Float64x type with TImode.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64x } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(TItype, UTItype, _Float64, FLT64X_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x.c
===================================================================
--- gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x.c	(nonexistent)
+++ gcc/testsuite/gcc.dg/torture/fp-int-convert-float64x.c	(working copy)
@@ -0,0 +1,19 @@ 
+/* Test floating-point conversions.  Standard types and _Float64x.  */
+/* { dg-do run } */
+/* { dg-require-effective-target float64x } */
+/* { dg-options "" } */
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+#include <float.h>
+#include "fp-int-convert.h"
+
+int
+main (void)
+{
+  TEST_I_F(signed char, unsigned char, _Float64x, FLT64X_MANT_DIG);
+  TEST_I_F(signed short, unsigned short, _Float64x, FLT64X_MANT_DIG);
+  TEST_I_F(signed int, unsigned int, _Float64x, FLT64X_MANT_DIG);
+  TEST_I_F(signed long, unsigned long, _Float64x, FLT64X_MANT_DIG);
+  TEST_I_F(signed long long, unsigned long long, _Float64x, FLT64X_MANT_DIG);
+  exit (0);
+}
Index: gcc/testsuite/lib/target-supports.exp
===================================================================
--- gcc/testsuite/lib/target-supports.exp	(revision 237622)
+++ gcc/testsuite/lib/target-supports.exp	(working copy)
@@ -2300,6 +2300,52 @@  proc check_effective_target_has_q_floating_suffix
 	float dummy = 1.0q;
     } "$opts"]
 }
+
+# Return 1 if the target supports the _FloatN / _FloatNx type
+# indicated in the function name, 0 otherwise.
+
+proc check_effective_target_float16 {} {
+    return [check_no_compiler_messages float16 object {
+        _Float16 x;
+    }]
+}
+
+proc check_effective_target_float32 {} {
+    return [check_no_compiler_messages float32 object {
+        _Float32 x;
+    }]
+}
+
+proc check_effective_target_float64 {} {
+    return [check_no_compiler_messages float64 object {
+        _Float64 x;
+    }]
+}
+
+proc check_effective_target_float128 {} {
+    return [check_no_compiler_messages float128 object {
+        _Float128 x;
+    }]
+}
+
+proc check_effective_target_float32x {} {
+    return [check_no_compiler_messages float32x object {
+        _Float32x x;
+    }]
+}
+
+proc check_effective_target_float64x {} {
+    return [check_no_compiler_messages float64x object {
+        _Float64x x;
+    }]
+}
+
+proc check_effective_target_float128x {} {
+    return [check_no_compiler_messages float128x object {
+        _Float128x x;
+    }]
+}
+
 # Return 1 if the target supports compiling fixed-point,
 # 0 otherwise.
 
Index: gcc/tree-core.h
===================================================================
--- gcc/tree-core.h	(revision 237622)
+++ gcc/tree-core.h	(working copy)
@@ -558,10 +558,44 @@  enum tree_index {
   TI_COMPLEX_DOUBLE_TYPE,
   TI_COMPLEX_LONG_DOUBLE_TYPE,
 
+  TI_COMPLEX_FLOAT16_TYPE,
+  TI_COMPLEX_FLOATN_NX_TYPE_FIRST = TI_COMPLEX_FLOAT16_TYPE,
+  TI_COMPLEX_FLOAT32_TYPE,
+  TI_COMPLEX_FLOAT64_TYPE,
+  TI_COMPLEX_FLOAT128_TYPE,
+  TI_COMPLEX_FLOAT32X_TYPE,
+  TI_COMPLEX_FLOAT64X_TYPE,
+  TI_COMPLEX_FLOAT128X_TYPE,
+
   TI_FLOAT_TYPE,
   TI_DOUBLE_TYPE,
   TI_LONG_DOUBLE_TYPE,
 
+  /* The _FloatN and _FloatNx types must be consecutive, and in the
+     same sequence as the corresponding complex types, which must also
+     be consecutive; _FloatN must come before _FloatNx; the order must
+     also be the same as in the floatn_nx_types array and the RID_*
+     values in c-common.h.  This is so that iterations over these
+     types work as intended.  */
+  TI_FLOAT16_TYPE,
+  TI_FLOATN_TYPE_FIRST = TI_FLOAT16_TYPE,
+  TI_FLOATN_NX_TYPE_FIRST = TI_FLOAT16_TYPE,
+  TI_FLOAT32_TYPE,
+  TI_FLOAT64_TYPE,
+  TI_FLOAT128_TYPE,
+  TI_FLOATN_TYPE_LAST = TI_FLOAT128_TYPE,
+#define NUM_FLOATN_TYPES (TI_FLOATN_TYPE_LAST - TI_FLOATN_TYPE_FIRST + 1)
+  TI_FLOAT32X_TYPE,
+  TI_FLOATNX_TYPE_FIRST = TI_FLOAT32X_TYPE,
+  TI_FLOAT64X_TYPE,
+  TI_FLOAT128X_TYPE,
+  TI_FLOATNX_TYPE_LAST = TI_FLOAT128X_TYPE,
+  TI_FLOATN_NX_TYPE_LAST = TI_FLOAT128X_TYPE,
+#define NUM_FLOATNX_TYPES (TI_FLOATNX_TYPE_LAST - TI_FLOATNX_TYPE_FIRST + 1)
+#define NUM_FLOATN_NX_TYPES (TI_FLOATN_NX_TYPE_LAST		\
+			     - TI_FLOATN_NX_TYPE_FIRST		\
+			     + 1)
+
   TI_FLOAT_PTR_TYPE,
   TI_DOUBLE_PTR_TYPE,
   TI_LONG_DOUBLE_PTR_TYPE,
@@ -1961,7 +1995,17 @@  struct GTY(()) builtin_info_type {
   unsigned declared_p : 1;
 };
 
+/* Information about a _FloatN or _FloatNx type that may be
+   supported.  */
+struct floatn_type_info {
+  /* The number N in the type name.  */
+  int n;
+  /* Whether it is an extended type _FloatNx (true) or an interchange
+     type (false).  */
+  bool extended;
+};
 
+
 /*---------------------------------------------------------------------------
                                 Global variables
 ---------------------------------------------------------------------------*/
@@ -2025,4 +2069,7 @@  extern GTY(()) tree current_function_decl;
 /* Nonzero means a FUNC_BEGIN label was emitted.  */
 extern GTY(()) const char * current_function_func_begin_label;
 
+/* Information about the _FloatN and _FloatNx types.  */
+extern const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES];
+
 #endif  // GCC_TREE_CORE_H
Index: gcc/tree.c
===================================================================
--- gcc/tree.c	(revision 237622)
+++ gcc/tree.c	(working copy)
@@ -10150,6 +10150,20 @@  build_atomic_base (tree type, unsigned int align)
   return t;
 }
 
+/* Information about the _FloatN and _FloatNx types.  This must be in
+   the same order as the corresponding TI_* enum values.  */
+const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES] =
+  {
+    { 16, false },
+    { 32, false },
+    { 64, false },
+    { 128, false },
+    { 32, true },
+    { 64, true },
+    { 128, true },
+  };
+
+
 /* Create nodes for all integer types (and error_mark_node) using the sizes
    of C datatypes.  SIGNED_CHAR specifies whether char is signed.  */
 
@@ -10322,6 +10336,24 @@  build_common_tree_nodes (bool signed_char)
   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
   layout_type (long_double_type_node);
 
+  for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+    {
+      int n = floatn_nx_types[i].n;
+      bool extended = floatn_nx_types[i].extended;
+      machine_mode mode = targetm.floatn_mode (n, extended);
+      if (mode == VOIDmode)
+	continue;
+      int precision = GET_MODE_PRECISION (mode);
+      /* Work around the rs6000 KFmode having precision 113 not
+	 128.  */
+      if (precision < n)
+	precision = n;
+      FLOATN_NX_TYPE_NODE (i) = make_node (REAL_TYPE);
+      TYPE_PRECISION (FLOATN_NX_TYPE_NODE (i)) = precision;
+      layout_type (FLOATN_NX_TYPE_NODE (i));
+      SET_TYPE_MODE (FLOATN_NX_TYPE_NODE (i), mode);
+    }
+
   float_ptr_type_node = build_pointer_type (float_type_node);
   double_ptr_type_node = build_pointer_type (double_type_node);
   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
@@ -10356,6 +10388,13 @@  build_common_tree_nodes (bool signed_char)
   complex_double_type_node = build_complex_type (double_type_node);
   complex_long_double_type_node = build_complex_type (long_double_type_node);
 
+  for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
+    {
+      if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE)
+	COMPLEX_FLOATN_NX_TYPE_NODE (i)
+	  = build_complex_type (FLOATN_NX_TYPE_NODE (i));
+    }
+
 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
   sat_ ## KIND ## _type_node = \
Index: gcc/tree.h
===================================================================
--- gcc/tree.h	(revision 237622)
+++ gcc/tree.h	(working copy)
@@ -3612,6 +3612,17 @@  tree_operand_check_code (const_tree __t, enum tree
 #define double_type_node		global_trees[TI_DOUBLE_TYPE]
 #define long_double_type_node		global_trees[TI_LONG_DOUBLE_TYPE]
 
+/* Nodes for particular _FloatN and _FloatNx types in sequence.  */
+#define FLOATN_TYPE_NODE(IDX)		global_trees[TI_FLOATN_TYPE_FIRST + (IDX)]
+#define FLOATN_NX_TYPE_NODE(IDX)	global_trees[TI_FLOATN_NX_TYPE_FIRST + (IDX)]
+#define FLOATNX_TYPE_NODE(IDX)		global_trees[TI_FLOATNX_TYPE_FIRST + (IDX)]
+
+/* Names for individual types, where required by back ends
+   (architecture-independent code should always iterate over all such
+   types).  */
+#define float128_type_node		global_trees[TI_FLOAT128_TYPE]
+#define float64x_type_node		global_trees[TI_FLOAT64X_TYPE]
+
 #define float_ptr_type_node		global_trees[TI_FLOAT_PTR_TYPE]
 #define double_ptr_type_node		global_trees[TI_DOUBLE_PTR_TYPE]
 #define long_double_ptr_type_node	global_trees[TI_LONG_DOUBLE_PTR_TYPE]
@@ -3622,6 +3633,8 @@  tree_operand_check_code (const_tree __t, enum tree
 #define complex_double_type_node	global_trees[TI_COMPLEX_DOUBLE_TYPE]
 #define complex_long_double_type_node	global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]
 
+#define COMPLEX_FLOATN_NX_TYPE_NODE(IDX)	global_trees[TI_COMPLEX_FLOATN_NX_TYPE_FIRST + (IDX)]
+
 #define pointer_bounds_type_node        global_trees[TI_POINTER_BOUNDS_TYPE]
 
 #define void_type_node			global_trees[TI_VOID_TYPE]
Index: libcpp/expr.c
===================================================================
--- libcpp/expr.c	(revision 237622)
+++ libcpp/expr.c	(working copy)
@@ -91,10 +91,10 @@  static unsigned int
 interpret_float_suffix (cpp_reader *pfile, const uchar *s, size_t len)
 {
   size_t flags;
-  size_t f, d, l, w, q, i;
+  size_t f, d, l, w, q, i, fn, fnx, fn_bits;
 
   flags = 0;
-  f = d = l = w = q = i = 0;
+  f = d = l = w = q = i = fn = fnx = fn_bits = 0;
 
   /* Process decimal float suffixes, which are two letters starting
      with d or D.  Order and case are significant.  */
@@ -172,21 +172,59 @@  interpret_float_suffix (cpp_reader *pfile, const u
 
   /* In any remaining valid suffix, the case and order don't matter.  */
   while (len--)
-    switch (s[len])
-      {
-      case 'f': case 'F': f++; break;
-      case 'd': case 'D': d++; break;
-      case 'l': case 'L': l++; break;
-      case 'w': case 'W': w++; break;
-      case 'q': case 'Q': q++; break;
-      case 'i': case 'I':
-      case 'j': case 'J': i++; break;
-      default:
-	return 0;
-      }
+    {
+      switch (s[0])
+	{
+	case 'f': case 'F':
+	  f++;
+	  if (len > 0
+	      && !CPP_OPTION (pfile, cplusplus)
+	      && s[1] >= '1'
+	      && s[1] <= '9'
+	      && fn_bits == 0)
+	    {
+	      f--;
+	      while (len > 0
+		     && s[1] >= '0'
+		     && s[1] <= '9'
+		     && fn_bits < CPP_FLOATN_MAX)
+		{
+		  fn_bits = fn_bits * 10 + (s[1] - '0');
+		  len--;
+		  s++;
+		}
+	      if (len > 0 && s[1] == 'x')
+		{
+		  fnx++;
+		  len--;
+		  s++;
+		}
+	      else
+		fn++;
+	    }
+	  break;
+	case 'd': case 'D': d++; break;
+	case 'l': case 'L': l++; break;
+	case 'w': case 'W': w++; break;
+	case 'q': case 'Q': q++; break;
+	case 'i': case 'I':
+	case 'j': case 'J': i++; break;
+	default:
+	  return 0;
+	}
+      s++;
+    }
 
-  if (f + d + l + w + q > 1 || i > 1)
+  if (f + d + l + w + q + fn + fnx > 1 || i > 1)
     return 0;
+  if (fn_bits > CPP_FLOATN_MAX)
+    return 0;
+  if (fnx && fn_bits != 32 && fn_bits != 64 && fn_bits != 128)
+    return 0;
+  if (fn && fn_bits != 16 && fn_bits % 32 != 0)
+    return 0;
+  if (fn && fn_bits == 96)
+    return 0;
 
   if (i && !CPP_OPTION (pfile, ext_numeric_literals))
     return 0;
@@ -199,7 +237,10 @@  interpret_float_suffix (cpp_reader *pfile, const u
 	     d ? CPP_N_MEDIUM :
 	     l ? CPP_N_LARGE :
 	     w ? CPP_N_MD_W :
-	     q ? CPP_N_MD_Q : CPP_N_DEFAULT));
+	     q ? CPP_N_MD_Q :
+	     fn ? CPP_N_FLOATN | (fn_bits << CPP_FLOATN_SHIFT) :
+	     fnx ? CPP_N_FLOATNX | (fn_bits << CPP_FLOATN_SHIFT) :
+	     CPP_N_DEFAULT));
 }
 
 /* Return the classification flags for a float suffix.  */
Index: libcpp/include/cpplib.h
===================================================================
--- libcpp/include/cpplib.h	(revision 237622)
+++ libcpp/include/cpplib.h	(working copy)
@@ -902,9 +902,16 @@  struct cpp_num
 
 #define CPP_N_FRACT	0x100000 /* Fract types.  */
 #define CPP_N_ACCUM	0x200000 /* Accum types.  */
+#define CPP_N_FLOATN	0x400000 /* _FloatN types.  */
+#define CPP_N_FLOATNX	0x800000 /* _FloatNx types.  */
 
 #define CPP_N_USERDEF	0x1000000 /* C++0x user-defined literal.  */
 
+#define CPP_N_WIDTH_FLOATN_NX	0xF0000000 /* _FloatN / _FloatNx value
+					      of N, divided by 16.  */
+#define CPP_FLOATN_SHIFT	24
+#define CPP_FLOATN_MAX	0xF0
+
 /* Classify a CPP_NUMBER token.  The return value is a combination of
    the flags from the above sets.  */
 extern unsigned cpp_classify_number (cpp_reader *, const cpp_token *,