/* file: libm_error.c */// Copyright (c) 2000 - 2005, Intel Corporation// All rights reserved.//// Contributed 2000 by the Intel Numerics Group, Intel Corporation//// Redistribution and use in source and binary forms, with or without// modification, are permitted provided that the following conditions are// met://// * Redistributions of source code must retain the above copyright// notice, this list of conditions and the following disclaimer.//// * Redistributions in binary form must reproduce the above copyright// notice, this list of conditions and the following disclaimer in the// documentation and/or other materials provided with the distribution.//// * The name of Intel Corporation may not be used to endorse or promote// products derived from this software without specific prior written// permission.//// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.//// Intel Corporation is the author of this code, and requests that all// problem reports or change requests be submitted to it directly at// http://www.intel.com/software/products/opensource/libraries/num.htm.//// History//==============================================================//  2/02/00: Initial version//  3/22/00: Updated to support flexible and dynamic error handling.//  8/16/00: Changed all matherr function-calls to use the pmatherr//           function-pointers.// 10/03/00: Corrected a scalb type.// 11/28/00: Changed INPUT_XL to INPUT_XD for scalb_underflow case.// 12/07/00: Added code to make scalbn error support equivalent to ldexp.//  2/07/01: Added __declspec(align(16)) to long double constants to correct//           alignment problem.//  4/23/01: Added code for remquo//  6/07/01: Added code for fdim, lrint, lround, llrint, llround//           Deleted code for remquo//  8/15/01: Added code for scalbln, nexttoward// 12/10/01: Added code for erfc// 12/27/01: Added code for degree argument functions// 01/02/02: Added code for tand, cotd// 01/15/02: Corrected SVID/XOPEN code for log1p, pow, and acosh// 01/25/02: Corrected ISOC for lgamma and gamma to return EDOM for neg ints// 01/28/02: Corrected SVID/XOPEN stderr message for log2// 05/20/02: Added code for cot// 07/01/02: Added code for sinhcosh// 10/04/02: Underflow detection in ISOC path redefined to//           be zero rather than tiny and inexact// 12/06/02: Added code for annuity and compound// 01/30/03: Corrected test for underflow in ISOC path to not set denormal// 04/10/03: Corrected ISOC branch for gamma/lgamma to return ERANGE for neg ints.//           Added code for tgamma// 04/11/03: Corrected POSIX/SVID/XOPEN branches for gamma/lgamma//           to return EDOM for neg ints.// 09/08/03: Corrected XOPEN/SVID result for pow overflow with neg x, pos y.// 10/14/03: Added ILP32 ifdef// 12/12/03: Corrected XOPEN/SVID results for powf_zero_to_negative,//           powl_neg_to_non_integer, atan2f_zero, atan2df_zero,//           acoshf_lt_one, acosh_lt_one.// 12/07/04: Cast name strings as char *.// 12/08/04: Corrected POSIX behavior for atan2_zero, acos_gt_one, asin_gt_one,//           log_negative, log10_negative, log1p_negative, and log2_negative.//           Added SVID and XOPEN case log2l_zero.// 12/13/04: Corrected POSIX behavior for exp2_overflow, exp2_underflow,//           exp10_overflow, exp10_underflow.  Added ISOC to set errno for//           exp10_underflow.// 12/14/04: Corrected POSIX behavior for nextafter_overflow,//           nextafter_underflow, nexttoward_overflow, nexttoward_underflow.//           Added ISOC to set errno for nextafter and nexttoward underflow.// 12/15/04: Corrected POSIX behavior for exp, exp2, and exp10 underflow.// 03/31/05: Added missing ALIGNIT statement to 6 float constants.#include <errno.h>#include <stdio.h>#include <stdlib.h>#include "libm_support.h"#ifdef _LIBC# define pmatherr matherr# define pmatherrf matherrf# define pmatherrl matherrl#else_LIB_VERSION_TYPE#if defined( __POSIX__ )_LIB_VERSIONIMF = _POSIX_;#elif defined( __XOPEN__ )_LIB_VERSIONIMF = _XOPEN_;#elif defined( __SVID__ )_LIB_VERSIONIMF = _SVID_;#elif defined( __IEEE__ )_LIB_VERSIONIMF = _IEEE_;#else_LIB_VERSIONIMF = _ISOC_;#endif/************************************************************//* matherrX function pointers and setusermatherrX functions *//************************************************************/int (*pmatherrf)(struct exceptionf*) = MATHERR_F;int (*pmatherr)(struct EXC_DECL_D*) = MATHERR_D;int (*pmatherrl)(struct exceptionl*) = matherrl;void __libm_setusermatherrf( int(*user_merrf)(struct exceptionf*) ){   pmatherrf = ( (user_merrf==NULL)? (MATHERR_F) : (user_merrf) ); }void __libm_setusermatherr( int(*user_merr)(struct EXC_DECL_D*) ){   pmatherr = ( (user_merr==NULL)? (MATHERR_D) : (user_merr) );    }void __libm_setusermatherrl( int(*user_merrl)(struct exceptionl*) ){   pmatherrl = ( (user_merrl==NULL)? (matherrl) : (user_merrl) );  }#endif /* !_LIBC *//***********************************************//* error-handling function, libm_error_support *//***********************************************/void __libm_error_support(void *arg1,void *arg2,void *retval,error_types input_tag){# ifdef __cplusplusstruct __exception exc;# elsestruct exception  exc;# endifstruct exceptionf excf;struct exceptionl excl;# ifdef __GNUC__#define ALIGNIT __attribute__ ((__aligned__ (16)))# elif defined opensource#define ALIGNIT# else#define ALIGNIT __declspec(align(16))# endif# ifdef SIZE_LONG_INT_64#define __INT_64__ signed long# else# if ILP32#define __INT_64__ signed long long# else#define __INT_64__ __int64# endif# endif#define STATIC staticALIGNITSTATIC const char float_inf[4] = {0x00,0x00,0x80,0x7F};ALIGNITSTATIC const char float_huge[4] = {0xFF,0xFF,0x7F,0x7F};ALIGNITSTATIC const char float_zero[4] = {0x00,0x00,0x00,0x00};ALIGNITSTATIC const char float_neg_inf[4] = {0x00,0x00,0x80,0xFF};ALIGNITSTATIC const char float_neg_huge[4] = {0xFF,0xFF,0x7F,0xFF};ALIGNITSTATIC const char float_neg_zero[4] = {0x00,0x00,0x00,0x80};ALIGNITSTATIC const char double_inf[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x7F};#ifndef _LIBCALIGNITSTATIC const char double_huge[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0x7F};#endifALIGNITSTATIC const char double_zero[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};ALIGNITSTATIC const char double_neg_inf[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0xFF};#ifndef _LIBCALIGNITSTATIC const char double_neg_huge[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0xFF};#endifALIGNITSTATIC const char double_neg_zero[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80};ALIGNITSTATIC const char long_double_inf[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x7F,0x00,0x00,0x00,0x00,0x00,0x00};ALIGNIT#ifndef _LIBCSTATIC const char long_double_huge[16] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x7F,0x00,0x00,0x00,0x00,0x00,0x00};#endifALIGNITSTATIC const char long_double_zero[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};ALIGNITSTATIC const char long_double_neg_inf[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00};ALIGNIT#ifndef _LIBCSTATIC const char long_double_neg_huge[16] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0x00,0x00,0x00,0x00,0x00,0x00};#endifALIGNITSTATIC const char long_double_neg_zero[16] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00};#define RETVAL_HUGE_VALL *(long double *)retval =  *(long double *)long_double_inf#define RETVAL_NEG_HUGE_VALL *(long double *)retval = *(long double *)long_double_neg_inf#define RETVAL_HUGEL *(long double *)retval = (long double)*(float *)float_huge#define RETVAL_NEG_HUGEL *(long double *)retval =(long double)*(float*)float_neg_huge#define RETVAL_HUGE_VALD *(double *)retval = *(double *) double_inf#define RETVAL_NEG_HUGE_VALD *(double *)retval = *(double *) double_neg_inf#define RETVAL_HUGED *(double *)retval = (double) *(float *)float_huge#define RETVAL_NEG_HUGED *(double *)retval = (double) *(float *) float_neg_huge#define RETVAL_HUGE_VALF *(float *)retval =  *(float *) float_inf#define RETVAL_NEG_HUGE_VALF *(float *)retval = *(float *) float_neg_inf#define RETVAL_HUGEF *(float *)retval = *(float *) float_huge#define RETVAL_NEG_HUGEF *(float *)retval = *(float *) float_neg_huge#define ZEROL_VALUE *(long double *)long_double_zero#define ZEROD_VALUE *(double *)double_zero#define ZEROF_VALUE *(float *)float_zero#define RETVAL_ZEROL *(long double *)retval = *(long double *)long_double_zero#define RETVAL_ZEROD *(double *)retval = *(double *)double_zero#define RETVAL_ZEROF *(float *)retval = *(float *)float_zero#define RETVAL_NEG_ZEROL *(long double *)retval = *(long double *)long_double_neg_zero#define RETVAL_NEG_ZEROD *(double *)retval = *(double *)double_neg_zero#define RETVAL_NEG_ZEROF *(float *)retval = *(float *)float_neg_zero#define RETVAL_ONEL *(long double *)retval = (long double) 1.0#define RETVAL_ONED *(double *)retval = 1.0#define RETVAL_ONEF *(float *)retval = 1.0f#define NOT_MATHERRL excl.arg1=*(long double *)arg1;excl.arg2=*(long double *)arg2;excl.retval=*(long double *)retval;if(!pmatherrl(&excl))#define NOT_MATHERRD exc.arg1=*(double *)arg1;exc.arg2=*(double *)arg2;exc.retval=*(double *)retval;if(!pmatherr(&exc))#define NOT_MATHERRF excf.arg1=*(float *)arg1;excf.arg2=*(float *)arg2;excf.retval=*(float *)retval;if(!pmatherrf(&excf))#define ifSVID if(_LIB_VERSIONIMF==_SVID_)#define NAMEL excl.name#define NAMED exc.name#define NAMEF excf.name//// These should work OK for MS because they are ints -// leading underbars are not necessary.//#define DOMAIN          1#define SING            2#define OVERFLOW        3#define UNDERFLOW       4#define TLOSS           5#define PLOSS           6#define SINGL excl.type = SING#define DOMAINL excl.type = DOMAIN#define OVERFLOWL excl.type = OVERFLOW#define UNDERFLOWL excl.type = UNDERFLOW#define TLOSSL excl.type = TLOSS#define SINGD exc.type = SING#define DOMAIND exc.type = DOMAIN#define OVERFLOWD exc.type = OVERFLOW#define UNDERFLOWD exc.type = UNDERFLOW#define TLOSSD exc.type = TLOSS#define SINGF excf.type = SING#define DOMAINF excf.type = DOMAIN#define OVERFLOWF excf.type = OVERFLOW#define UNDERFLOWF excf.type = UNDERFLOW#define TLOSSF excf.type = TLOSS#define INPUT_XL (excl.arg1=*(long double*)arg1)#define INPUT_XD (exc.arg1=*(double*)arg1)#define INPUT_XF (excf.arg1=*(float*)arg1)#define INPUT_YL (excl.arg2=*(long double*)arg2)#define INPUT_YD (exc.arg2=*(double*)arg2)#define INPUT_YF (excf.arg2=*(float*)arg2)#define INPUT_RESL (*(long double *)retval)#define INPUT_RESD (*(double *)retval)#define INPUT_RESF (*(float *)retval)#define INPUT_RESI64 (*(__INT_64__ *)retval)#define WRITEL_LOG_ZERO fputs("logl: SING error\n",stderr)#define WRITED_LOG_ZERO fputs("log: SING error\n",stderr)#define WRITEF_LOG_ZERO fputs("logf: SING error\n",stderr)#define WRITEL_LOG_NEGATIVE fputs("logl: DOMAIN error\n",stderr)#define WRITED_LOG_NEGATIVE fputs("log: DOMAIN error\n",stderr)#define WRITEF_LOG_NEGATIVE fputs("logf: DOMAIN error\n",stderr)#define WRITEL_Y0_ZERO fputs("y0l: DOMAIN error\n",stderr)#define WRITED_Y0_ZERO fputs("y0: DOMAIN error\n",stderr)#define WRITEF_Y0_ZERO fputs("y0f: DOMAIN error\n",stderr)#define WRITEL_Y0_NEGATIVE fputs("y0l: DOMAIN error\n",stderr)#define WRITED_Y0_NEGATIVE fputs("y0: DOMAIN error\n",stderr)#define WRITEF_Y0_NEGATIVE fputs("y0f: DOMAIN error\n",stderr)#define WRITEL_Y1_ZERO fputs("y1l: DOMAIN error\n",stderr)#define WRITED_Y1_ZERO fputs("y1: DOMAIN error\n",stderr)#define WRITEF_Y1_ZERO fputs("y1f: DOMAIN error\n",stderr)#define WRITEL_Y1_NEGATIVE fputs("y1l: DOMAIN error\n",stderr)#define WRITED_Y1_NEGATIVE fputs("y1: DOMAIN error\n",stderr)#define WRITEF_Y1_NEGATIVE fputs("y1f: DOMAIN error\n",stderr)#define WRITEL_YN_ZERO fputs("ynl: DOMAIN error\n",stderr)#define WRITED_YN_ZERO fputs("yn: DOMAIN error\n",stderr)#define WRITEF_YN_ZERO fputs("ynf: DOMAIN error\n",stderr)#define WRITEL_YN_NEGATIVE fputs("ynl: DOMAIN error\n",stderr)#define WRITED_YN_NEGATIVE fputs("yn: DOMAIN error\n",stderr)#define WRITEF_YN_NEGATIVE fputs("ynf: DOMAIN error\n",stderr)#define WRITEL_LOG1P_ZERO fputs("log1pl: SING error\n",stderr)#define WRITED_LOG1P_ZERO fputs("log1p: SING error\n",stderr)#define WRITEF_LOG1P_ZERO fputs("log1pf: SING error\n",stderr)#define WRITEL_LOG1P_NEGATIVE fputs("log1pl: DOMAIN error\n",stderr)#define WRITED_LOG1P_NEGATIVE fputs("log1p: DOMAIN error\n",stderr)#define WRITEF_LOG1P_NEGATIVE fputs("log1pf: DOMAIN error\n",stderr)#define WRITEL_LOG10_ZERO fputs("log10l: SING error\n",stderr)#define WRITED_LOG10_ZERO fputs("log10: SING error\n",stderr)#define WRITEF_LOG10_ZERO fputs("log10f: SING error\n",stderr)#define WRITEL_LOG10_NEGATIVE fputs("log10l: DOMAIN error\n",stderr)#define WRITED_LOG10_NEGATIVE fputs("log10: DOMAIN error\n",stderr)#define WRITEF_LOG10_NEGATIVE fputs("log10f: DOMAIN error\n",stderr)#define WRITEL_LOG2_ZERO fputs("log2l: SING error\n",stderr)#define WRITED_LOG2_ZERO fputs("log2: SING error\n",stderr)#define WRITEF_LOG2_ZERO fputs("log2f: SING error\n",stderr)#define WRITEL_LOG2_NEGATIVE fputs("log2l: DOMAIN error\n",stderr)#define WRITED_LOG2_NEGATIVE fputs("log2: DOMAIN error\n",stderr)#define WRITEF_LOG2_NEGATIVE fputs("log2f: DOMAIN error\n",stderr)#define WRITEL_POW_ZERO_TO_ZERO fputs("powl(0,0): DOMAIN error\n",stderr)#define WRITED_POW_ZERO_TO_ZERO fputs("pow(0,0): DOMAIN error\n",stderr)#define WRITEF_POW_ZERO_TO_ZERO fputs("powf(0,0): DOMAIN error\n",stderr)#define WRITEL_POW_ZERO_TO_NEGATIVE fputs("powl(0,negative): DOMAIN error\n",stderr)#define WRITED_POW_ZERO_TO_NEGATIVE fputs("pow(0,negative): DOMAIN error\n",stderr)#define WRITEF_POW_ZERO_TO_NEGATIVE fputs("powf(0,negative): DOMAIN error\n",stderr)#define WRITEL_POW_NEG_TO_NON_INTEGER fputs("powl(negative,non-integer): DOMAIN error\n",stderr)#define WRITED_POW_NEG_TO_NON_INTEGER fputs("pow(negative,non-integer): DOMAIN error\n",stderr)#define WRITEF_POW_NEG_TO_NON_INTEGER fputs("powf(negative,non-integer): DOMAIN error\n",stderr)#define WRITEL_ATAN2_ZERO_BY_ZERO fputs("atan2l: DOMAIN error\n",stderr)#define WRITED_ATAN2_ZERO_BY_ZERO fputs("atan2: DOMAIN error\n",stderr)#define WRITEF_ATAN2_ZERO_BY_ZERO fputs("atan2f: DOMAIN error\n",stderr)#define WRITEL_SQRT fputs("sqrtl: DOMAIN error\n",stderr)#define WRITED_SQRT fputs("sqrt: DOMAIN error\n",stderr)#define WRITEF_SQRT fputs("sqrtf: DOMAIN error\n",stderr)#define WRITEL_FMOD fputs("fmodl: DOMAIN error\n",stderr)#define WRITED_FMOD fputs("fmod: DOMAIN error\n",stderr)#define WRITEF_FMOD fputs("fmodf: DOMAIN error\n",stderr)#define WRITEL_REM fputs("remainderl: DOMAIN error\n",stderr)#define WRITED_REM fputs("remainder: DOMAIN error\n",stderr)#define WRITEF_REM fputs("remainderf: DOMAIN error\n",stderr)#define WRITEL_ACOS fputs("acosl: DOMAIN error\n",stderr)#define WRITED_ACOS fputs("acos: DOMAIN error\n",stderr)#define WRITEF_ACOS fputs("acosf: DOMAIN error\n",stderr)#define WRITEL_ASIN fputs("asinl: DOMAIN error\n",stderr)#define WRITED_ASIN fputs("asin: DOMAIN error\n",stderr)#define WRITEF_ASIN fputs("asinf: DOMAIN error\n",stderr)#define WRITEL_ACOSH fputs("acoshl: DOMAIN error\n",stderr)#define WRITED_ACOSH fputs("acosh: DOMAIN error\n",stderr)#define WRITEF_ACOSH fputs("acoshf: DOMAIN error\n",stderr)#define WRITEL_ATANH_GT_ONE fputs("atanhl: DOMAIN error\n",stderr)#define WRITED_ATANH_GT_ONE fputs("atanh: DOMAIN error\n",stderr)#define WRITEF_ATANH_GT_ONE fputs("atanhf: DOMAIN error\n",stderr)#define WRITEL_ATANH_EQ_ONE fputs("atanhl: SING error\n",stderr)#define WRITED_ATANH_EQ_ONE fputs("atanh: SING error\n",stderr)#define WRITEF_ATANH_EQ_ONE fputs("atanhf: SING error\n",stderr)#define WRITEL_LGAMMA_NEGATIVE fputs("lgammal: SING error\n",stderr)#define WRITED_LGAMMA_NEGATIVE fputs("lgamma: SING error\n",stderr)#define WRITEF_LGAMMA_NEGATIVE fputs("lgammaf: SING error\n",stderr)#define WRITEL_GAMMA_NEGATIVE fputs("gammal: SING error\n",stderr)#define WRITED_GAMMA_NEGATIVE fputs("gamma: SING error\n",stderr)#define WRITEF_GAMMA_NEGATIVE fputs("gammaf: SING error\n",stderr)#define WRITEL_TGAMMA_NEGATIVE fputs("tgammal: SING error\n",stderr)#define WRITED_TGAMMA_NEGATIVE fputs("tgamma: SING error\n",stderr)#define WRITEF_TGAMMA_NEGATIVE fputs("tgammaf: SING error\n",stderr)#define WRITEL_J0_TLOSS  fputs("j0l: TLOSS error\n",stderr)#define WRITEL_Y0_TLOSS  fputs("y0l: TLOSS error\n",stderr)#define WRITEL_J1_TLOSS  fputs("j1l: TLOSS error\n",stderr)#define WRITEL_Y1_TLOSS  fputs("y1l: TLOSS error\n",stderr)#define WRITEL_JN_TLOSS  fputs("jnl: TLOSS error\n",stderr)#define WRITEL_YN_TLOSS  fputs("ynl: TLOSS error\n",stderr)#define WRITED_J0_TLOSS  fputs("j0: TLOSS error\n",stderr)#define WRITED_Y0_TLOSS  fputs("y0: TLOSS error\n",stderr)#define WRITED_J1_TLOSS  fputs("j1: TLOSS error\n",stderr)#define WRITED_Y1_TLOSS  fputs("y1: TLOSS error\n",stderr)#define WRITED_JN_TLOSS  fputs("jn: TLOSS error\n",stderr)#define WRITED_YN_TLOSS  fputs("yn: TLOSS error\n",stderr)#define WRITEF_J0_TLOSS  fputs("j0f: TLOSS error\n",stderr)#define WRITEF_Y0_TLOSS  fputs("y0f: TLOSS error\n",stderr)#define WRITEF_J1_TLOSS  fputs("j1f: TLOSS error\n",stderr)#define WRITEF_Y1_TLOSS  fputs("y1f: TLOSS error\n",stderr)#define WRITEF_JN_TLOSS  fputs("jnf: TLOSS error\n",stderr)#define WRITEF_YN_TLOSS  fputs("ynf: TLOSS error\n",stderr)#define WRITEL_ACOSD fputs("acosdl: DOMAIN error\n",stderr)#define WRITED_ACOSD fputs("acosd: DOMAIN error\n",stderr)#define WRITEF_ACOSD fputs("acosdf: DOMAIN error\n",stderr)#define WRITEL_ASIND fputs("asindl: DOMAIN error\n",stderr)#define WRITED_ASIND fputs("asind: DOMAIN error\n",stderr)#define WRITEF_ASIND fputs("asindf: DOMAIN error\n",stderr)#define WRITEL_ATAN2D_ZERO_BY_ZERO fputs("atan2dl: DOMAIN error\n",stderr)#define WRITED_ATAN2D_ZERO_BY_ZERO fputs("atan2d: DOMAIN error\n",stderr)#define WRITEF_ATAN2D_ZERO_BY_ZERO fputs("atan2df: DOMAIN error\n",stderr)/***********************//* IEEE Path           *//***********************/if(_LIB_VERSIONIMF==_IEEE_) return;/***********************//* C9X Path           *//***********************/else if(_LIB_VERSIONIMF==_ISOC_){  switch(input_tag)  {    case logl_zero:    case log_zero:    case logf_zero:    case log10l_zero:    case log10_zero:    case log10f_zero:    case log2l_zero:    case log2_zero:    case log2f_zero:    case log1pl_zero:    case log1p_zero:    case log1pf_zero:    case powl_overflow:    case pow_overflow:    case powf_overflow:    case expl_overflow:    case exp_overflow:    case expf_overflow:    case exp2l_overflow:    case exp2_overflow:    case exp2f_overflow:    case exp10l_overflow:    case exp10_overflow:    case exp10f_overflow:    case expm1l_overflow:    case expm1_overflow:    case expm1f_overflow:    case hypotl_overflow:    case hypot_overflow:    case hypotf_overflow:    case sinhl_overflow:    case sinh_overflow:    case sinhf_overflow:    case atanhl_eq_one:    case atanh_eq_one:    case atanhf_eq_one:    case scalbl_overflow:    case scalb_overflow:    case scalbf_overflow:    case coshl_overflow:    case cosh_overflow:    case coshf_overflow:    case nextafterl_overflow:    case nextafter_overflow:    case nextafterf_overflow:    case nextafterl_underflow:    case nextafter_underflow:    case nextafterf_underflow:    case nexttowardl_overflow:    case nexttoward_overflow:    case nexttowardf_overflow:    case nexttowardl_underflow:    case nexttoward_underflow:    case nexttowardf_underflow:    case scalbnl_overflow:    case scalbn_overflow:    case scalbnf_overflow:    case scalblnl_overflow:    case scalbln_overflow:    case scalblnf_overflow:    case ldexpl_overflow:    case ldexp_overflow:    case ldexpf_overflow:    case lgammal_overflow:    case lgamma_overflow:    case lgammaf_overflow:    case gammal_overflow:    case gamma_overflow:    case gammaf_overflow:    case lgammal_negative:    case lgamma_negative:    case lgammaf_negative:    case gammal_negative:    case gamma_negative:    case gammaf_negative:    case ilogbl_zero:    case ilogb_zero:    case ilogbf_zero:    case fdiml_overflow:    case fdim_overflow:    case fdimf_overflow:    case llrintl_large:    case llrint_large:    case llrintf_large:    case llroundl_large:    case llround_large:    case llroundf_large:    case lrintl_large:    case lrint_large:    case lrintf_large:    case lroundl_large:    case lround_large:    case lroundf_large:    case tandl_overflow:    case tand_overflow:    case tandf_overflow:    case cotdl_overflow:    case cotd_overflow:    case cotdf_overflow:    case cotl_overflow:    case cot_overflow:    case cotf_overflow:    case sinhcoshl_overflow:    case sinhcosh_overflow: