Re: [PATCH] call-cdce: Add missing BUILT_IN_*F{32,64}X handling and improve BUILT_IN_*L [PR113993]

[Richard Biener <rguenther@suse.de>]

On Wed, 21 Feb 2024, Jakub Jelinek wrote:

> Hi!
> 
> The following testcase ICEs, because can_test_argument_range
> returns true for BUILT_IN_{COSH,SINH,EXP{,M1,2}}{F32X,F64X}
> among many other builtins, but get_no_error_domain doesn't handle
> those.
> 
> float32x_type_node when supported in GCC always has DFmode, so that
> case is easy (and call-cdce assumes that SFmode is IEEE float and DFmode
> is IEEE double).  So *F32X is simply handled by adding those cases
> next to *F64.
> float64x_type_node when supported in GCC by definition has a mode
> with larger precision and exponent range than DFmode, so it can be XFmode,
> TFmode or KFmode.  I went through all the l/f128 suffixed builtins and
> verified that the float128x_type_node no error domain range is actually
> identical to the Intel extended long double no error domain range; it isn't
> that surprising, both IEEE quad and Intel/Motorola extended have the same
> exponent range [-16381, 16384] (well, Motorola -16382 probably because of
> different behavior for denormals, but that has nothing to do with
> get_no_error_domain which is about large inputs overflowing into +-Inf
> or triggering NaN, denormals could in theory do something solely for sqrt
> and even that is fine).  In theory some target could have different larger
> type, so for *F64X the code verifies that
> REAL_MODE_FORMAT (TYPE_MODE (float64x_type_node))->emax == 16384
> and if so, uses the *F128 domains, otherwise falls back to the non-suffixed
> ones (aka *F64), that is certainly the conservative minimum.
> While at it, the patch also changes the *L suffixed cases to do pretty much
> the same, the comment said that the function just assumes for *L
> the *F64 ranges, but that is unnecessarily conservative.
> All we currently have for long double is:
> 1) IEEE quad (emax 16384, *F128 ranges)
> 2) XFmode Intel/Motorola extended (emax 16384, same as *F128 ranges)
> 3) IBM extended (double double, emax 1024, the extra precision doesn't
>    really help and the domains are the same as for *F64)
> 4) same as double (*F64 again)
> So, the patch uses also for *L
> REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node))->emax == 16384
> checks and either tail recurses into the *F128 case for that or to
> non-suffixed (aka *F64) case otherwise.
> BUILT_IN_*F128X not handled because no target has those and it doesn't
> seem something is on the horizon and who knows what would be used for that.
> Thus, all we get this wrong for are probably VAX floats or something
> similar, no intent from me to look at that, that is preexisting issue.
> 
> BTW, I'm surprised we don't have BUILT_IN_EXP10F{16,32,64,128,32X,64X,128X}
> builtins, seems glibc has those (sure, I think except *16 and *128x).
> 
> Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?

OK.

Thanks,
Richard.

> 2024-02-21  Jakub Jelinek  <jakub@redhat.com>
> 
> 	PR tree-optimization/113993
> 	* tree-call-cdce.cc (get_no_error_domain): Handle
> 	BUILT_IN_{COSH,SINH,EXP{,M1,2}}{F32X,F64X}.  Handle
> 	BUILT_IN_{COSH,SINH,EXP{,M1,2}}L for
> 	REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node))->emax == 16384
> 	the as the F128 suffixed cases, otherwise as non-suffixed ones.
> 	Handle BUILT_IN_{EXP,POW}10L for
> 	REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node))->emax == 16384
> 	as (-inf, 4932).
> 
> 	* gcc.dg/tree-ssa/pr113993.c: New test.
> 
> --- gcc/tree-call-cdce.cc.jj	2024-01-03 11:51:37.654646209 +0100
> +++ gcc/tree-call-cdce.cc	2024-02-20 09:19:24.432837856 +0100
> @@ -677,14 +677,14 @@ gen_conditions_for_pow (gcall *pow_call,
>     Since IEEE only sets minimum requirements for long double format,
>     different long double formats exist under different implementations
>     (e.g, 64 bit double precision (DF), 80 bit double-extended
> -   precision (XF), and 128 bit quad precision (QF) ).  For simplicity,
> +   precision (XF), and 128 bit quad precision (TF) ).  For simplicity,
>     in this implementation, the computed bounds for long double assume
> -   64 bit format (DF), and are therefore conservative.  Another
> -   assumption is that single precision float type is always SF mode,
> -   and double type is DF mode.  This function is quite
> -   implementation specific, so it may not be suitable to be part of
> -   builtins.cc.  This needs to be revisited later to see if it can
> -   be leveraged in x87 assembly expansion.  */
> +   64 bit format (DF) except when it is IEEE quad or extended with the same
> +   emax, and are therefore sometimes conservative.  Another assumption is
> +   that single precision float type is always SF mode, and double type is DF
> +   mode.  This function is quite implementation specific, so it may not be
> +   suitable to be part of builtins.cc.  This needs to be revisited later
> +   to see if it can be leveraged in x87 assembly expansion.  */
>  
>  static inp_domain
>  get_no_error_domain (enum built_in_function fnc)
> @@ -723,10 +723,10 @@ get_no_error_domain (enum built_in_funct
>                           89, true, false);
>      case BUILT_IN_COSH:
>      case BUILT_IN_SINH:
> -    case BUILT_IN_COSHL:
> -    case BUILT_IN_SINHL:
>      case BUILT_IN_COSHF64:
>      case BUILT_IN_SINHF64:
> +    case BUILT_IN_COSHF32X:
> +    case BUILT_IN_SINHF32X:
>        /* cosh: (-710, +710)  */
>        return get_domain (-710, true, false,
>                           710, true, false);
> @@ -735,6 +735,16 @@ get_no_error_domain (enum built_in_funct
>        /* coshf128: (-11357, +11357)  */
>        return get_domain (-11357, true, false,
>  			 11357, true, false);
> +    case BUILT_IN_COSHL:
> +    case BUILT_IN_SINHL:
> +      if (REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node))->emax == 16384)
> +	return get_no_error_domain (BUILT_IN_COSHF128);
> +      return get_no_error_domain (BUILT_IN_COSH);
> +    case BUILT_IN_COSHF64X:
> +    case BUILT_IN_SINHF64X:
> +      if (REAL_MODE_FORMAT (TYPE_MODE (float64x_type_node))->emax == 16384)
> +	return get_no_error_domain (BUILT_IN_COSHF128);
> +      return get_no_error_domain (BUILT_IN_COSH);
>      /* Log functions: (0, +inf)  */
>      CASE_FLT_FN (BUILT_IN_LOG):
>      CASE_FLT_FN_FLOATN_NX (BUILT_IN_LOG):
> @@ -751,7 +761,7 @@ get_no_error_domain (enum built_in_funct
>      /* Exp functions.  */
>      case BUILT_IN_EXPF16:
>      case BUILT_IN_EXPM1F16:
> -      /* expf: (-inf, 11)  */
> +      /* expf16: (-inf, 11)  */
>        return get_domain (-1, false, false,
>  			 11, true, false);
>      case BUILT_IN_EXPF:
> @@ -763,10 +773,10 @@ get_no_error_domain (enum built_in_funct
>                           88, true, false);
>      case BUILT_IN_EXP:
>      case BUILT_IN_EXPM1:
> -    case BUILT_IN_EXPL:
> -    case BUILT_IN_EXPM1L:
>      case BUILT_IN_EXPF64:
>      case BUILT_IN_EXPM1F64:
> +    case BUILT_IN_EXPF32X:
> +    case BUILT_IN_EXPM1F32X:
>        /* exp: (-inf, 709)  */
>        return get_domain (-1, false, false,
>                           709, true, false);
> @@ -775,6 +785,16 @@ get_no_error_domain (enum built_in_funct
>        /* expf128: (-inf, 11356)  */
>        return get_domain (-1, false, false,
>  			 11356, true, false);
> +    case BUILT_IN_EXPL:
> +    case BUILT_IN_EXPM1L:
> +      if (REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node))->emax == 16384)
> +	return get_no_error_domain (BUILT_IN_EXPF128);
> +      return get_no_error_domain (BUILT_IN_EXP);
> +    case BUILT_IN_EXPF64X:
> +    case BUILT_IN_EXPM1F64X:
> +      if (REAL_MODE_FORMAT (TYPE_MODE (float64x_type_node))->emax == 16384)
> +	return get_no_error_domain (BUILT_IN_EXPF128);
> +      return get_no_error_domain (BUILT_IN_EXP);
>      case BUILT_IN_EXP2F16:
>        /* exp2f16: (-inf, 16)  */
>        return get_domain (-1, false, false,
> @@ -785,8 +805,8 @@ get_no_error_domain (enum built_in_funct
>        return get_domain (-1, false, false,
>                           128, true, false);
>      case BUILT_IN_EXP2:
> -    case BUILT_IN_EXP2L:
>      case BUILT_IN_EXP2F64:
> +    case BUILT_IN_EXP2F32X:
>        /* exp2: (-inf, 1024)  */
>        return get_domain (-1, false, false,
>                           1024, true, false);
> @@ -794,6 +814,14 @@ get_no_error_domain (enum built_in_funct
>        /* exp2f128: (-inf, 16384)  */
>        return get_domain (-1, false, false,
>  			 16384, true, false);
> +    case BUILT_IN_EXP2L:
> +      if (REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node))->emax == 16384)
> +	return get_no_error_domain (BUILT_IN_EXP2F128);
> +      return get_no_error_domain (BUILT_IN_EXP2);
> +    case BUILT_IN_EXP2F64X:
> +      if (REAL_MODE_FORMAT (TYPE_MODE (float64x_type_node))->emax == 16384)
> +	return get_no_error_domain (BUILT_IN_EXP2F128);
> +      return get_no_error_domain (BUILT_IN_EXP2);
>      case BUILT_IN_EXP10F:
>      case BUILT_IN_POW10F:
>        /* exp10f: (-inf, 38)  */
> @@ -801,11 +829,16 @@ get_no_error_domain (enum built_in_funct
>                           38, true, false);
>      case BUILT_IN_EXP10:
>      case BUILT_IN_POW10:
> -    case BUILT_IN_EXP10L:
> -    case BUILT_IN_POW10L:
>        /* exp10: (-inf, 308)  */
>        return get_domain (-1, false, false,
>                           308, true, false);
> +    case BUILT_IN_EXP10L:
> +    case BUILT_IN_POW10L:
> +      if (REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node))->emax == 16384)
> +	/* exp10l: (-inf, 4932)  */
> +	return get_domain (-1, false, false,
> +			   4932, true, false);
> +      return get_no_error_domain (BUILT_IN_EXP10);
>      /* sqrt: [0, +inf)  */
>      CASE_FLT_FN (BUILT_IN_SQRT):
>      CASE_FLT_FN_FLOATN_NX (BUILT_IN_SQRT):
> --- gcc/testsuite/gcc.dg/tree-ssa/pr113993.c.jj	2024-02-20 09:51:59.755613591 +0100
> +++ gcc/testsuite/gcc.dg/tree-ssa/pr113993.c	2024-02-20 09:52:28.815210185 +0100
> @@ -0,0 +1,299 @@
> +/* PR tree-optimization/113993 */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-tree-optimized" } */
> +/* { dg-add-options float32 } */
> +/* { dg-add-options float64 } */
> +/* { dg-add-options float128 } */
> +/* { dg-add-options float32x } */
> +/* { dg-add-options float64x } */
> +/* { dg-final { scan-tree-dump-not "__builtin_\[a-z0-9\] \\\(\[^\n\r\]\\\);" "optimized" } } */
> +
> +void
> +flt (float f1, float f2, float f3, float f4, float f5,
> +     float f6, float f7, float f8, float f9, float f10)
> +{
> +  if (!(f1 >= -1.0f && f1 <= 1.0f)) __builtin_unreachable ();
> +  __builtin_acosf (f1);
> +  __builtin_asinf (f1);
> +  if (!(f2 >= 1.0f && f2 <= __builtin_inff ())) __builtin_unreachable ();
> +  __builtin_acoshf (f2);
> +  if (!(f3 > -1.0f && f3 < 1.0f)) __builtin_unreachable ();
> +  __builtin_atanhf (f3);
> +  if (!(f4 > 0.0f && f4 < __builtin_inff ())) __builtin_unreachable ();
> +  __builtin_logf (f4);
> +  __builtin_log2f (f4);
> +  __builtin_log10f (f4);
> +  if (!(f5 > -1.0f && f5 < __builtin_inff ())) __builtin_unreachable ();
> +  __builtin_log1pf (f5);
> +  if (!(f6 >= 0.0f && f6 < __builtin_inff ())) __builtin_unreachable ();
> +  __builtin_sqrtf (f6);
> +#if __FLT_MANT_DIG__ == __FLT32_MANT_DIG__ && __FLT_MAX_EXP__ == __FLT32_MAX_EXP__
> +  if (!(f7 > -89.0f && f7 < 89.0f)) __builtin_unreachable ();
> +  __builtin_coshf (f7);
> +  __builtin_sinhf (f7);
> +  if (!(f8 > -__builtin_inff () && f8 < 88.0f)) __builtin_unreachable ();
> +  __builtin_expf (f8);
> +  if (!(f9 > -__builtin_inff () && f9 < 128.0f)) __builtin_unreachable ();
> +  __builtin_exp2f (f9);
> +  if (!(f10 > -__builtin_inff () && f10 < 38.0f)) __builtin_unreachable ();
> +  __builtin_exp10f (f10);
> +#endif
> +}
> +
> +#if defined(__FLT16_MANT_DIG__) && 0 /* No library routines here, these don't actually fold away.  */
> +void
> +flt16 (_Float16 f1, _Float16 f2, _Float16 f3, _Float16 f4, _Float16 f5,
> +       _Float16 f6, _Float16 f7, _Float16 f8, _Float16 f9)
> +{
> +  if (!(f1 >= -1.0f16 && f1 <= 1.0f16)) __builtin_unreachable ();
> +  __builtin_acosf16 (f1);
> +  __builtin_asinf16 (f1);
> +  if (!(f2 >= 1.0f16 && f2 <= __builtin_inff16 ())) __builtin_unreachable ();
> +  __builtin_acoshf16 (f2);
> +  if (!(f3 > -1.0f16 && f3 < 1.0f16)) __builtin_unreachable ();
> +  __builtin_atanhf16 (f3);
> +  if (!(f4 > 0.0f16 && f4 < __builtin_inff16 ())) __builtin_unreachable ();
> +  __builtin_logf16 (f4);
> +  __builtin_log2f16 (f4);
> +  __builtin_log10f16 (f4);
> +  if (!(f5 > -1.0f16 && f5 < __builtin_inff16 ())) __builtin_unreachable ();
> +  __builtin_log1pf16 (f5);
> +  if (!(f6 >= 0.0f16 && f6 < __builtin_inff16 ())) __builtin_unreachable ();
> +  __builtin_sqrtf16 (f6);
> +  if (!(f7 > -11.0f16 && f7 < 11.0f16)) __builtin_unreachable ();
> +  __builtin_coshf16 (f7);
> +  __builtin_sinhf16 (f7);
> +  if (!(f8 > -__builtin_inff16 () && f8 < 11.0f16)) __builtin_unreachable ();
> +  __builtin_expf16 (f8);
> +  if (!(f9 > -__builtin_inff16 () && f9 < 16.0f16)) __builtin_unreachable ();
> +  __builtin_exp2f16 (f9);
> +}
> +#endif
> +
> +#ifdef __FLT32_MANT_DIG__
> +void
> +flt32 (_Float32 f1, _Float32 f2, _Float32 f3, _Float32 f4, _Float32 f5,
> +       _Float32 f6, _Float32 f7, _Float32 f8, _Float32 f9)
> +{
> +  if (!(f1 >= -1.0f32 && f1 <= 1.0f32)) __builtin_unreachable ();
> +  __builtin_acosf32 (f1);
> +  __builtin_asinf32 (f1);
> +  if (!(f2 >= 1.0f32 && f2 <= __builtin_inff32 ())) __builtin_unreachable ();
> +  __builtin_acoshf32 (f2);
> +  if (!(f3 > -1.0f32 && f3 < 1.0f32)) __builtin_unreachable ();
> +  __builtin_atanhf32 (f3);
> +  if (!(f4 > 0.0f32 && f4 < __builtin_inff32 ())) __builtin_unreachable ();
> +  __builtin_logf32 (f4);
> +  __builtin_log2f32 (f4);
> +  __builtin_log10f32 (f4);
> +  if (!(f5 > -1.0f32 && f5 < __builtin_inff32 ())) __builtin_unreachable ();
> +  __builtin_log1pf32 (f5);
> +  if (!(f6 >= 0.0f32 && f6 < __builtin_inff32 ())) __builtin_unreachable ();
> +  __builtin_sqrtf32 (f6);
> +  if (!(f7 > -89.0f32 && f7 < 89.0f32)) __builtin_unreachable ();
> +  __builtin_coshf32 (f7);
> +  __builtin_sinhf32 (f7);
> +  if (!(f8 > -__builtin_inff32 () && f8 < 88.0f32)) __builtin_unreachable ();
> +  __builtin_expf32 (f8);
> +  if (!(f9 > -__builtin_inff32 () && f9 < 128.0f32)) __builtin_unreachable ();
> +  __builtin_exp2f32 (f9);
> +}
> +#endif
> +
> +void
> +dbl (double f1, double f2, double f3, double f4, double f5,
> +     double f6, double f7, double f8, double f9, double f10)
> +{
> +  if (!(f1 >= -1.0 && f1 <= 1.0)) __builtin_unreachable ();
> +  __builtin_acos (f1);
> +  __builtin_asin (f1);
> +  if (!(f2 >= 1.0 && f2 <= __builtin_inf ())) __builtin_unreachable ();
> +  __builtin_acosh (f2);
> +  if (!(f3 > -1.0 && f3 < 1.0)) __builtin_unreachable ();
> +  __builtin_atanh (f3);
> +  if (!(f4 > 0.0 && f4 < __builtin_inf ())) __builtin_unreachable ();
> +  __builtin_log (f4);
> +  __builtin_log2 (f4);
> +  __builtin_log10 (f4);
> +  if (!(f5 > -1.0 && f5 < __builtin_inf ())) __builtin_unreachable ();
> +  __builtin_log1p (f5);
> +  if (!(f6 >= 0.0 && f6 < __builtin_inf ())) __builtin_unreachable ();
> +  __builtin_sqrt (f6);
> +#if __DBL_MANT_DIG__ == __FLT64_MANT_DIG__ && __DBL_MAX_EXP__ == __FLT64_MAX_EXP__
> +  if (!(f7 > -710.0 && f7 < 710.0)) __builtin_unreachable ();
> +  __builtin_cosh (f7);
> +  __builtin_sinh (f7);
> +  if (!(f8 > -__builtin_inf () && f8 < 709.0)) __builtin_unreachable ();
> +  __builtin_exp (f8);
> +  if (!(f9 > -__builtin_inf () && f9 < 1024.0)) __builtin_unreachable ();
> +  __builtin_exp2 (f9);
> +  if (!(f10 > -__builtin_inf () && f10 < 308.0)) __builtin_unreachable ();
> +  __builtin_exp10 (f10);
> +#endif
> +}
> +
> +#ifdef __FLT64_MANT_DIG__
> +void
> +flt64 (_Float64 f1, _Float64 f2, _Float64 f3, _Float64 f4, _Float64 f5,
> +       _Float64 f6, _Float64 f7, _Float64 f8, _Float64 f9)
> +{
> +  if (!(f1 >= -1.0f64 && f1 <= 1.0f64)) __builtin_unreachable ();
> +  __builtin_acosf64 (f1);
> +  __builtin_asinf64 (f1);
> +  if (!(f2 >= 1.0f64 && f2 <= __builtin_inff64 ())) __builtin_unreachable ();
> +  __builtin_acoshf64 (f2);
> +  if (!(f3 > -1.0f64 && f3 < 1.0f64)) __builtin_unreachable ();
> +  __builtin_atanhf64 (f3);
> +  if (!(f4 > 0.0f64 && f4 < __builtin_inff64 ())) __builtin_unreachable ();
> +  __builtin_logf64 (f4);
> +  __builtin_log2f64 (f4);
> +  __builtin_log10f64 (f4);
> +  if (!(f5 > -1.0f64 && f5 < __builtin_inff64 ())) __builtin_unreachable ();
> +  __builtin_log1pf64 (f5);
> +  if (!(f6 >= 0.0f64 && f6 < __builtin_inff64 ())) __builtin_unreachable ();
> +  __builtin_sqrtf64 (f6);
> +  if (!(f7 > -710.0f64 && f7 < 710.0f64)) __builtin_unreachable ();
> +  __builtin_coshf64 (f7);
> +  __builtin_sinhf64 (f7);
> +  if (!(f8 > -__builtin_inff64 () && f8 < 709.0f64)) __builtin_unreachable ();
> +  __builtin_expf64 (f8);
> +  if (!(f9 > -__builtin_inff64 () && f9 < 1024.0f64)) __builtin_unreachable ();
> +  __builtin_exp2f64 (f9);
> +}
> +#endif
> +
> +#ifdef __FLT32X_MANT_DIG__
> +void
> +flt32x (_Float32x f1, _Float32x f2, _Float32x f3, _Float32x f4, _Float32x f5,
> +	_Float32x f6, _Float32x f7, _Float32x f8, _Float32x f9)
> +{
> +  if (!(f1 >= -1.0f32x && f1 <= 1.0f32x)) __builtin_unreachable ();
> +  __builtin_acosf32x (f1);
> +  __builtin_asinf32x (f1);
> +  if (!(f2 >= 1.0f32x && f2 <= __builtin_inff32x ())) __builtin_unreachable ();
> +  __builtin_acoshf32x (f2);
> +  if (!(f3 > -1.0f32x && f3 < 1.0f32x)) __builtin_unreachable ();
> +  __builtin_atanhf32x (f3);
> +  if (!(f4 > 0.0f32x && f4 < __builtin_inff32x ())) __builtin_unreachable ();
> +  __builtin_logf32x (f4);
> +  __builtin_log2f32x (f4);
> +  __builtin_log10f32x (f4);
> +  if (!(f5 > -1.0f32x && f5 < __builtin_inff32x ())) __builtin_unreachable ();
> +  __builtin_log1pf32x (f5);
> +  if (!(f6 >= 0.0f32x && f6 < __builtin_inff32x ())) __builtin_unreachable ();
> +  __builtin_sqrtf32x (f6);
> +#if __FLT32X_MANT_DIG__ == __FLT64_MANT_DIG__ && __FLT32X_MAX_EXP__ == __FLT64_MAX_EXP__
> +  if (!(f7 > -710.0f32x && f7 < 710.0f32x)) __builtin_unreachable ();
> +  __builtin_coshf32x (f7);
> +  __builtin_sinhf32x (f7);
> +  if (!(f8 > -__builtin_inff32x () && f8 < 709.0f32x)) __builtin_unreachable ();
> +  __builtin_expf32x (f8);
> +  if (!(f9 > -__builtin_inff32x () && f9 < 1024.0f32x)) __builtin_unreachable ();
> +  __builtin_exp2f32x (f9);
> +#endif
> +}
> +#endif
> +
> +void
> +ldbl (long double f1, long double f2, long double f3, long double f4, long double f5,
> +      long double f6, long double f7, long double f8, long double f9, long double f10)
> +{
> +  if (!(f1 >= -1.0L && f1 <= 1.0L)) __builtin_unreachable ();
> +  __builtin_acosl (f1);
> +  __builtin_asinl (f1);
> +  if (!(f2 >= 1.0L && f2 <= __builtin_infl ())) __builtin_unreachable ();
> +  __builtin_acoshl (f2);
> +  if (!(f3 > -1.0L && f3 < 1.0L)) __builtin_unreachable ();
> +  __builtin_atanhl (f3);
> +  if (!(f4 > 0.0L && f4 < __builtin_infl ())) __builtin_unreachable ();
> +  __builtin_logl (f4);
> +  __builtin_log2l (f4);
> +  __builtin_log10l (f4);
> +  if (!(f5 > -1.0L && f5 < __builtin_infl ())) __builtin_unreachable ();
> +  __builtin_log1pl (f5);
> +  if (!(f6 >= 0.0L && f6 < __builtin_infl ())) __builtin_unreachable ();
> +  __builtin_sqrtl (f6);
> +#if __LDBL_MAX_EXP__ == 16384
> +  if (!(f7 > -11357.0L && f7 < 11357.0L)) __builtin_unreachable ();
> +  __builtin_coshl (f7);
> +  __builtin_sinhl (f7);
> +  if (!(f8 > -__builtin_infl () && f8 < 11356.0L)) __builtin_unreachable ();
> +  __builtin_expl (f8);
> +  if (!(f9 > -__builtin_infl () && f9 < 16384.0L)) __builtin_unreachable ();
> +  __builtin_exp2l (f9);
> +  if (!(f10 > -__builtin_infl () && f10 < 4932.0L)) __builtin_unreachable ();
> +  __builtin_exp10l (f10);
> +#elif __LDBL_MANT_DIG__ == __FLT64_MANT_DIG__ && __LDBL_MAX_EXP__ == __FLT64_MAX_EXP__
> +  if (!(f7 > -710.0L && f7 < 710.0L)) __builtin_unreachable ();
> +  __builtin_coshl (f7);
> +  __builtin_sinhl (f7);
> +  if (!(f8 > -__builtin_infl () && f8 < 709.0L)) __builtin_unreachable ();
> +  __builtin_expl (f8);
> +  if (!(f9 > -__builtin_infl () && f9 < 1024.0L)) __builtin_unreachable ();
> +  __builtin_exp2l (f9);
> +  if (!(f10 > -__builtin_infl () && f10 < 308.0L)) __builtin_unreachable ();
> +  __builtin_exp10l (f10);
> +#endif
> +}
> +
> +#ifdef __FLT128_MANT_DIG__
> +void
> +flt128 (_Float128 f1, _Float128 f2, _Float128 f3, _Float128 f4, _Float128 f5,
> +	_Float128 f6, _Float128 f7, _Float128 f8, _Float128 f9)
> +{
> +  if (!(f1 >= -1.0f128 && f1 <= 1.0f128)) __builtin_unreachable ();
> +  __builtin_acosf128 (f1);
> +  __builtin_asinf128 (f1);
> +  if (!(f2 >= 1.0f128 && f2 <= __builtin_inff128 ())) __builtin_unreachable ();
> +  __builtin_acoshf128 (f2);
> +  if (!(f3 > -1.0f128 && f3 < 1.0f128)) __builtin_unreachable ();
> +  __builtin_atanhf128 (f3);
> +  if (!(f4 > 0.0f128 && f4 < __builtin_inff128 ())) __builtin_unreachable ();
> +  __builtin_logf128 (f4);
> +  __builtin_log2f128 (f4);
> +  __builtin_log10f128 (f4);
> +  if (!(f5 > -1.0f128 && f5 < __builtin_inff128 ())) __builtin_unreachable ();
> +  __builtin_log1pf128 (f5);
> +  if (!(f6 >= 0.0f128 && f6 < __builtin_inff128 ())) __builtin_unreachable ();
> +  __builtin_sqrtf128 (f6);
> +  if (!(f7 > -11357.0f128 && f7 < 11357.0f128)) __builtin_unreachable ();
> +  __builtin_coshf128 (f7);
> +  __builtin_sinhf128 (f7);
> +  if (!(f8 > -__builtin_inff128 () && f8 < 11356.0f128)) __builtin_unreachable ();
> +  __builtin_expf128 (f8);
> +  if (!(f9 > -__builtin_inff128 () && f9 < 16384.0f128)) __builtin_unreachable ();
> +  __builtin_exp2f128 (f9);
> +}
> +#endif
> +
> +#ifdef __FLT64X_MANT_DIG__
> +void
> +flt64x (_Float64x f1, _Float64x f2, _Float64x f3, _Float64x f4, _Float64x f5,
> +	_Float64x f6, _Float64x f7, _Float64x f8, _Float64x f9)
> +{
> +  if (!(f1 >= -1.0f64x && f1 <= 1.0f64x)) __builtin_unreachable ();
> +  __builtin_acosf64x (f1);
> +  __builtin_asinf64x (f1);
> +  if (!(f2 >= 1.0f64x && f2 <= __builtin_inff64x ())) __builtin_unreachable ();
> +  __builtin_acoshf64x (f2);
> +  if (!(f3 > -1.0f64x && f3 < 1.0f64x)) __builtin_unreachable ();
> +  __builtin_atanhf64x (f3);
> +  if (!(f4 > 0.0f64x && f4 < __builtin_inff64x ())) __builtin_unreachable ();
> +  __builtin_logf64x (f4);
> +  __builtin_log2f64x (f4);
> +  __builtin_log10f64x (f4);
> +  if (!(f5 > -1.0f64x && f5 < __builtin_inff64x ())) __builtin_unreachable ();
> +  __builtin_log1pf64x (f5);
> +  if (!(f6 >= 0.0f64x && f6 < __builtin_inff64x ())) __builtin_unreachable ();
> +  __builtin_sqrtf64x (f6);
> +#if __FLT64X_MAX_EXP__ == 16384
> +  if (!(f7 > -11357.0f64x && f7 < 11357.0f64x)) __builtin_unreachable ();
> +  __builtin_coshf64x (f7);
> +  __builtin_sinhf64x (f7);
> +  if (!(f8 > -__builtin_inff64x () && f8 < 11356.0f64x)) __builtin_unreachable ();
> +  __builtin_expf64x (f8);
> +  if (!(f9 > -__builtin_inff64x () && f9 < 16384.0f64x)) __builtin_unreachable ();
> +  __builtin_exp2f64x (f9);
> +#endif
> +}
> +#endif
> 
> 	Jakub
> 
> 

-- 
Richard Biener <rguenther@suse.de>
SUSE Software Solutions Germany GmbH,
Frankenstrasse 146, 90461 Nuernberg, Germany;
GF: Ivo Totev, Andrew McDonald, Werner Knoblich; (HRB 36809, AG Nuernberg)