?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(CFLAGS-tst-align.c): Add -mpreferred-stack-boundary=4.
[glibc.git] / sysdeps / ia64 / fpu / libm_error.c
blobebbaad02ad678e07297dff85968e26a207451a1e
1 //
2 // Copyright (C) 2000, 2001, Intel Corporation
3 // All rights reserved.
4 //
5 // Contributed 2/2/2000 by John Harrison, Ted Kubaska, Bob Norin, Shane Story, James
6 // Edwards, and Ping Tak Peter Tang of the Computational Software Lab, Intel Corporation.
7 //
8 // Redistribution and use in source and binary forms, with or without
9 // modification, are permitted provided that the following conditions are
10 // met:
11 //
12 // * Redistributions of source code must retain the above copyright
13 // notice, this list of conditions and the following disclaimer.
14 //
15 // * Redistributions in binary form must reproduce the above copyright
16 // notice, this list of conditions and the following disclaimer in the
17 // documentation and/or other materials provided with the distribution.
18 //
19 // * The name of Intel Corporation may not be used to endorse or promote
20 // products derived from this software without specific prior written
21 // permission.
22 //
23 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS
27 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
28 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
29 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
31 // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING
32 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 //
35 // Intel Corporation is the author of this code, and requests that all
36 // problem reports or change requests be submitted to it directly at
37 // http://developer.intel.com/opensource.
38 //
39 // History
40 //==============================================================
41 // 2/02/00: Initial version
42 // 3/22/00: Updated to support flexible and dynamic error handling.
43 // 8/16/00: Changed all matherr function-calls to use the pmatherr
44 // function-pointers.
45 // 10/03/00: Corrected a scalb type.
46 // 11/28/00: Changed INPUT_XL to INPUT_XD for scalb_underflow case.
47 // 12/07/00: Added code to make scalbn error support equivalent to ldexp.
48 // 2/07/01: Added __declspec(align(16)) to long double constants to correct
49 // alignment problem.
50 //
51
52 #include <errno.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include "libm_support.h"
56
57 #ifndef _LIBC
58 _LIB_VERSION_TYPE
59 #if defined( __POSIX__ )
60 _LIB_VERSION = _POSIX_;
61 #elif defined( __XOPEN__ )
62 _LIB_VERSION = _XOPEN_;
63 #elif defined( __SVID__ )
64 _LIB_VERSION = _SVID_;
65 #elif defined( __IEEE__ )
66 _LIB_VERSION = _IEEE_;
67 #else
68 _LIB_VERSION = _ISOC_;
69 #endif
70 #endif
71
72 /************************************************************/
73 /* matherrX function pointers and setusermatherrX functions */
74 /************************************************************/
75 #if 0
76 int (*pmatherrf)(struct exceptionf*) = MATHERR_F;
77 int (*pmatherr)(struct EXC_DECL_D*) = MATHERR_D;
78 int (*pmatherrl)(struct exceptionl*) = matherrl;
79
80 void __libm_setusermatherrf( int(*user_merrf)(struct exceptionf*) )
81 { pmatherrf = ( (user_merrf==NULL)? (MATHERR_F) : (user_merrf) ); }
82
83 void __libm_setusermatherr( int(*user_merr)(struct EXC_DECL_D*) )
84 { pmatherr = ( (user_merr==NULL)? (MATHERR_D) : (user_merr) ); }
85
86 void __libm_setusermatherrl( int(*user_merrl)(struct exceptionl*) )
87 { pmatherrl = ( (user_merrl==NULL)? (matherrl) : (user_merrl) ); }
88 #endif
89
90 /***********************************************/
91 /* error-handling function, libm_error_support */
92 /***********************************************/
93 void __libm_error_support(void *arg1,void *arg2,void *retval,error_types input_tag)
94 {
95
96
97 # ifdef __cplusplus
98 struct __exception exc;
99 # else
100 struct exception exc;
101 # endif
102
103 struct exceptionf excf;
104 struct exceptionl excl;
105
106 # if defined opensource || defined _LIBC
107 #define ALIGNIT
108 #define ALIGNATTR __attribute__ ((__aligned__ (16)))
109 # else
110 #define ALIGNIT __declspec(align(16))
111 #define ALIGNATTR
112 # endif
113
114 const char float_inf[4] = {0x00,0x00,0x80,0x7F};
115 const char float_huge[4] = {0xFF,0xFF,0x7F,0x7F};
116 const char float_zero[4] = {0x00,0x00,0x00,0x00};
117 const char float_neg_inf[4] = {0x00,0x00,0x80,0xFF};
118 const char float_neg_huge[4] = {0xFF,0xFF,0x7F,0xFF};
119 const char float_neg_zero[4] = {0x00,0x00,0x00,0x80};
120 ALIGNIT
121 const char double_inf[8] ALIGNATTR = {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x7F};
122 ALIGNIT
123 //const char double_huge[8] ALIGNATTR = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0x7F};
124 ALIGNIT
125 const char double_zero[8] ALIGNATTR = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
126 ALIGNIT
127 const char double_neg_inf[8] ALIGNATTR = {0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0xFF};
128 ALIGNIT
129 //const char double_neg_huge[8] ALIGNATTR = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xEF,0xFF};
130 ALIGNIT
131 const char double_neg_zero[8] ALIGNATTR = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80};
132 ALIGNIT
133 const char long_double_inf[16] ALIGNATTR = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x7F,0x00,0x00,0x00,0x00,0x00,0x00};
134 ALIGNIT
135 //const char long_double_huge[16] ALIGNATTR = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x7F,0x00,0x00,0x00,0x00,0x00,0x00};
136 ALIGNIT
137 const char long_double_zero[16] ALIGNATTR = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
138 ALIGNIT
139 const char long_double_neg_inf[16] ALIGNATTR = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00};
140 ALIGNIT
141 //const char long_double_neg_huge[16] ALIGNATTR = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFE,0xFF,0x00,0x00,0x00,0x00,0x00,0x00};
142 ALIGNIT
143 const char long_double_neg_zero[16] ALIGNATTR = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00};
144
145 #define RETVAL_HUGE_VALL *(long double *)retval = *(long double *)long_double_inf
146 #define RETVAL_NEG_HUGE_VALL *(long double *)retval = *(long double *)long_double_neg_inf
147 #define RETVAL_HUGEL *(long double *)retval = (long double)*(float *)float_huge
148 #define RETVAL_NEG_HUGEL *(long double *)retval =(long double)*(float*)float_neg_huge
149
150 #define RETVAL_HUGE_VALD *(double *)retval = *(double *) double_inf
151 #define RETVAL_NEG_HUGE_VALD *(double *)retval = *(double *) double_neg_inf
152 #define RETVAL_HUGED *(double *)retval = (double) *(float *)float_huge
153 #define RETVAL_NEG_HUGED *(double *)retval = (double) *(float *) float_neg_huge
154
155 #define RETVAL_HUGE_VALF *(float *)retval = *(float *) float_inf
156 #define RETVAL_NEG_HUGE_VALF *(float *)retval = *(float *) float_neg_inf
157 #define RETVAL_HUGEF *(float *)retval = *(float *) float_huge
158 #define RETVAL_NEG_HUGEF *(float *)retval = *(float *) float_neg_huge
159
160 #define RETVAL_ZEROL *(long double *)retval = *(long double *)long_double_zero
161 #define RETVAL_ZEROD *(double *)retval = *(double *)double_zero
162 #define RETVAL_ZEROF *(float *)retval = *(float *)float_zero
163
164 #define RETVAL_NEG_ZEROL *(long double *)retval = *(long double *)long_double_neg_zero
165 #define RETVAL_NEG_ZEROD *(double *)retval = *(double *)double_neg_zero
166 #define RETVAL_NEG_ZEROF *(float *)retval = *(float *)float_neg_zero
167
168 #define RETVAL_ONEL *(long double *)retval = (long double) 1.0
169 #define RETVAL_ONED *(double *)retval = 1.0
170 #define RETVAL_ONEF *(float *)retval = 1.0f
171
172 #define NOT_MATHERRL excl.arg1=*(long double *)arg1;excl.arg2=*(long double *)arg2;excl.retval=*(long double *)retval;if(!matherrl(&excl))
173 #define NOT_MATHERRD exc.arg1=*(double *)arg1;exc.arg2=*(double *)arg2;exc.retval=*(double *)retval;if(!MATHERR_D(&exc))
174 #define NOT_MATHERRF excf.arg1=*(float *)arg1;excf.arg2=*(float *)arg2;excf.retval=*(float *)retval;if(!MATHERR_F(&excf))
175
176 #define ifSVID if(_LIB_VERSION==_SVID_)
177
178 #define NAMEL excl.name
179 #define NAMED exc.name
180 #define NAMEF excf.name
181
182 //
183 // These should work OK for MS because they are ints -
184 // leading underbars are not necessary.
185 //
186
187 #define DOMAIN 1
188 #define SING 2
189 #define OVERFLOW 3
190 #define UNDERFLOW 4
191 #define TLOSS 5
192 #define PLOSS 6
193
194 #define SINGL excl.type = SING
195 #define DOMAINL excl.type = DOMAIN
196 #define OVERFLOWL excl.type = OVERFLOW
197 #define UNDERFLOWL excl.type = UNDERFLOW
198 #define TLOSSL excl.type = TLOSS
199 #define SINGD exc.type = SING
200 #define DOMAIND exc.type = DOMAIN
201 #define OVERFLOWD exc.type = OVERFLOW
202 #define UNDERFLOWD exc.type = UNDERFLOW
203 #define TLOSSD exc.type = TLOSS
204 #define SINGF excf.type = SING
205 #define DOMAINF excf.type = DOMAIN
206 #define OVERFLOWF excf.type = OVERFLOW
207 #define UNDERFLOWF excf.type = UNDERFLOW
208 #define TLOSSF excf.type = TLOSS
209
210 #define INPUT_XL (excl.arg1=*(long double*)arg1)
211 #define INPUT_XD (exc.arg1=*(double*)arg1)
212 #define INPUT_XF (excf.arg1=*(float*)arg1)
213 #define INPUT_YL (excl.arg1=*(long double*)arg2)
214 #define INPUT_YD (exc.arg1=*(double*)arg2)
215 #define INPUT_YF (excf.arg1=*(float*)arg2)
216 #define INPUT_RESL (*(long double *)retval)
217 #define INPUT_RESD (*(double *)retval)
218 #define INPUT_RESF (*(float *)retval)
219
220 #define WRITEL_LOG_ZERO fputs("logl: SING error\n",stderr)
221 #define WRITED_LOG_ZERO fputs("log: SING error\n",stderr)
222 #define WRITEF_LOG_ZERO fputs("logf: SING error\n",stderr)
223 #define WRITEL_LOG_NEGATIVE fputs("logl: DOMAIN error\n",stderr)
224 #define WRITED_LOG_NEGATIVE fputs("log: DOMAIN error\n",stderr)
225 #define WRITEF_LOG_NEGATIVE fputs("logf: DOMAIN error\n",stderr)
226 #define WRITEL_Y0_ZERO fputs("y0l: DOMAIN error\n",stderr)
227 #define WRITED_Y0_ZERO fputs("y0: DOMAIN error\n",stderr)
228 #define WRITEF_Y0_ZERO fputs("y0f: DOMAIN error\n",stderr)
229 #define WRITEL_Y0_NEGATIVE fputs("y0l: DOMAIN error\n",stderr)
230 #define WRITED_Y0_NEGATIVE fputs("y0: DOMAIN error\n",stderr)
231 #define WRITEF_Y0_NEGATIVE fputs("y0f: DOMAIN error\n",stderr)
232 #define WRITEL_Y1_ZERO fputs("y1l: DOMAIN error\n",stderr)
233 #define WRITED_Y1_ZERO fputs("y1: DOMAIN error\n",stderr)
234 #define WRITEF_Y1_ZERO fputs("y1f: DOMAIN error\n",stderr)
235 #define WRITEL_Y1_NEGATIVE fputs("y1l: DOMAIN error\n",stderr)
236 #define WRITED_Y1_NEGATIUE fputs("y1: DOMAIN error\n",stderr)
237 #define WRITEF_Y1_NEGATIVE fputs("y1f: DOMAIN error\n",stderr)
238 #define WRITEL_YN_ZERO fputs("ynl: DOMAIN error\n",stderr)
239 #define WRITED_YN_ZERO fputs("yn: DOMAIN error\n",stderr)
240 #define WRITEF_YN_ZERO fputs("ynf: DOMAIN error\n",stderr)
241 #define WRITEL_YN_NEGATIVE fputs("ynl: DOMAIN error\n",stderr)
242 #define WRITED_YN_NEGATIVE fputs("yn: DOMAIN error\n",stderr)
243 #define WRITEF_YN_NEGATIVE fputs("ynf: DOMAIN error\n",stderr)
244 #define WRITEL_LOG1P_ZERO fputs("log1pl: SING error\n",stderr)
245 #define WRITED_LOG1P_ZERO fputs("log1p: SING error\n",stderr)
246 #define WRITEF_LOG1P_ZERO fputs("log1pf: SING error\n",stderr)
247 #define WRITEL_LOG1P_NEGATIVE fputs("log1pl: DOMAIN error\n",stderr)
248 #define WRITED_LOG1P_NEGATIVE fputs("log1p: DOMAIN error\n",stderr)
249 #define WRITEF_LOG1P_NEGATIVE fputs("log1pf: DOMAIN error\n",stderr)
250 #define WRITEL_LOG10_ZERO fputs("log10l: SING error\n",stderr)
251 #define WRITED_LOG10_ZERO fputs("log10: SING error\n",stderr)
252 #define WRITEF_LOG10_ZERO fputs("log10f: SING error\n",stderr)
253 #define WRITEL_LOG10_NEGATIVE fputs("log10l: DOMAIN error\n",stderr)
254 #define WRITED_LOG10_NEGATIVE fputs("log10: DOMAIN error\n",stderr)
255 #define WRITEF_LOG10_NEGATIVE fputs("log10f: DOMAIN error\n",stderr)
256 #define WRITEL_POW_ZERO_TO_ZERO fputs("powl(0,0): DOMAIN error\n",stderr)
257 #define WRITED_POW_ZERO_TO_ZERO fputs("pow(0,0): DOMAIN error\n",stderr)
258 #define WRITEF_POW_ZERO_TO_ZERO fputs("powf(0,0): DOMAIN error\n",stderr)
259 #define WRITEL_POW_ZERO_TO_NEGATIVE fputs("powl(0,negative): DOMAIN error\n",stderr)
260 #define WRITED_POW_ZERO_TO_NEGATIVE fputs("pow(0,negative): DOMAIN error\n",stderr)
261 #define WRITEF_POW_ZERO_TO_NEGATIVE fputs("powf(0,negative): DOMAIN error\n",stderr)
262 #define WRITEL_POW_NEG_TO_NON_INTEGER fputs("powl(negative,non-integer): DOMAIN error\n",stderr)
263 #define WRITED_POW_NEG_TO_NON_INTEGER fputs("pow(negative,non-integer): DOMAIN error\n",stderr)
264 #define WRITEF_POW_NEG_TO_NON_INTEGER fputs("powf(negative,non-integer): DOMAIN error\n",stderr)
265 #define WRITEL_ATAN2_ZERO_BY_ZERO fputs("atan2l: DOMAIN error\n",stderr)
266 #define WRITED_ATAN2_ZERO_BY_ZERO fputs("atan2: DOMAIN error\n",stderr)
267 #define WRITEF_ATAN2_ZERO_BY_ZERO fputs("atan2f: DOMAIN error\n",stderr)
268 #define WRITEL_SQRT fputs("sqrtl: DOMAIN error\n",stderr)
269 #define WRITED_SQRT fputs("sqrt: DOMAIN error\n",stderr)
270 #define WRITEF_SQRT fputs("sqrtf: DOMAIN error\n",stderr)
271 #define WRITEL_FMOD fputs("fmodl: DOMAIN error\n",stderr)
272 #define WRITED_FMOD fputs("fmod: DOMAIN error\n",stderr)
273 #define WRITEF_FMOD fputs("fmodf: DOMAIN error\n",stderr)
274 #define WRITEL_REM fputs("remainderl: DOMAIN error\n",stderr)
275 #define WRITED_REM fputs("remainder: DOMAIN error\n",stderr)
276 #define WRITEF_REM fputs("remainderf: DOMAIN error\n",stderr)
277 #define WRITEL_ACOS fputs("acosl: DOMAIN error\n",stderr)
278 #define WRITED_ACOS fputs("acos: DOMAIN error\n",stderr)
279 #define WRITEF_ACOS fputs("acosf: DOMAIN error\n",stderr)
280 #define WRITEL_ASIN fputs("asinl: DOMAIN error\n",stderr)
281 #define WRITED_ASIN fputs("asin: DOMAIN error\n",stderr)
282 #define WRITEF_ASIN fputs("asinf: DOMAIN error\n",stderr)
283 #define WRITEL_ACOSH fputs("acoshl: DOMAIN error\n",stderr)
284 #define WRITED_ACOSH fputs("acosh: DOMAIN error\n",stderr)
285 #define WRITEF_ACOSH fputs("acoshf: DOMAIN error\n",stderr)
286 #define WRITEL_ATANH_GT_ONE fputs("atanhl: DOMAIN error\n",stderr)
287 #define WRITED_ATANH_GT_ONE fputs("atanh: DOMAIN error\n",stderr)
288 #define WRITEF_ATANH_GT_ONE fputs("atanhf: DOMAIN error\n",stderr)
289 #define WRITEL_ATANH_EQ_ONE fputs("atanhl: SING error\n",stderr)
290 #define WRITED_ATANH_EQ_ONE fputs("atanh: SING error\n",stderr)
291 #define WRITEF_ATANH_EQ_ONE fputs("atanhf: SING error\n",stderr)
292 #define WRITEL_LGAMMA_NEGATIVE fputs("lgammal: SING error\n",stderr)
293 #define WRITED_LGAMMA_NEGATIVE fputs("lgamma: SING error\n",stderr)
294 #define WRITEF_LGAMMA_NEGATIVE fputs("lgammaf: SING error\n",stderr)
295 #define WRITEL_GAMMA_NEGATIVE fputs("gammal: SING error\n",stderr)
296 #define WRITED_GAMMA_NEGATIVE fputs("gamma: SING error\n",stderr)
297 #define WRITEF_GAMMA_NEGATIVE fputs("gammaf: SING error\n",stderr)
298 #define WRITEL_J0_TLOSS fputs("j0l: TLOSS error\n",stderr)
299 #define WRITEL_Y0_TLOSS fputs("y0l: TLOSS error\n",stderr)
300 #define WRITEL_J1_TLOSS fputs("j1l: TLOSS error\n",stderr)
301 #define WRITEL_Y1_TLOSS fputs("y1l: TLOSS error\n",stderr)
302 #define WRITEL_JN_TLOSS fputs("jnl: TLOSS error\n",stderr)
303 #define WRITEL_YN_TLOSS fputs("ynl: TLOSS error\n",stderr)
304 #define WRITED_J0_TLOSS fputs("j0: TLOSS error\n",stderr)
305 #define WRITED_Y0_TLOSS fputs("y0: TLOSS error\n",stderr)
306 #define WRITED_J1_TLOSS fputs("j1: TLOSS error\n",stderr)
307 #define WRITED_Y1_TLOSS fputs("y1: TLOSS error\n",stderr)
308 #define WRITED_JN_TLOSS fputs("jn: TLOSS error\n",stderr)
309 #define WRITED_YN_TLOSS fputs("yn: TLOSS error\n",stderr)
310 #define WRITEF_J0_TLOSS fputs("j0f: TLOSS error\n",stderr)
311 #define WRITEF_Y0_TLOSS fputs("y0f: TLOSS error\n",stderr)
312 #define WRITEF_J1_TLOSS fputs("j1f: TLOSS error\n",stderr)
313 #define WRITEF_Y1_TLOSS fputs("y1f: TLOSS error\n",stderr)
314 #define WRITEF_JN_TLOSS fputs("jnf: TLOSS error\n",stderr)
315 #define WRITEF_YN_TLOSS fputs("ynf: TLOSS error\n",stderr)
316
317 /***********************/
318 /* IEEE Path */
319 /***********************/
320 if(_LIB_VERSION==_IEEE_) return;
321
322 /***********************/
323 /* C9X Path */
324 /***********************/
325 else if(_LIB_VERSION==_ISOC_)
326 {
327 switch(input_tag)
328 {
329 case logl_zero:
330 case log_zero:
331 case logf_zero:
332 case log10l_zero:
333 case log10_zero:
334 case log10f_zero:
335 case log2l_zero:
336 case log2_zero:
337 case log2f_zero:
338 case log1pl_zero:
339 case log1p_zero:
340 case log1pf_zero:
341 case powl_overflow:
342 case pow_overflow:
343 case powf_overflow:
344 case powl_underflow:
345 case pow_underflow:
346 case powf_underflow:
347 case expl_overflow:
348 case exp_overflow:
349 case expf_overflow:
350 case expl_underflow:
351 case exp_underflow:
352 case expf_underflow:
353 case exp2l_overflow:
354 case exp2_overflow:
355 case exp2f_overflow:
356 case exp2l_underflow:
357 case exp2_underflow:
358 case exp2f_underflow:
359 case exp10l_overflow:
360 case exp10_overflow:
361 case exp10f_overflow:
362 case expm1l_overflow:
363 case expm1_overflow:
364 case expm1f_overflow:
365 case hypotl_overflow:
366 case hypot_overflow:
367 case hypotf_overflow:
368 case sinhl_overflow:
369 case sinh_overflow:
370 case sinhf_overflow:
371 case atanhl_eq_one:
372 case atanh_eq_one:
373 case atanhf_eq_one:
374 case scalbl_overflow:
375 case scalb_overflow:
376 case scalbf_overflow:
377 case scalbl_underflow:
378 case scalb_underflow:
379 case scalbf_underflow:
380 case coshl_overflow:
381 case cosh_overflow:
382 case coshf_overflow:
383 case nextafterl_overflow:
384 case nextafter_overflow:
385 case nextafterf_overflow:
386 case scalbnl_overflow:
387 case scalbn_overflow:
388 case scalbnf_overflow:
389 case scalbnl_underflow:
390 case scalbn_underflow:
391 case scalbnf_underflow:
392 case ldexpl_overflow:
393 case ldexp_overflow:
394 case ldexpf_overflow:
395 case ldexpl_underflow:
396 case ldexp_underflow:
397 case ldexpf_underflow:
398 case lgammal_overflow:
399 case lgamma_overflow:
400 case lgammaf_overflow:
401 case lgammal_negative:
402 case lgamma_negative:
403 case lgammaf_negative:
404 case gammal_overflow:
405 case gamma_overflow:
406 case gammaf_overflow:
407 case gammal_negative:
408 case gamma_negative:
409 case gammaf_negative:
410 case ilogbl_zero:
411 case ilogb_zero:
412 case ilogbf_zero:
413 {
414 ERRNO_RANGE; break;
415 }
416 case logl_negative:
417 case log_negative:
418 case logf_negative:
419 case log10l_negative:
420 case log10_negative:
421 case log10f_negative:
422 case log2l_negative:
423 case log2_negative:
424 case log2f_negative:
425 case log1pl_negative:
426 case log1p_negative:
427 case log1pf_negative:
428 case sqrtl_negative:
429 case sqrt_negative:
430 case sqrtf_negative:
431 case atan2l_zero:
432 case atan2_zero:
433 case atan2f_zero:
434 case powl_zero_to_negative:
435 case powl_neg_to_non_integer:
436 case pow_zero_to_negative:
437 case pow_neg_to_non_integer:
438 case powf_zero_to_negative:
439 case powf_neg_to_non_integer:
440 case fmodl_by_zero:
441 case fmod_by_zero:
442 case fmodf_by_zero:
443 case atanhl_gt_one:
444 case atanh_gt_one:
445 case atanhf_gt_one:
446 case acosl_gt_one:
447 case acos_gt_one:
448 case acosf_gt_one:
449 case asinl_gt_one:
450 case asin_gt_one:
451 case asinf_gt_one:
452 case logbl_zero:
453 case logb_zero:
454 case logbf_zero:
455 case acoshl_lt_one:
456 case acosh_lt_one:
457 case acoshf_lt_one:
458 case y0l_zero:
459 case y0_zero:
460 case y0f_zero:
461 case y1l_zero:
462 case y1_zero:
463 case y1f_zero:
464 case ynl_zero:
465 case yn_zero:
466 case ynf_zero:
467 case y0l_negative:
468 case y0_negative:
469 case y0f_negative:
470 case y1l_negative:
471 case y1_negative:
472 case y1f_negative:
473 case ynl_negative:
474 case yn_negative:
475 case ynf_negative:
476 {
477 ERRNO_DOMAIN; break;
478 }
479 default:
480 abort();
481 }
482 return;
483 }
484
485 /***********************/
486 /* _POSIX_ Path */
487 /***********************/
488
489 else if(_LIB_VERSION==_POSIX_)
490 {
491 switch(input_tag)
492 {
493 case gammal_overflow:
494 case lgammal_overflow:
495 {
496 RETVAL_HUGE_VALL; ERRNO_RANGE; break;
497 }
498 case gamma_overflow:
499 case lgamma_overflow:
500 {
501 RETVAL_HUGE_VALD; ERRNO_RANGE; break;
502 }
503 case gammaf_overflow:
504 case lgammaf_overflow:
505 {
506 RETVAL_HUGE_VALF; ERRNO_RANGE; break;
507 }
508 case gammal_negative:
509 case gamma_negative:
510 case gammaf_negative:
511 case lgammal_negative:
512 case lgamma_negative:
513 case lgammaf_negative:
514 {
515 ERRNO_DOMAIN; break;
516 }
517 case ldexpl_overflow:
518 case ldexpl_underflow:
519 case ldexp_overflow:
520 case ldexp_underflow:
521 case ldexpf_overflow:
522 case ldexpf_underflow:
523 case scalbnl_overflow:
524 case scalbnl_underflow:
525 case scalbn_overflow:
526 case scalbn_underflow:
527 case scalbnf_overflow:
528 case scalbnf_underflow:
529 {
530 ERRNO_RANGE; break;
531 }
532 case atanhl_gt_one:
533 case atanhl_eq_one:
534 /* atanhl(|x| >= 1) */
535 {
536 ERRNO_DOMAIN; break;
537 }
538 case atanh_gt_one:
539 case atanh_eq_one:
540 /* atanh(|x| >= 1) */
541 {
542 ERRNO_DOMAIN; break;
543 }
544 case atanhf_gt_one:
545 case atanhf_eq_one:
546 /* atanhf(|x| >= 1) */
547 {
548 ERRNO_DOMAIN; break;
549 }
550 case sqrtl_negative:
551 /* sqrtl(x < 0) */
552 {
553 ERRNO_DOMAIN; break;
554 }
555 case sqrt_negative:
556 /* sqrt(x < 0) */
557 {
558 ERRNO_DOMAIN; break;
559 }
560 case sqrtf_negative:
561 /* sqrtf(x < 0) */
562 {
563 ERRNO_DOMAIN; break;
564 }
565 case y0l_zero:
566 case y1l_zero:
567 case ynl_zero:
568 /* y0l(0) */
569 /* y1l(0) */
570 /* ynl(0) */
571 {
572 RETVAL_NEG_HUGE_VALL; ERRNO_DOMAIN; break;
573 }
574 case y0_zero:
575 case y1_zero:
576 case yn_zero:
577 /* y0(0) */
578 /* y1(0) */
579 /* yn(0) */
580 {
581 RETVAL_NEG_HUGE_VALD; ERRNO_DOMAIN; break;
582 }
583 case y0f_zero:
584 case y1f_zero:
585 case ynf_zero:
586 /* y0f(0) */
587 /* y1f(0) */
588 /* ynf(0) */
589 {
590 RETVAL_NEG_HUGE_VALF; ERRNO_DOMAIN; break;
591 }
592 case y0l_negative:
593 case y1l_negative:
594 case ynl_negative:
595 /* y0l(x < 0) */
596 /* y1l(x < 0) */
597 /* ynl(x < 0) */
598 {
599 RETVAL_NEG_HUGE_VALL; ERRNO_DOMAIN; break;
600 }
601 case y0_negative:
602 case y1_negative:
603 case yn_negative:
604 /* y0(x < 0) */
605 /* y1(x < 0) */
606 /* yn(x < 0) */
607 {
608 RETVAL_NEG_HUGE_VALD; ERRNO_DOMAIN; break;
609 }
610 case y0f_negative:
611 case y1f_negative:
612 case ynf_negative:
613 /* y0f(x < 0) */
614 /* y1f(x < 0) */
615 /* ynf(x < 0) */
616 {
617 RETVAL_NEG_HUGE_VALF; ERRNO_DOMAIN; break;
618 }
619 case logl_zero:
620 case log1pl_zero:
621 case log10l_zero:
622 /* logl(0) */
623 /* log1pl(0) */
624 /* log10l(0) */
625 {
626 RETVAL_NEG_HUGE_VALL; ERRNO_RANGE; break;
627 }
628 case log_zero:
629 case log1p_zero:
630 case log10_zero:
631 case log2l_zero:
632 /* log(0) */
633 /* log1p(0) */
634 /* log10(0) */
635 {
636 RETVAL_NEG_HUGE_VALD; ERRNO_RANGE; break;
637 }
638 case logf_zero:
639 case log1pf_zero:
640 case log10f_zero:
641 /* logf(0) */
642 /* log1pf(0) */
643 /* log10f(0) */
644 {
645 RETVAL_NEG_HUGE_VALF; ERRNO_RANGE; break;
646 }
647 case logl_negative:
648 case log1pl_negative:
649 case log10l_negative:
650 case log2l_negative:
651 /* logl(x < 0) */
652 /* log1pl(x < 0) */
653 /* log10l(x < 0) */
654 {
655 ERRNO_DOMAIN; break;
656 }
657 case log_negative:
658 case log1p_negative:
659 case log10_negative:
660 case log2_negative:
661 /* log(x < 0) */
662 /* log1p(x < 0) */
663 /* log10(x < 0) */
664 {
665 ERRNO_DOMAIN; break;
666 }
667 case logf_negative:
668 case log1pf_negative:
669 case log10f_negative:
670 case log2f_negative:
671 /* logf(x < 0) */
672 /* log1pf(x < 0) */
673 /* log10f(x < 0) */
674 {
675 ERRNO_DOMAIN; break;
676 }
677 case expl_overflow:
678 /* expl overflow */
679 {
680 RETVAL_HUGE_VALL; ERRNO_RANGE; break;
681 }
682 case exp_overflow:
683 /* exp overflow */
684 {
685 RETVAL_HUGE_VALD; ERRNO_RANGE; break;
686 }
687 case expf_overflow:
688 /* expf overflow */
689 {
690 RETVAL_HUGE_VALF; ERRNO_RANGE; break;
691 }
692 case expl_underflow:
693 /* expl underflow */
694 {
695 RETVAL_ZEROL; ERRNO_RANGE; break;
696 }
697 case exp_underflow:
698 /* exp underflow */
699 {
700 RETVAL_ZEROD; ERRNO_RANGE; break;
701 }
702 case expf_underflow:
703 /* expf underflow */
704 {
705 RETVAL_ZEROF; ERRNO_RANGE; break;
706 }
707 case j0l_gt_loss:
708 case y0l_gt_loss:
709 case j1l_gt_loss:
710 case y1l_gt_loss:
711 case jnl_gt_loss:
712 case ynl_gt_loss:
713 /* jn and yn doubl-extended> XLOSS */
714 {
715 RETVAL_ZEROL; ERRNO_RANGE; break;
716 }
717 case j0_gt_loss:
718 case y0_gt_loss:
719 case j1_gt_loss:
720 case y1_gt_loss:
721 case jn_gt_loss:
722 case yn_gt_loss:
723 /* jn and yn double > XLOSS */
724 {
725 RETVAL_ZEROD; ERRNO_RANGE; break;
726 }
727 case j0f_gt_loss:
728 case y0f_gt_loss:
729 case j1f_gt_loss:
730 case y1f_gt_loss:
731 case jnf_gt_loss:
732 case ynf_gt_loss:
733 /* j0n and y0n > XLOSS */
734 {
735 RETVAL_ZEROF; ERRNO_RANGE; break;
736 }
737 case powl_zero_to_zero:
738 /* powl 0**0 */
739 {
740 break;
741 }
742 case pow_zero_to_zero:
743 /* pow 0**0 */
744 {
745 break;
746 }
747 case powf_zero_to_zero:
748 /* powf 0**0 */
749 {
750 break;
751 }
752 case powl_overflow:
753 /* powl(x,y) overflow */
754 {
755 if (INPUT_RESL < 0) RETVAL_NEG_HUGE_VALL;
756 else RETVAL_HUGE_VALL;
757 ERRNO_RANGE; break;
758 }
759 case pow_overflow:
760 /* pow(x,y) overflow */
761 {
762 if (INPUT_RESD < 0) RETVAL_NEG_HUGE_VALD;
763 else RETVAL_HUGE_VALD;
764 ERRNO_RANGE; break;
765 }
766 case powf_overflow:
767 /* powf(x,y) overflow */
768 {
769 if (INPUT_RESF < 0) RETVAL_NEG_HUGE_VALF;
770 else RETVAL_HUGE_VALF;
771 ERRNO_RANGE; break;
772 }
773 case powl_underflow:
774 /* powl(x,y) underflow */
775 {
776 RETVAL_ZEROL; ERRNO_RANGE; break;
777 }
778 case pow_underflow:
779 /* pow(x,y) underflow */
780 {
781 RETVAL_ZEROD; ERRNO_RANGE; break;
782 }
783 case powf_underflow:
784 /* powf(x,y) underflow */
785 {
786 RETVAL_ZEROF; ERRNO_RANGE; break;
787 }
788 case powl_zero_to_negative:
789 /* 0**neg */
790 {
791 ERRNO_DOMAIN; break;
792 }
793 case pow_zero_to_negative:
794 /* 0**neg */
795 {
796 ERRNO_DOMAIN; break;
797 }
798 case powf_zero_to_negative:
799 /* 0**neg */
800 {
801 ERRNO_DOMAIN; break;
802 }
803 case powl_neg_to_non_integer:
804 /* neg**non_integral */
805 {
806 ERRNO_DOMAIN; break;
807 }
808 case pow_neg_to_non_integer:
809 /* neg**non_integral */
810 {
811 ERRNO_DOMAIN; break;
812 }
813 case powf_neg_to_non_integer:
814 /* neg**non-integral */
815 {
816 ERRNO_DOMAIN; break;
817 }
818 case powl_nan_to_zero:
819 /* powl(NaN,0.0) */
820 /* Special Error */
821 {
822 break;
823 }
824 case pow_nan_to_zero:
825 /* pow(NaN,0.0) */
826 {
827 break;
828 }
829 case powf_nan_to_zero:
830 /* powf(NaN,0.0) */
831 {
832 break;
833 }
834 case atan2l_zero:
835 /* atan2l(0,0) */
836 {
837 /* XXX arg1 and arg2 are switched!!!! */
838 if (signbit (*(long double *) arg1))
839 /* y == -0 */
840 *(long double *) retval = copysignl (M_PIl, *(long double *) arg2);
841 else
842 *(long double *) retval = *(long double *) arg2;
843 ERRNO_DOMAIN; break;
844 }
845 case atan2_zero:
846 /* atan2(0,0) */
847 {
848 /* XXX arg1 and arg2 are switched!!!! */
849 if (signbit (*(double *) arg1))
850 /* y == -0 */
851 *(double *) retval = copysign (M_PI, *(double *) arg2);
852 else
853 *(double *) retval = *(double *) arg2;
854 ERRNO_DOMAIN; break;
855 }
856 case
857 atan2f_zero:
858 /* atan2f(0,0) */
859 {
860 if (signbit (*(float *) arg2))
861 /* y == -0 */
862 *(float *) retval = copysignf (M_PI, *(float *) arg1);
863 else
864 *(float *) retval = *(float *) arg1;
865 ERRNO_DOMAIN; break;
866 }
867 case expm1l_overflow:
868 /* expm1 overflow */
869 {
870 ERRNO_RANGE; break;
871 }
872 case expm1_overflow:
873 /* expm1 overflow */
874 {
875 ERRNO_RANGE; break;
876 }
877 case expm1f_overflow:
878 /* expm1f overflow */
879 {
880 ERRNO_RANGE; break;
881 }
882 case expm1l_underflow:
883 /* expm1 underflow */
884 {
885 ERRNO_RANGE; break;
886 }
887 case expm1_underflow:
888 /* expm1 underflow */
889 {
890 ERRNO_RANGE; break;
891 }
892 case expm1f_underflow:
893 /* expm1f underflow */
894 {
895 ERRNO_RANGE; break;
896 }
897 case hypotl_overflow:
898 /* hypotl overflow */
899 {
900 RETVAL_HUGE_VALL; ERRNO_RANGE; break;
901 }
902 case hypot_overflow:
903 /* hypot overflow */
904 {
905 RETVAL_HUGE_VALD; ERRNO_RANGE; break;
906 }
907 case hypotf_overflow:
908 /* hypotf overflow */
909 {
910 RETVAL_HUGE_VALF; ERRNO_RANGE; break;
911 }
912 case scalbl_underflow:
913 /* scalbl underflow */
914 {
915 if (INPUT_XL < 0) RETVAL_NEG_ZEROL;
916 else RETVAL_ZEROL;
917 ERRNO_RANGE; break;
918 }
919 case scalb_underflow:
920 /* scalb underflow */
921 {
922 if (INPUT_XD < 0) RETVAL_NEG_ZEROD;
923 else RETVAL_ZEROD;
924 ERRNO_RANGE; break;
925 }
926 case scalbf_underflow:
927 /* scalbf underflow */
928 {
929 if (INPUT_XF < 0) RETVAL_NEG_ZEROF;
930 else RETVAL_ZEROF;
931 ERRNO_RANGE; break;
932 }
933 case scalbl_overflow:
934 /* scalbl overflow */
935 {
936 if (INPUT_XL < 0) RETVAL_NEG_HUGE_VALL;
937 else RETVAL_HUGE_VALL;
938 ERRNO_RANGE; break;
939 }
940 case scalb_overflow:
941 /* scalb overflow */
942 {
943 if (INPUT_XD < 0) RETVAL_NEG_HUGE_VALD;
944 else RETVAL_HUGE_VALD;
945 ERRNO_RANGE; break;
946 }
947 case scalbf_overflow:
948 /* scalbf overflow */
949 {
950 if (INPUT_XF < 0) RETVAL_NEG_HUGE_VALF;
951 else RETVAL_HUGE_VALF;
952 ERRNO_RANGE; break;
953 }
954 case acoshl_lt_one:
955 /* acoshl(x < 1) */
956 {
957 ERRNO_DOMAIN; break;
958 }
959 case acosh_lt_one:
960 /* acosh(x < 1) */
961 {
962 ERRNO_DOMAIN; break;
963 }
964 case acoshf_lt_one:
965 /* acoshf(x < 1) */
966 {
967 ERRNO_DOMAIN; break;
968 }
969 case acosl_gt_one:
970 /* acosl(x > 1) */
971 {
972 ERRNO_DOMAIN; break;
973 }
974 case acos_gt_one:
975 /* acos(x > 1) */
976 {
977 ERRNO_DOMAIN; break;
978 }
979 case acosf_gt_one:
980 /* acosf(x > 1) */
981 {
982 ERRNO_DOMAIN; break;
983 }
984 case asinl_gt_one:
985 /* asinl(x > 1) */
986 {
987 ERRNO_DOMAIN; break;
988 }
989 case asin_gt_one:
990 /* asin(x > 1) */
991 {
992 ERRNO_DOMAIN; break;
993 }
994 case asinf_gt_one:
995 /* asinf(x > 1) */
996 {
997 ERRNO_DOMAIN; break;
998 }
999 case remainderl_by_zero:
1000 case fmodl_by_zero:
1001 /* fmodl(x,0) */
1002 {
1003 ERRNO_DOMAIN; break;
1004 }
1005 case remainder_by_zero:
1006 case fmod_by_zero:
1007 /* fmod(x,0) */
1008 {
1009 ERRNO_DOMAIN; break;
1010 }
1011 case remainderf_by_zero:
1012 case fmodf_by_zero:
1013 /* fmodf(x,0) */
1014 {
1015 ERRNO_DOMAIN; break;
1016 }
1017 case coshl_overflow:
1018 /* coshl overflows */
1019 {
1020 RETVAL_HUGE_VALL; ERRNO_RANGE; break;
1021 }
1022 case cosh_overflow:
1023 /* cosh overflows */
1024 {
1025 RETVAL_HUGE_VALD; ERRNO_RANGE; break;
1026 }
1027 case coshf_overflow:
1028 /* coshf overflows */
1029 {
1030 RETVAL_HUGE_VALF; ERRNO_RANGE; break;
1031 }
1032 case sinhl_overflow:
1033 /* sinhl overflows */
1034 {
1035 if (INPUT_XL > 0) RETVAL_HUGE_VALL;
1036 else RETVAL_NEG_HUGE_VALL;
1037 ERRNO_RANGE; break;
1038 }
1039 case sinh_overflow:
1040 /* sinh overflows */
1041 {
1042 if (INPUT_XD > 0) RETVAL_HUGE_VALD;
1043 else RETVAL_NEG_HUGE_VALD;
1044 ERRNO_RANGE; break;
1045 }
1046 case sinhf_overflow:
1047 /* sinhf overflows */
1048 {
1049 if (INPUT_XF > 0) RETVAL_HUGE_VALF;
1050 else RETVAL_NEG_HUGE_VALF;
1051 ERRNO_RANGE; break;
1052 }
1053 case logbl_zero:
1054 /* logbl(0) */
1055 {
1056 ERRNO_DOMAIN; break;
1057 }
1058 case logb_zero:
1059 /* logb(0) */
1060 {
1061 ERRNO_DOMAIN; break;
1062 }
1063 case logbf_zero:
1064 /* logbf(0) */
1065 {
1066 ERRNO_DOMAIN; break;
1067 }
1068 case ilogbl_zero:
1069 /* ilogbl(0) */
1070 {
1071 ERRNO_RANGE; break;
1072 }
1073 case ilogb_zero:
1074 /* ilogb(0) */
1075 {
1076 ERRNO_RANGE; break;
1077 }
1078 case ilogbf_zero:
1079 /* ilogbf(0) */
1080 {
1081 ERRNO_RANGE; break;
1082 }
1083 default:
1084 abort();
1085 }
1086 return;
1087 /* _POSIX_ */
1088 }
1089
1090 /*******************************/
1091 /* __SVID__ and __XOPEN__ Path */
1092 /*******************************/
1093 else
1094 {
1095 switch(input_tag)
1096 {
1097 case ldexpl_overflow:
1098 case ldexpl_underflow:
1099 case ldexp_overflow:
1100 case ldexp_underflow:
1101 case ldexpf_overflow:
1102 case ldexpf_underflow:
1103 case scalbnl_overflow:
1104 case scalbnl_underflow:
1105 case scalbn_overflow:
1106 case scalbn_underflow:
1107 case scalbnf_overflow:
1108 case scalbnf_underflow:
1109 {
1110 ERRNO_RANGE; break;
1111 }
1112 case sqrtl_negative:
1113 /* sqrtl(x < 0) */
1114 {
1115 DOMAINL; NAMEL = (char *) "sqrtl";
1116 ifSVID
1117 {
1118 RETVAL_ZEROL;
1119 NOT_MATHERRL
1120 {
1121 WRITEL_SQRT;
1122 ERRNO_DOMAIN;
1123 }
1124 }
1125 else
1126 { /* NaN already computed */
1127 NOT_MATHERRL {ERRNO_DOMAIN;}
1128 }
1129 *(long double *)retval = excl.retval;
1130 break;
1131 }
1132 case sqrt_negative:
1133 /* sqrt(x < 0) */
1134 {
1135 DOMAIND; NAMED = (char *) "sqrt";
1136 ifSVID
1137 {
1138
1139 RETVAL_ZEROD;
1140 NOT_MATHERRD
1141 {
1142 WRITED_SQRT;
1143 ERRNO_DOMAIN;
1144 }
1145 }
1146 else
1147 { /* NaN already computed */
1148 NOT_MATHERRD {ERRNO_DOMAIN;}
1149 }
1150 *(double *)retval = exc.retval;
1151 break;
1152 }
1153 case sqrtf_negative:
1154 /* sqrtf(x < 0) */
1155 {
1156 DOMAINF; NAMEF = (char *) "sqrtf";
1157 ifSVID
1158 {
1159 RETVAL_ZEROF;
1160 NOT_MATHERRF
1161 {
1162 WRITEF_SQRT;
1163 ERRNO_DOMAIN;
1164 }
1165 }
1166 else
1167 {
1168 NOT_MATHERRF {ERRNO_DOMAIN;}
1169 }
1170 *(float *)retval = excf.retval;
1171 break;
1172 }
1173 case logl_zero:
1174 case log2l_zero:
1175 /* logl(0) */
1176 {
1177 SINGL; NAMEL = (char *) "logl";
1178 ifSVID
1179 {
1180 RETVAL_NEG_HUGEL;
1181 NOT_MATHERRL
1182 {
1183 WRITEL_LOG_ZERO;
1184 ERRNO_DOMAIN;
1185 }
1186 }
1187 else
1188 {
1189 RETVAL_NEG_HUGE_VALL;
1190 NOT_MATHERRL {ERRNO_DOMAIN;}
1191 }
1192 *(long double *)retval = excl.retval;
1193 break;
1194 }
1195 case log_zero:
1196 case log2_zero:
1197 /* log(0) */
1198 {
1199 SINGD; NAMED = (char *) "log";
1200 ifSVID
1201 {
1202 RETVAL_NEG_HUGED;
1203 NOT_MATHERRD
1204 {
1205 WRITED_LOG_ZERO;
1206 ERRNO_DOMAIN;
1207 }
1208 }
1209 else
1210 {
1211 RETVAL_NEG_HUGE_VALD;
1212 NOT_MATHERRD {ERRNO_DOMAIN;}
1213 }
1214 *(double *)retval = exc.retval;
1215 break;
1216 }
1217 case logf_zero:
1218 case log2f_zero:
1219 /* logf(0) */
1220 {
1221 SINGF; NAMEF = (char *) "logf";
1222 ifSVID
1223 {
1224 RETVAL_NEG_HUGEF;
1225 NOT_MATHERRF
1226 {
1227 WRITEF_LOG_ZERO;
1228 ERRNO_DOMAIN;
1229 }
1230 }
1231 else
1232 {
1233 RETVAL_NEG_HUGE_VALF;
1234 NOT_MATHERRF {ERRNO_DOMAIN;}
1235 }
1236 *(float *)retval = excf.retval;
1237 break;
1238 }
1239
1240 case logl_negative:
1241 case log2l_negative:
1242 /* logl(x < 0) */
1243 {
1244 DOMAINL; NAMEL = (char *) "logl";
1245 ifSVID
1246 {
1247 RETVAL_NEG_HUGEL;
1248 NOT_MATHERRL
1249 {
1250 WRITEL_LOG_NEGATIVE;
1251 ERRNO_DOMAIN;
1252 }
1253 }
1254 else
1255 {
1256 RETVAL_NEG_HUGE_VALL;
1257 NOT_MATHERRL {ERRNO_DOMAIN;}
1258 }
1259 *(long double *)retval = excl.retval;
1260 break;
1261 }
1262 case log_negative:
1263 case log2_negative:
1264 /* log(x < 0) */
1265 {
1266 DOMAIND; NAMED = (char *) "log";
1267 ifSVID
1268 {
1269 RETVAL_NEG_HUGED;
1270 NOT_MATHERRD
1271 {
1272 WRITED_LOG_NEGATIVE;
1273 ERRNO_DOMAIN;
1274 }
1275 }
1276 else
1277 {
1278 RETVAL_NEG_HUGE_VALD;
1279 NOT_MATHERRD {ERRNO_DOMAIN;}
1280 }
1281 *(double *)retval = exc.retval;
1282 break;
1283 }
1284 case logf_negative:
1285 case log2f_negative:
1286 /* logf(x < 0) */
1287 {
1288 DOMAINF; NAMEF = (char *) "logf";
1289 ifSVID
1290 {
1291 RETVAL_NEG_HUGEF;
1292 NOT_MATHERRF
1293 {
1294 WRITEF_LOG_NEGATIVE;
1295 ERRNO_DOMAIN;
1296 }
1297 }
1298 else
1299 {
1300 RETVAL_NEG_HUGE_VALF;
1301 NOT_MATHERRF{ERRNO_DOMAIN;}
1302 }
1303 *(float *)retval = excf.retval;
1304 break;
1305 }
1306 case log1pl_zero:
1307 /* log1pl(-1) */
1308 {
1309 SINGL; NAMEL = (char *) "log1pl";
1310 ifSVID
1311 {
1312 RETVAL_NEG_HUGEL;
1313 NOT_MATHERRL
1314 {
1315 WRITEL_LOG1P_ZERO;
1316 ERRNO_DOMAIN;
1317 }
1318 }
1319 else
1320 {
1321 RETVAL_NEG_HUGE_VALL;
1322 NOT_MATHERRL {ERRNO_DOMAIN;}
1323 }
1324 *(long double *)retval = excl.retval;
1325 break;
1326 }
1327 case log1p_zero:
1328 /* log1p(-1) */
1329 {
1330 SINGD; NAMED = (char *) "log1p";
1331 ifSVID
1332 {
1333 RETVAL_NEG_HUGED;
1334 NOT_MATHERRD
1335 {
1336 WRITED_LOG1P_ZERO;
1337 ERRNO_DOMAIN;
1338 }
1339 }
1340 else
1341 {
1342 RETVAL_NEG_HUGE_VALD;
1343 NOT_MATHERRD {ERRNO_DOMAIN;}
1344 }
1345 *(double *)retval = exc.retval;
1346 break;
1347 }
1348 case log1pf_zero:
1349 /* log1pf(-1) */
1350 {
1351 SINGF; NAMEF = (char *) "log1pf";
1352 ifSVID
1353 {
1354 RETVAL_NEG_HUGEF;
1355 NOT_MATHERRF
1356 {
1357 WRITEF_LOG1P_ZERO;
1358 ERRNO_DOMAIN;
1359 }
1360 }
1361 else
1362 {
1363 RETVAL_NEG_HUGE_VALF;
1364 NOT_MATHERRF {}ERRNO_DOMAIN;
1365 }
1366 *(float *)retval = excf.retval;
1367 break;
1368 }
1369 case log1pl_negative:
1370 /* log1pl(x < -1) */
1371 {
1372 DOMAINL; NAMEL = (char *) "log1pl";
1373 ifSVID
1374 {
1375 RETVAL_NEG_HUGEL;
1376 NOT_MATHERRL
1377 {
1378 WRITEL_LOG1P_NEGATIVE;
1379 ERRNO_DOMAIN;
1380 }
1381 }
1382 else
1383 {
1384 RETVAL_NEG_HUGE_VALL;
1385 NOT_MATHERRL {ERRNO_DOMAIN;}
1386 }
1387 *(long double *)retval = excl.retval;
1388 break;
1389 }
1390 case log1p_negative:
1391 /* log1p(x < -1) */
1392 {
1393 DOMAIND; NAMED = (char *) "log1p";
1394 ifSVID
1395 {
1396 RETVAL_NEG_HUGED;
1397 NOT_MATHERRD
1398 {
1399 WRITED_LOG1P_NEGATIVE;
1400 ERRNO_DOMAIN;
1401 }
1402 }
1403 else
1404 {
1405 RETVAL_NEG_HUGE_VALD;
1406 NOT_MATHERRD {ERRNO_DOMAIN;}
1407 }
1408 *(double *)retval = exc.retval;
1409 break;
1410 }
1411 case log1pf_negative:
1412 /* log1pf(x < -1) */
1413 {
1414 DOMAINF; NAMEF = (char *) "log1pf";
1415 ifSVID
1416 {
1417 RETVAL_NEG_HUGEF;
1418 NOT_MATHERRF
1419 {
1420 WRITEF_LOG1P_NEGATIVE;
1421 ERRNO_DOMAIN;
1422 }
1423 }
1424 else
1425 {
1426 RETVAL_NEG_HUGE_VALF;
1427 NOT_MATHERRF {ERRNO_DOMAIN;}
1428 }
1429 *(float *)retval = excf.retval;
1430 break;
1431 }
1432 case log10l_zero:
1433 /* log10l(0) */
1434 {
1435 SINGL; NAMEL = (char *) "log10l";
1436 ifSVID
1437 {
1438 RETVAL_NEG_HUGEL;
1439 NOT_MATHERRL
1440 {
1441 WRITEL_LOG10_ZERO;
1442 ERRNO_DOMAIN;
1443 }
1444 }
1445 else
1446 {
1447 RETVAL_NEG_HUGE_VALL;
1448 NOT_MATHERRL {ERRNO_DOMAIN;}
1449 }
1450 *(long double *)retval = excl.retval;
1451 break;
1452 }
1453 case log10_zero:
1454 /* log10(0) */
1455 {
1456 SINGD; NAMED = (char *) "log10";
1457 ifSVID
1458 {
1459 RETVAL_NEG_HUGED;
1460 NOT_MATHERRD
1461 {
1462 WRITED_LOG10_ZERO;
1463 ERRNO_DOMAIN;
1464 }
1465 }
1466 else
1467 {
1468 RETVAL_NEG_HUGE_VALD;
1469 NOT_MATHERRD {ERRNO_DOMAIN;}
1470 }
1471 *(double *)retval = exc.retval;
1472 break;
1473 }
1474 case log10f_zero:
1475 /* log10f(0) */
1476 {
1477 SINGF; NAMEF = (char *) "log10f";
1478 ifSVID
1479 {
1480 RETVAL_NEG_HUGEF;
1481 NOT_MATHERRF
1482 {
1483 WRITEF_LOG10_ZERO;
1484 ERRNO_DOMAIN;
1485 }
1486 }
1487 else
1488 {
1489 RETVAL_NEG_HUGE_VALF;
1490 NOT_MATHERRF {ERRNO_DOMAIN;}
1491 }
1492 *(float *)retval = excf.retval;
1493 break;
1494 }
1495 case log10l_negative:
1496 /* log10l(x < 0) */
1497 {
1498 DOMAINL; NAMEL = (char *) "log10l";
1499 ifSVID
1500 {
1501 RETVAL_NEG_HUGEL;
1502 NOT_MATHERRL
1503 {
1504 WRITEL_LOG10_NEGATIVE;
1505 ERRNO_DOMAIN;
1506 }
1507 }
1508 else
1509 {
1510 RETVAL_NEG_HUGE_VALL;
1511 NOT_MATHERRL {ERRNO_DOMAIN;}
1512 }
1513 *(long double *)retval = excl.retval;
1514 break;
1515 }
1516 case log10_negative:
1517 /* log10(x < 0) */
1518 {
1519 DOMAIND; NAMED = (char *) "log10";
1520 ifSVID
1521 {
1522 RETVAL_NEG_HUGED;
1523 NOT_MATHERRD
1524 {
1525 WRITED_LOG10_NEGATIVE;
1526 ERRNO_DOMAIN;
1527 }
1528 }
1529 else
1530 {
1531 RETVAL_NEG_HUGE_VALD;
1532 NOT_MATHERRD {ERRNO_DOMAIN;}
1533 }
1534 *(double *)retval = exc.retval;
1535 break;
1536 }
1537 case log10f_negative:
1538 /* log10f(x < 0) */
1539 {
1540 DOMAINF; NAMEF = (char *) "log10f";
1541 ifSVID
1542 {
1543 RETVAL_NEG_HUGEF;
1544 NOT_MATHERRF
1545 {
1546 WRITEF_LOG10_NEGATIVE;
1547 ERRNO_DOMAIN;
1548 }
1549 }
1550 else
1551 {
1552 RETVAL_NEG_HUGE_VALF;
1553 NOT_MATHERRF {ERRNO_DOMAIN;}
1554 }
1555 *(float *)retval = excf.retval;
1556 break;
1557 }
1558 case expl_overflow:
1559 /* expl overflow */
1560 {
1561 OVERFLOWL; NAMEL = (char *) "expl";
1562 ifSVID
1563 {
1564 RETVAL_HUGEL;
1565 }
1566 else
1567 {
1568 RETVAL_HUGE_VALL;
1569 }
1570 NOT_MATHERRL {ERRNO_RANGE;}
1571 *(long double *)retval = excl.retval;
1572 break;
1573 }
1574 case exp_overflow:
1575 /* exp overflow */
1576 {
1577 OVERFLOWD; NAMED = (char *) "exp";
1578 ifSVID
1579 {
1580 RETVAL_HUGED;
1581 }
1582 else
1583 {
1584 RETVAL_HUGE_VALD;
1585 }
1586 NOT_MATHERRD {ERRNO_RANGE;}
1587 *(double *)retval = exc.retval;
1588 break;
1589 }
1590 case expf_overflow:
1591 /* expf overflow */
1592 {
1593 OVERFLOWF; NAMEF = (char *) "expf";
1594 ifSVID
1595 {
1596 RETVAL_HUGEF;
1597 }
1598 else
1599 {
1600 RETVAL_HUGE_VALF;
1601 }
1602 NOT_MATHERRF {ERRNO_RANGE;}
1603 *(float *)retval = excf.retval;
1604 break;
1605 }
1606 case expl_underflow:
1607 /* expl underflow */
1608 {
1609 UNDERFLOWL; NAMEL = (char *) "expl"; RETVAL_ZEROL;
1610 NOT_MATHERRL {ERRNO_RANGE;}
1611 *(long double *)retval = excl.retval;
1612 break;
1613 }
1614 case exp_underflow:
1615 /* exp underflow */
1616 {
1617 UNDERFLOWD; NAMED = (char *) "exp"; RETVAL_ZEROD;
1618 NOT_MATHERRD {ERRNO_RANGE;}
1619 *(double *)retval = exc.retval;
1620 break;
1621 }
1622 case expf_underflow:
1623 /* expf underflow */
1624 {
1625 UNDERFLOWF; NAMEF = (char *) "expf"; RETVAL_ZEROF;
1626 NOT_MATHERRF {ERRNO_RANGE;}
1627 *(float *)retval = excf.retval;
1628 break;
1629 }
1630 case powl_zero_to_zero:
1631 /* powl 0**0 */
1632 {
1633 DOMAINL; NAMEL = (char *) "powl";
1634 ifSVID
1635 {
1636 RETVAL_ZEROL;
1637 NOT_MATHERRL
1638 {
1639 WRITEL_POW_ZERO_TO_ZERO;
1640 ERRNO_RANGE;
1641 }
1642 *(long double *)retval = excl.retval;
1643 }
1644 else RETVAL_ONEL;
1645 break;
1646 }
1647 case pow_zero_to_zero:
1648 /* pow 0**0 */
1649 {
1650 DOMAIND; NAMED = (char *) "pow";
1651 ifSVID
1652 {
1653 RETVAL_ZEROD;
1654 NOT_MATHERRD
1655 {
1656 WRITED_POW_ZERO_TO_ZERO;
1657 ERRNO_RANGE;
1658 }
1659 *(double *)retval = exc.retval;
1660 }
1661 else RETVAL_ONED;
1662 break;
1663 }
1664 case powf_zero_to_zero:
1665 /* powf 0**0 */
1666 {
1667 DOMAINF; NAMEF = (char *) "powf";
1668 ifSVID
1669 {
1670 RETVAL_ZEROF;
1671 NOT_MATHERRF
1672 {
1673 WRITEF_POW_ZERO_TO_ZERO;
1674 ERRNO_RANGE;
1675 }
1676 *(float *)retval = excf.retval;
1677 }
1678 else RETVAL_ONEF;
1679 break;
1680 }
1681 case powl_overflow:
1682 /* powl(x,y) overflow */
1683 {
1684 OVERFLOWL; NAMEL = (char *) "powl";
1685 ifSVID
1686 {
1687 if (INPUT_XL < 0) RETVAL_NEG_HUGEL;
1688 else RETVAL_HUGEL;
1689 }
1690 else
1691 {
1692 if (INPUT_XL < 0) RETVAL_NEG_HUGE_VALL;
1693 else RETVAL_HUGE_VALL;
1694 }
1695 NOT_MATHERRL {ERRNO_RANGE;}
1696 *(long double *)retval = excl.retval;
1697 break;
1698 }
1699 case pow_overflow:
1700 /* pow(x,y) overflow */
1701 {
1702 OVERFLOWD; NAMED = (char *) "pow";
1703 ifSVID
1704 {
1705 if (INPUT_XD < 0) RETVAL_NEG_HUGED;
1706 else RETVAL_HUGED;
1707 }
1708 else
1709 {
1710 if (INPUT_XD < 0) RETVAL_NEG_HUGE_VALD;
1711 else RETVAL_HUGE_VALD;
1712 }
1713 NOT_MATHERRD {ERRNO_RANGE;}
1714 *(double *)retval = exc.retval;
1715 break;
1716 }
1717 case powf_overflow:
1718 /* powf(x,y) overflow */
1719 {
1720 OVERFLOWF; NAMEF = (char *) "powf";
1721 ifSVID
1722 {
1723 if (INPUT_XF < 0) RETVAL_NEG_HUGEF;
1724 else RETVAL_HUGEF;
1725 }
1726 else
1727 {
1728 if (INPUT_XF < 0) RETVAL_NEG_HUGE_VALF;
1729 else RETVAL_HUGE_VALF;
1730 }
1731 NOT_MATHERRF {ERRNO_RANGE;}
1732 *(float *)retval = excf.retval;
1733 break;
1734 }
1735 case powl_underflow:
1736 /* powl(x,y) underflow */
1737 {
1738 UNDERFLOWL; NAMEL = (char *) "powl"; RETVAL_ZEROL;
1739 NOT_MATHERRL {ERRNO_RANGE;}
1740 *(long double *)retval = excl.retval;
1741 break;
1742 }
1743 case pow_underflow:
1744 /* pow(x,y) underflow */
1745 {
1746 UNDERFLOWD; NAMED = (char *) "pow"; RETVAL_ZEROD;
1747 NOT_MATHERRD {ERRNO_RANGE;}
1748 *(double *)retval = exc.retval;
1749 break;
1750 }
1751 case powf_underflow:
1752 /* powf(x,y) underflow */
1753 {
1754 UNDERFLOWF; NAMEF = (char *) "powf"; RETVAL_ZEROF;
1755 NOT_MATHERRF {ERRNO_RANGE;}
1756 *(float *)retval = excf.retval;
1757 break;
1758 }
1759 case powl_zero_to_negative:
1760 /* 0 to neg */
1761 {
1762 DOMAINL; NAMEL = (char *) "powl";
1763 ifSVID
1764 {
1765 RETVAL_ZEROL;
1766 NOT_MATHERRL
1767 {
1768 WRITEL_POW_ZERO_TO_NEGATIVE;
1769 ERRNO_DOMAIN;
1770 }
1771 }
1772 else
1773 {
1774 RETVAL_NEG_HUGE_VALL;
1775 NOT_MATHERRL {ERRNO_DOMAIN;}
1776 }
1777 *(long double *)retval = excl.retval;
1778 break;
1779 }
1780 case pow_zero_to_negative:
1781 /* 0**neg */
1782 {
1783 DOMAIND; NAMED = (char *) "pow";
1784 ifSVID
1785 {
1786 RETVAL_ZEROD;
1787 NOT_MATHERRD
1788 {
1789 WRITED_POW_ZERO_TO_NEGATIVE;
1790 ERRNO_DOMAIN;
1791 }
1792 }
1793 else
1794 {
1795 RETVAL_NEG_HUGE_VALD;
1796 NOT_MATHERRD {ERRNO_DOMAIN;}
1797 }
1798 *(double *)retval = exc.retval;
1799 break;
1800 }
1801 case powf_zero_to_negative:
1802 /* 0**neg */
1803 {
1804 DOMAINF; NAMEF = (char *) "powf";
1805 RETVAL_NEG_HUGE_VALF;
1806 ifSVID
1807 {
1808 RETVAL_ZEROF;
1809 NOT_MATHERRF
1810 {
1811 WRITEF_POW_ZERO_TO_NEGATIVE;
1812 ERRNO_DOMAIN;
1813 }
1814 }
1815 else
1816 {
1817 RETVAL_NEG_HUGE_VALF;
1818 NOT_MATHERRF {ERRNO_DOMAIN;}
1819 }
1820 *(float *)retval = excf.retval;
1821 break;
1822 }
1823 case powl_neg_to_non_integer:
1824 /* neg**non_integral */
1825 {
1826 DOMAINL; NAMEL = (char *) "powl";
1827 ifSVID
1828 {
1829 RETVAL_ZEROF;
1830 NOT_MATHERRL
1831 {
1832 WRITEL_POW_NEG_TO_NON_INTEGER;
1833 ERRNO_DOMAIN;
1834 }
1835 }
1836 else
1837 {
1838 NOT_MATHERRL {ERRNO_DOMAIN;}
1839 }
1840 *(long double *)retval = excl.retval;
1841 break;
1842 }
1843 case pow_neg_to_non_integer:
1844 /* neg**non_integral */
1845 {
1846 DOMAIND; NAMED = (char *) "pow";
1847 ifSVID
1848 {
1849 RETVAL_ZEROD;
1850 NOT_MATHERRD
1851 {
1852 WRITED_POW_NEG_TO_NON_INTEGER;
1853 ERRNO_DOMAIN;
1854 }
1855 }
1856 else
1857 {
1858 NOT_MATHERRD {ERRNO_DOMAIN;}
1859 }
1860 *(double *)retval = exc.retval;
1861 break;
1862 }
1863 case powf_neg_to_non_integer:
1864 /* neg**non-integral */
1865 {
1866 DOMAINF; NAMEF = (char *) "powf";
1867 ifSVID
1868 {
1869 RETVAL_ZEROF;
1870 NOT_MATHERRF
1871 {
1872 WRITEF_POW_NEG_TO_NON_INTEGER;
1873 ERRNO_DOMAIN;
1874 }
1875 }
1876 else
1877 {
1878 NOT_MATHERRF {ERRNO_DOMAIN;}
1879 }
1880 *(float *)retval = excf.retval;
1881 break;
1882 }
1883 case powl_nan_to_zero:
1884 /* pow(NaN,0.0) */
1885 /* Special Error */
1886 {
1887 DOMAINL; NAMEL = (char *) "powl"; INPUT_XL; INPUT_YL;
1888 excl.retval = *(long double *)arg1;
1889 NOT_MATHERRL {ERRNO_DOMAIN;}
1890 *(long double *)retval = excl.retval;
1891 break;
1892 }
1893 case pow_nan_to_zero:
1894 /* pow(NaN,0.0) */
1895 /* Special Error */
1896 {
1897 DOMAIND; NAMED = (char *) "pow"; INPUT_XD; INPUT_YD;
1898 exc.retval = *(double *)arg1;
1899 NOT_MATHERRD {ERRNO_DOMAIN;}
1900 *(double *)retval = exc.retval;
1901 break;
1902 }
1903 case powf_nan_to_zero:
1904 /* powf(NaN,0.0) */
1905 /* Special Error */
1906 {
1907 DOMAINF; NAMEF = (char *) "powf"; INPUT_XF; INPUT_YF;
1908 excf.retval = *(float *)arg1;
1909 NOT_MATHERRF {ERRNO_DOMAIN;}
1910 *(float *)retval = excf.retval;
1911 break;
1912 }
1913 case atan2l_zero:
1914 /* atan2l(0.0,0.0) */
1915 {
1916 DOMAINL; NAMEL = (char *) "atan2l";
1917 RETVAL_ZEROL;
1918 NOT_MATHERRL
1919 {
1920 ifSVID
1921 {
1922 WRITEL_ATAN2_ZERO_BY_ZERO;
1923 }
1924 ERRNO_DOMAIN;
1925 }
1926 *(long double *)retval = excl.retval;
1927 break;
1928 }
1929 case atan2_zero:
1930 /* atan2(0.0,0.0) */
1931 {
1932 DOMAIND; NAMED = (char *) "atan2";
1933 RETVAL_ZEROD;
1934 NOT_MATHERRD
1935 {
1936 ifSVID
1937 {
1938 WRITED_ATAN2_ZERO_BY_ZERO;
1939 }
1940 ERRNO_DOMAIN;
1941 }
1942 *(double *)retval = exc.retval;
1943 break;
1944 }
1945 case atan2f_zero:
1946 /* atan2f(0.0,0.0) */
1947 {
1948 DOMAINF; NAMEF = (char *) "atan2f";
1949 RETVAL_ZEROF;
1950 NOT_MATHERRF
1951 ifSVID
1952 {
1953 WRITEF_ATAN2_ZERO_BY_ZERO;
1954 }
1955 ERRNO_DOMAIN;
1956 *(float *)retval = excf.retval;
1957 break;
1958 }
1959 case expm1_overflow:
1960 /* expm1(finite) overflow */
1961 /* Overflow is the only documented */
1962 /* special value. */
1963 {
1964 ERRNO_RANGE;
1965 break;
1966 }
1967 case expm1f_overflow:
1968 /* expm1f(finite) overflow */
1969 {
1970 ERRNO_RANGE;
1971 break;
1972 }
1973 case expm1_underflow:
1974 /* expm1(finite) underflow */
1975 /* Underflow is not documented */
1976 /* special value. */
1977 {
1978 ERRNO_RANGE;
1979 break;
1980 }
1981 case expm1f_underflow:
1982 /* expm1f(finite) underflow */
1983 {
1984 ERRNO_RANGE;
1985 break;
1986 }
1987 case scalbl_underflow:
1988 /* scalbl underflow */
1989 {
1990 UNDERFLOWL; NAMEL = (char *) "scalbl";
1991 if (INPUT_XL < 0.0L) RETVAL_NEG_ZEROL;
1992 else RETVAL_ZEROL;
1993 NOT_MATHERRL {ERRNO_RANGE;}
1994 *(long double *)retval = excf.retval;
1995 break;
1996 }
1997 case scalb_underflow:
1998 /* scalb underflow */
1999 {
2000 UNDERFLOWD; NAMED = (char *) "scalb";
2001 if (INPUT_XD < 0.0) RETVAL_NEG_ZEROD;
2002 else RETVAL_ZEROD;
2003 NOT_MATHERRD {ERRNO_RANGE;}
2004 *(double *)retval = exc.retval;
2005 break;
2006 }
2007 case scalbf_underflow:
2008 /* scalbf underflow */
2009 {
2010 UNDERFLOWF; NAMEF = (char *) "scalbf";
2011 if (INPUT_XF < 0.0) RETVAL_NEG_ZEROF;
2012 else RETVAL_ZEROF;
2013 NOT_MATHERRF {ERRNO_RANGE;}
2014 *(float *)retval = excf.retval;
2015 break;
2016 }
2017 case scalbl_overflow:
2018 /* scalbl overflow */
2019 {
2020 OVERFLOWL; NAMEL = (char *) "scalbl";
2021 if (INPUT_XL < 0) RETVAL_NEG_HUGE_VALL;
2022 else RETVAL_HUGE_VALL;
2023 NOT_MATHERRL {ERRNO_RANGE;}
2024 *(long double *)retval = excl.retval;
2025 break;
2026 }
2027 case scalb_overflow:
2028 /* scalb overflow */
2029 {
2030 OVERFLOWD; NAMED = (char *) "scalb";
2031 if (INPUT_XD < 0) RETVAL_NEG_HUGE_VALD;
2032 else RETVAL_HUGE_VALD;
2033 NOT_MATHERRD {ERRNO_RANGE;}
2034 *(double *)retval = exc.retval;
2035 break;
2036 }
2037 case scalbf_overflow:
2038 /* scalbf overflow */
2039 {
2040 OVERFLOWF; NAMEF = (char *) "scalbf";
2041 if (INPUT_XF < 0) RETVAL_NEG_HUGE_VALF;
2042 else RETVAL_HUGE_VALF;
2043 NOT_MATHERRF {ERRNO_RANGE;}
2044 *(float *)retval = excf.retval;
2045 break;
2046 }
2047 case hypotl_overflow:
2048 /* hypotl overflow */
2049 {
2050 OVERFLOWL; NAMEL = (char *) "hypotl";
2051 ifSVID
2052 {
2053 RETVAL_HUGEL;
2054 }
2055 else
2056 {
2057 RETVAL_HUGE_VALL;
2058 }
2059 NOT_MATHERRL {ERRNO_RANGE;}
2060 *(long double *)retval = excl.retval;
2061 break;
2062 }
2063 case hypot_overflow:
2064 /* hypot overflow */
2065 {
2066 OVERFLOWD; NAMED = (char *) "hypot";
2067 ifSVID
2068 {
2069 RETVAL_HUGED;
2070 }
2071 else
2072 {
2073 RETVAL_HUGE_VALD;
2074 }
2075 NOT_MATHERRD {ERRNO_RANGE;}
2076 *(double *)retval = exc.retval;
2077 break;
2078 }
2079 case hypotf_overflow:
2080 /* hypotf overflow */
2081 {
2082 OVERFLOWF; NAMEF = (char *) "hypotf";
2083 ifSVID
2084 {
2085 RETVAL_HUGEF;
2086 }
2087 else
2088 {
2089 RETVAL_HUGE_VALF;
2090 }
2091 NOT_MATHERRF {ERRNO_RANGE;}
2092 *(float *)retval = excf.retval;
2093 break;
2094 }
2095 case acosl_gt_one:
2096 /* acosl(x > 1) */
2097 {
2098 DOMAINL; NAMEL = (char *) "acosl";
2099 RETVAL_ZEROL;
2100 ifSVID
2101 {
2102 NOT_MATHERRL
2103 {
2104 WRITEL_ACOS;
2105 ERRNO_DOMAIN;
2106 }
2107 }
2108 else
2109 {
2110 NOT_MATHERRL {ERRNO_DOMAIN;}
2111 }
2112 *(long double *)retval = excl.retval;
2113 break;
2114 }
2115 case acos_gt_one:
2116 /* acos(x > 1) */
2117 {
2118 DOMAIND; NAMED = (char *) "acos";
2119 RETVAL_ZEROD;
2120 ifSVID
2121 {
2122 NOT_MATHERRD
2123 {
2124 WRITED_ACOS;
2125 ERRNO_DOMAIN;
2126 }
2127 }
2128 else
2129 {
2130 NOT_MATHERRD {ERRNO_DOMAIN;}
2131 }
2132 *(double *)retval = exc.retval;
2133 break;
2134 }
2135 case acosf_gt_one:
2136 /* acosf(x > 1) */
2137 {
2138 DOMAINF; NAMEF = (char *) "acosf";
2139 RETVAL_ZEROF;
2140 ifSVID
2141 {
2142 NOT_MATHERRF
2143 {
2144 WRITEF_ACOS;
2145 ERRNO_DOMAIN;
2146 }
2147 }
2148 else
2149 {
2150 NOT_MATHERRF {ERRNO_DOMAIN;}
2151 }
2152 *(float *)retval = excf.retval;
2153 break;
2154 }
2155 case asinl_gt_one:
2156 /* asinl(x > 1) */
2157 {
2158 DOMAINL; NAMEL = (char *) "asinl";
2159 RETVAL_ZEROL;
2160 ifSVID
2161 {
2162 NOT_MATHERRL
2163 {
2164 WRITEL_ASIN;
2165 ERRNO_DOMAIN;
2166 }
2167 }
2168 else
2169 {
2170 NOT_MATHERRL {ERRNO_DOMAIN;}
2171 }
2172 *(long double *)retval = excl.retval;
2173 break;
2174 }
2175 case asin_gt_one:
2176 /* asin(x > 1) */
2177 {
2178 DOMAIND; NAMED = (char *) "asin";
2179 RETVAL_ZEROD;
2180 ifSVID
2181 {
2182 NOT_MATHERRD
2183 {
2184 WRITED_ASIN;
2185 ERRNO_DOMAIN;
2186 }
2187 }
2188 else
2189 {
2190 NOT_MATHERRD {ERRNO_DOMAIN;}
2191 }
2192 *(double *)retval = exc.retval;
2193 break;
2194 }
2195 case asinf_gt_one:
2196 /* asinf(x > 1) */
2197 {
2198 DOMAINF; NAMEF = (char *) "asinf";
2199 RETVAL_ZEROF;
2200 ifSVID
2201 {
2202 NOT_MATHERRF
2203 {
2204 WRITEF_ASIN;
2205 ERRNO_DOMAIN;
2206 }
2207 }
2208 else
2209 {
2210 NOT_MATHERRF {ERRNO_DOMAIN;}
2211 }
2212 *(float *)retval = excf.retval;
2213 break;
2214 }
2215 case coshl_overflow:
2216 /* coshl overflow */
2217 {
2218 OVERFLOWL; NAMEL = (char *) "coshl";
2219 ifSVID
2220 {
2221 RETVAL_HUGEL;
2222 }
2223 else
2224 {
2225 RETVAL_HUGE_VALL;
2226 }
2227 NOT_MATHERRL {ERRNO_RANGE;}
2228 *(long double *)retval = excl.retval;
2229 break;
2230 }
2231 case cosh_overflow:
2232 /* cosh overflow */
2233 {
2234 OVERFLOWD; NAMED = (char *) "cosh";
2235 ifSVID
2236 {
2237 RETVAL_HUGED;
2238 }
2239 else
2240 {
2241 RETVAL_HUGE_VALD;
2242 }
2243 NOT_MATHERRD {ERRNO_RANGE;}
2244 *(double *)retval = exc.retval;
2245 break;
2246 }
2247 case coshf_overflow:
2248 /* coshf overflow */
2249 {
2250 OVERFLOWF; NAMEF = (char *) "coshf";
2251 ifSVID
2252 {
2253 RETVAL_HUGEF;
2254 }
2255 else
2256 {
2257 RETVAL_HUGE_VALF;
2258 }
2259 NOT_MATHERRF {ERRNO_RANGE;}
2260 *(float *)retval = excf.retval;
2261 break;
2262 }
2263 case sinhl_overflow:
2264 /* sinhl overflow */
2265 {
2266 OVERFLOWL; NAMEL = (char *) "sinhl";
2267 ifSVID
2268 {
2269 if (INPUT_XL > 0.0) RETVAL_HUGEL;
2270 else RETVAL_NEG_HUGEL;
2271 }
2272 else
2273 {
2274 if (INPUT_XL > 0.0) RETVAL_HUGE_VALL;
2275 else RETVAL_NEG_HUGE_VALL;
2276 }
2277 NOT_MATHERRL {ERRNO_RANGE;}
2278 *(long double *)retval = excl.retval;
2279 break;
2280 }
2281 case sinh_overflow:
2282 /* sinh overflow */
2283 {
2284 OVERFLOWD; NAMED = (char *) "sinh";
2285 ifSVID
2286 {
2287 if (INPUT_XD > 0.0) RETVAL_HUGED;
2288 else RETVAL_NEG_HUGED;
2289 }
2290 else
2291 {
2292 if (INPUT_XD > 0.0) RETVAL_HUGE_VALD;
2293 else RETVAL_NEG_HUGE_VALD;
2294 }
2295 NOT_MATHERRD {ERRNO_RANGE;}
2296 *(double *)retval = exc.retval;
2297 break;
2298 }
2299 case sinhf_overflow:
2300 /* sinhf overflow */
2301 {
2302 OVERFLOWF; NAMEF = (char *) "sinhf";
2303 ifSVID
2304 {
2305 if( INPUT_XF > 0.0) RETVAL_HUGEF;
2306 else RETVAL_NEG_HUGEF;
2307 }
2308 else
2309 {
2310 if (INPUT_XF > 0.0) RETVAL_HUGE_VALF;
2311 else RETVAL_NEG_HUGE_VALF;
2312 }
2313 NOT_MATHERRF {ERRNO_RANGE;}
2314 *(float *)retval = excf.retval;
2315 break;
2316 }
2317 case acoshl_lt_one:
2318 /* acoshl(x < 1) */
2319 {
2320 DOMAINL; NAMEL = (char *) "acoshl";
2321 ifSVID
2322 {
2323 NOT_MATHERRL
2324 {
2325 WRITEL_ACOSH;
2326 ERRNO_DOMAIN;
2327 }
2328 }
2329 else NOT_MATHERRL {ERRNO_DOMAIN;}
2330 *(long double *)retval = excl.retval;
2331 break;
2332 }
2333 case acosh_lt_one:
2334 /* acosh(x < 1) */
2335 {
2336 DOMAIND; NAMED = (char *) "acosh";
2337 ifSVID
2338 {
2339 NOT_MATHERRD
2340 {
2341 WRITEL_ACOSH;
2342 ERRNO_DOMAIN;
2343 }
2344 }
2345 else NOT_MATHERRD {ERRNO_DOMAIN;}
2346 *(double *)retval = exc.retval;
2347 break;
2348 }
2349 case acoshf_lt_one:
2350 /* acoshf(x < 1) */
2351 {
2352 DOMAINF; NAMEF = (char *) "acoshf";
2353 ifSVID
2354 {
2355 NOT_MATHERRF
2356 {
2357 WRITEF_ACOSH;
2358 ERRNO_DOMAIN;
2359 }
2360 }
2361 else
2362 {
2363 NOT_MATHERRF {ERRNO_DOMAIN;}
2364 }
2365 *(float *)retval = excf.retval;
2366 ERRNO_DOMAIN; break;
2367 }
2368 case atanhl_gt_one:
2369 /* atanhl(|x| > 1) */
2370 {
2371 DOMAINL; NAMEL = (char *) "atanhl";
2372 ifSVID
2373 {
2374 NOT_MATHERRL
2375 {
2376 WRITEL_ATANH_GT_ONE;
2377 ERRNO_DOMAIN;
2378 }
2379 }
2380 else
2381 {
2382 NOT_MATHERRL {ERRNO_DOMAIN;}
2383 }
2384 break;
2385 }
2386 case atanh_gt_one:
2387 /* atanh(|x| > 1) */
2388 {
2389 DOMAIND; NAMED = (char *) "atanh";
2390 ifSVID
2391 {
2392 NOT_MATHERRD
2393 {
2394 WRITED_ATANH_GT_ONE;
2395 ERRNO_DOMAIN;
2396 }
2397 }
2398 else
2399 {
2400 NOT_MATHERRD {ERRNO_DOMAIN;}
2401 }
2402 break;
2403 }
2404 case atanhf_gt_one:
2405 /* atanhf(|x| > 1) */
2406 {
2407 DOMAINF; NAMEF = (char *) "atanhf";
2408 ifSVID
2409 {
2410 NOT_MATHERRF
2411 {
2412 WRITEF_ATANH_GT_ONE;
2413 ERRNO_DOMAIN;
2414 }
2415 }
2416 else
2417 {
2418 NOT_MATHERRF {ERRNO_DOMAIN;}
2419 }
2420 break;
2421 }
2422 case atanhl_eq_one:
2423 /* atanhl(|x| == 1) */
2424 {
2425 SINGL; NAMEL = (char *)"atanhl";
2426 ifSVID
2427 {
2428 NOT_MATHERRL
2429 {
2430 WRITEL_ATANH_EQ_ONE;
2431 ERRNO_DOMAIN;
2432 }
2433 }
2434 else
2435 {
2436 NOT_MATHERRL {ERRNO_DOMAIN;}
2437 }
2438 break;
2439 }
2440 case atanh_eq_one:
2441 /* atanh(|x| == 1) */
2442 {
2443 SINGD; NAMED = (char *) "atanh";
2444 ifSVID
2445 {
2446 NOT_MATHERRD
2447 {
2448 WRITED_ATANH_EQ_ONE;
2449 ERRNO_DOMAIN;
2450 }
2451 }
2452 else
2453 {
2454 NOT_MATHERRD {ERRNO_DOMAIN;}
2455 }
2456 break;
2457 }
2458 case atanhf_eq_one:
2459 /* atanhf(|x| == 1) */
2460 {
2461 SINGF; NAMEF = (char *) "atanhf";
2462 ifSVID
2463 {
2464 NOT_MATHERRF
2465 {
2466 WRITEF_ATANH_EQ_ONE;
2467 ERRNO_DOMAIN;
2468 }
2469 }
2470 else
2471 {
2472 NOT_MATHERRF {ERRNO_DOMAIN;}
2473 }
2474 break;
2475 }
2476 case gammal_overflow:
2477 /* gammal overflow */
2478 {
2479 OVERFLOWL; NAMEL = (char *) "gammal";
2480 ifSVID
2481 {
2482 RETVAL_HUGEL;
2483 }
2484 else
2485 {
2486 RETVAL_HUGE_VALL;
2487 }
2488 NOT_MATHERRL {ERRNO_RANGE;}
2489 *(long double *)retval = excl.retval;
2490 break;
2491 }
2492 case gamma_overflow:
2493 /* gamma overflow */
2494 {
2495 OVERFLOWD; NAMED = (char *) "gamma";
2496 ifSVID
2497 {
2498 RETVAL_HUGED;
2499 }
2500 else
2501 {
2502 RETVAL_HUGE_VALD;
2503 }
2504 NOT_MATHERRD {ERRNO_RANGE;}
2505 *(double *)retval = exc.retval;
2506 break;
2507 }
2508 case gammaf_overflow:
2509 /* gammaf overflow */
2510 {
2511 OVERFLOWF; NAMEF = (char *) "gammaf";
2512 ifSVID
2513 {
2514 RETVAL_HUGEF;
2515 }
2516 else
2517 {
2518 RETVAL_HUGE_VALF;
2519 }
2520 NOT_MATHERRF {ERRNO_RANGE;}
2521 *(float *)retval = excf.retval;
2522 break;
2523 }
2524 case lgammal_overflow:
2525 /* lgammal overflow */
2526 {
2527 OVERFLOWL; NAMEL = (char *) "lgammal";
2528 ifSVID
2529 {
2530 RETVAL_HUGEL;
2531 }
2532 else
2533 {
2534 RETVAL_HUGE_VALL;
2535 }
2536 NOT_MATHERRL {ERRNO_RANGE;}
2537 *(long double *)retval = excl.retval;
2538 break;
2539 }
2540 case lgamma_overflow:
2541 /* lgamma overflow */
2542 {
2543 OVERFLOWD; NAMED = (char *) "lgamma";
2544 ifSVID
2545 {
2546 RETVAL_HUGED;
2547 }
2548 else
2549 {
2550 RETVAL_HUGE_VALD;
2551 }
2552 NOT_MATHERRD {ERRNO_RANGE;}
2553 *(double *)retval = exc.retval;
2554 break;
2555 }
2556 case lgammaf_overflow:
2557 /* lgammaf overflow */
2558 {
2559 OVERFLOWF; NAMEF = (char *) "lgammaf";
2560 ifSVID
2561 {
2562 RETVAL_HUGEF;
2563 }
2564 else
2565 {
2566 RETVAL_HUGE_VALF;
2567 }
2568 NOT_MATHERRF {ERRNO_RANGE;}
2569 *(float *)retval = excf.retval;
2570 break;
2571 }
2572 case lgammal_negative:
2573 /* lgammal -int or 0 */
2574 {
2575 SINGL; NAMEL = (char *) "lgammal";
2576 ifSVID
2577 {
2578 RETVAL_HUGEL;
2579 NOT_MATHERRL
2580 {
2581 WRITEL_LGAMMA_NEGATIVE;
2582 ERRNO_DOMAIN;
2583 }
2584 }
2585 else
2586 {
2587 RETVAL_HUGE_VALL;
2588 NOT_MATHERRL {ERRNO_DOMAIN;}
2589 }
2590 *(long double *)retval = excl.retval;
2591 break;
2592 }
2593 case lgamma_negative:
2594 /* lgamma -int or 0 */
2595 {
2596 SINGD; NAMED = (char *) "lgamma";
2597 ifSVID
2598 {
2599 RETVAL_HUGED;
2600 NOT_MATHERRD
2601 {
2602 WRITED_LGAMMA_NEGATIVE;
2603 ERRNO_DOMAIN;
2604 }
2605 }
2606 else
2607 {
2608 RETVAL_HUGE_VALD;
2609 NOT_MATHERRD {ERRNO_DOMAIN;}
2610 }
2611 *(double *)retval = exc.retval;
2612 break;
2613 }
2614 case lgammaf_negative:
2615 /* lgammaf -int or 0 */
2616 {
2617 SINGF; NAMEF = (char *) "lgammaf";
2618 ifSVID
2619 {
2620 RETVAL_HUGEF;
2621 NOT_MATHERRF
2622 {
2623 WRITEF_LGAMMA_NEGATIVE;
2624 ERRNO_DOMAIN;
2625 }
2626 }
2627 else
2628 {
2629 RETVAL_HUGE_VALF;
2630 NOT_MATHERRF {ERRNO_DOMAIN;}
2631 }
2632 *(float *)retval = excf.retval;
2633 break;
2634 }
2635 case gammal_negative:
2636 /* gammal -int or 0 */
2637 {
2638 SINGL; NAMEL = (char *) "gammal";
2639 ifSVID
2640 {
2641 RETVAL_HUGEL;
2642 NOT_MATHERRL
2643 {
2644 WRITEL_GAMMA_NEGATIVE;
2645 ERRNO_DOMAIN;
2646 }
2647 }
2648 else
2649 {
2650 RETVAL_HUGE_VALL;
2651 NOT_MATHERRL {ERRNO_DOMAIN;}
2652 }
2653 *(long double *)retval = excl.retval;
2654 break;
2655 }
2656 case gamma_negative:
2657 /* gamma -int or 0 */
2658 {
2659 SINGD; NAMED = (char *) "gamma";
2660 ifSVID
2661 {
2662 RETVAL_HUGED;
2663 NOT_MATHERRD
2664 {
2665 WRITED_GAMMA_NEGATIVE;
2666 ERRNO_DOMAIN;
2667 }
2668 }
2669 else
2670 {
2671 RETVAL_HUGE_VALD;
2672 NOT_MATHERRD {ERRNO_DOMAIN;}
2673 }
2674 *(double *)retval = exc.retval;
2675 break;
2676 }
2677 case gammaf_negative:
2678 /* gammaf -int or 0 */
2679 {
2680 SINGF; NAMEF = (char *) "gammaf";
2681 ifSVID
2682 {
2683 RETVAL_HUGEF;
2684 NOT_MATHERRF
2685 {
2686 WRITEF_GAMMA_NEGATIVE;
2687 ERRNO_DOMAIN;
2688 }
2689 }
2690 else
2691 {
2692 RETVAL_HUGE_VALF;
2693 NOT_MATHERRF {ERRNO_DOMAIN;}
2694 }
2695 *(float *)retval = excf.retval;
2696 break;
2697 }
2698 case j0l_gt_loss:
2699 /* j0l > loss */
2700 {
2701 TLOSSL; NAMEL = (char *) "j0l";
2702 RETVAL_ZEROL;
2703 ifSVID
2704 {
2705 NOT_MATHERRL
2706 {
2707 WRITEL_J0_TLOSS;
2708 ERRNO_RANGE;
2709 }
2710 }
2711 else
2712 {
2713 NOT_MATHERRL {ERRNO_RANGE;}
2714 }
2715 *(long double *)retval = excl.retval;
2716 break;
2717 }
2718 case j0_gt_loss:
2719 /* j0 > loss */
2720 {
2721 TLOSSD; NAMED = (char *) "j0";
2722 RETVAL_ZEROD;
2723 ifSVID
2724 {
2725 NOT_MATHERRD
2726 {
2727 WRITED_J0_TLOSS;
2728 ERRNO_RANGE;
2729 }
2730 }
2731 else
2732 {
2733 NOT_MATHERRD {ERRNO_RANGE;}
2734 }
2735 *(double*)retval = exc.retval;
2736 break;
2737 }
2738 case j0f_gt_loss:
2739 /* j0f > loss */
2740 {
2741 TLOSSF; NAMEF = (char *) "j0f";
2742 RETVAL_ZEROF;
2743 ifSVID
2744 {
2745 NOT_MATHERRF
2746 {
2747 WRITEF_J0_TLOSS;
2748 ERRNO_RANGE;
2749 }
2750 }
2751 else
2752 {
2753 NOT_MATHERRF {ERRNO_RANGE;}
2754 }
2755 *(float*)retval = excf.retval;
2756 break;
2757 }
2758 case j1l_gt_loss:
2759 /* j1l > loss */
2760 {
2761 TLOSSL; NAMEL = (char *) "j1l";
2762 RETVAL_ZEROL;
2763 ifSVID
2764 {
2765 NOT_MATHERRL
2766 {
2767 WRITEL_J1_TLOSS;
2768 ERRNO_RANGE;
2769 }
2770 }
2771 else
2772 {
2773 NOT_MATHERRL {ERRNO_RANGE;}
2774 }
2775 *(long double *)retval = excl.retval;
2776 break;
2777 }
2778 case j1_gt_loss:
2779 /* j1 > loss */
2780 {
2781 TLOSSD; NAMED = (char *) "j1";
2782 RETVAL_ZEROD;
2783 ifSVID
2784 {
2785 NOT_MATHERRD
2786 {
2787 WRITED_J1_TLOSS;
2788 ERRNO_RANGE;
2789 }
2790 }
2791 else
2792 {
2793 NOT_MATHERRD {ERRNO_RANGE;}
2794 }
2795 *(double*)retval = exc.retval;
2796 break;
2797 }
2798 case j1f_gt_loss:
2799 /* j1f > loss */
2800 {
2801 TLOSSF; NAMEF = (char *) "j1f";
2802 RETVAL_ZEROF;
2803 ifSVID
2804 {
2805 NOT_MATHERRF
2806 {
2807 WRITEF_J1_TLOSS;
2808 ERRNO_RANGE;
2809 }
2810 }
2811 else
2812 {
2813 NOT_MATHERRF {ERRNO_RANGE;}
2814 }
2815 *(float*)retval = excf.retval;
2816 break;
2817 }
2818 case jnl_gt_loss:
2819 /* jnl > loss */
2820 {
2821 TLOSSL; NAMEL = (char *) "jnl";
2822 RETVAL_ZEROL;
2823 ifSVID
2824 {
2825 NOT_MATHERRL
2826 {
2827 WRITEL_JN_TLOSS;
2828 ERRNO_RANGE;
2829 }
2830 }
2831 else
2832 {
2833 NOT_MATHERRL {ERRNO_RANGE;}
2834 }
2835 *(long double *)retval = excl.retval;
2836 break;
2837 }
2838 case jn_gt_loss:
2839 /* jn > loss */
2840 {
2841 TLOSSD; NAMED = (char *) "jn";
2842 RETVAL_ZEROD;
2843 ifSVID
2844 {
2845 NOT_MATHERRD
2846 {
2847 WRITED_JN_TLOSS;
2848 ERRNO_RANGE;
2849 }
2850 }
2851 else
2852 {
2853 NOT_MATHERRD {ERRNO_RANGE;}
2854 }
2855 *(double*)retval = exc.retval;
2856 break;
2857 }
2858 case jnf_gt_loss:
2859 /* jnf > loss */
2860 {
2861 TLOSSF; NAMEF = (char *) "jnf";
2862 RETVAL_ZEROF;
2863 ifSVID
2864 {
2865 NOT_MATHERRF
2866 {
2867 WRITEF_JN_TLOSS;
2868 ERRNO_RANGE;
2869 }
2870 }
2871 else
2872 {
2873 NOT_MATHERRF {ERRNO_RANGE;}
2874 }
2875 *(float*)retval = excf.retval;
2876 break;
2877 }
2878 case y0l_gt_loss:
2879 /* y0l > loss */
2880 {
2881 TLOSSL; NAMEL = (char *) "y0l";
2882 RETVAL_ZEROL;
2883 ifSVID
2884 {
2885 NOT_MATHERRL
2886 {
2887 WRITEL_Y0_TLOSS;
2888 ERRNO_RANGE;
2889 }
2890 }
2891 else
2892 {
2893 NOT_MATHERRL {ERRNO_RANGE;}
2894 }
2895 *(long double *)retval = excl.retval;
2896 break;
2897 }
2898 case y0_gt_loss:
2899 /* y0 > loss */
2900 {
2901 TLOSSD; NAMED = (char *) "y0";
2902 RETVAL_ZEROD;
2903 ifSVID
2904 {
2905 NOT_MATHERRD
2906 {
2907 WRITED_Y0_TLOSS;
2908 ERRNO_RANGE;
2909 }
2910 }
2911 else
2912 {
2913 NOT_MATHERRD {ERRNO_RANGE;}
2914 }
2915 *(double*)retval = exc.retval;
2916 break;
2917 }
2918 case y0f_gt_loss:
2919 /* y0f > loss */
2920 {
2921 TLOSSF; NAMEF = (char *) "y0f";
2922 RETVAL_ZEROF;
2923 ifSVID
2924 {
2925 NOT_MATHERRF
2926 {
2927 WRITEF_Y0_TLOSS;
2928 ERRNO_RANGE;
2929 }
2930 }
2931 else
2932 {
2933 NOT_MATHERRF {ERRNO_RANGE;}
2934 }
2935 *(float*)retval = excf.retval;
2936 break;
2937 }
2938 case y0l_zero:
2939 /* y0l(0) */
2940 {
2941 DOMAINL; NAMEL = (char *) "y0l";
2942 ifSVID
2943 {
2944 RETVAL_NEG_HUGEL;
2945 NOT_MATHERRL
2946 {
2947 WRITEL_Y0_ZERO;
2948 ERRNO_DOMAIN;
2949 }
2950 }
2951 else
2952 {
2953 RETVAL_NEG_HUGE_VALL;
2954 NOT_MATHERRL {ERRNO_DOMAIN;}
2955 }
2956 *(long double *)retval = excl.retval;
2957 break;
2958 }
2959 case y0_zero:
2960 /* y0(0) */
2961 {
2962 DOMAIND; NAMED = (char *) "y0";
2963 ifSVID
2964 {
2965 RETVAL_NEG_HUGED;
2966 NOT_MATHERRD
2967 {
2968 WRITED_Y0_ZERO;
2969 ERRNO_DOMAIN;
2970 }
2971 }
2972 else
2973 {
2974 RETVAL_NEG_HUGE_VALD;
2975 NOT_MATHERRD {ERRNO_DOMAIN;}
2976 }
2977 *(double *)retval = exc.retval;
2978 break;
2979 }
2980 case y0f_zero:
2981 /* y0f(0) */
2982 {
2983 DOMAINF; NAMEF = (char *) "y0f";
2984 ifSVID
2985 {
2986 RETVAL_NEG_HUGEF;
2987 NOT_MATHERRF
2988 {
2989 WRITEF_Y0_ZERO;
2990 ERRNO_DOMAIN;
2991 }
2992 }
2993 else
2994 {
2995 RETVAL_NEG_HUGE_VALF;
2996 NOT_MATHERRF {ERRNO_DOMAIN;}
2997 }
2998 *(float *)retval = excf.retval;
2999 break;
3000 }
3001 case y1l_gt_loss:
3002 /* y1l > loss */
3003 {
3004 TLOSSL; NAMEL = (char *) "y1l";
3005 RETVAL_ZEROL;
3006 ifSVID
3007 {
3008 NOT_MATHERRL
3009 {
3010 WRITEL_Y1_TLOSS;
3011 ERRNO_RANGE;
3012 }
3013 }
3014 else
3015 {
3016 NOT_MATHERRL {ERRNO_RANGE;}
3017 }
3018 *(long double *)retval = excl.retval;
3019 break;
3020 }
3021 case y1_gt_loss:
3022 /* y1 > loss */
3023 {
3024 TLOSSD; NAMED = (char *) "y1";
3025 RETVAL_ZEROD;
3026 ifSVID
3027 {
3028 NOT_MATHERRD
3029 {
3030 WRITED_Y1_TLOSS;
3031 ERRNO_RANGE;
3032 }
3033 }
3034 else
3035 {
3036 NOT_MATHERRD {ERRNO_RANGE;}
3037 }
3038 *(double*)retval = exc.retval;
3039 break;
3040 }
3041 case y1f_gt_loss:
3042 /* y1f > loss */
3043 {
3044 TLOSSF; NAMEF = (char *) "y1f";
3045 RETVAL_ZEROF;
3046 ifSVID
3047 {
3048 NOT_MATHERRF
3049 {
3050 WRITEF_Y1_TLOSS;
3051 ERRNO_RANGE;
3052 }
3053 }
3054 else
3055 {
3056 NOT_MATHERRF {ERRNO_RANGE;}
3057 }
3058 *(float*)retval = excf.retval;
3059 break;
3060 }
3061 case y1l_zero:
3062 /* y1l(0) */
3063 {
3064 DOMAINL; NAMEL = (char *) "y1l";
3065 ifSVID
3066 {
3067 RETVAL_NEG_HUGEL;
3068 NOT_MATHERRL
3069 {
3070 WRITEL_Y1_ZERO;
3071 ERRNO_DOMAIN;
3072 }
3073 }
3074 else
3075 {
3076 RETVAL_NEG_HUGE_VALL;
3077 NOT_MATHERRL {ERRNO_DOMAIN;}
3078 }
3079 *(long double *)retval = excl.retval;
3080 break;
3081 }
3082 case y1_zero:
3083 /* y1(0) */
3084 {
3085 DOMAIND; NAMED = (char *) "y1";
3086 ifSVID
3087 {
3088 RETVAL_NEG_HUGED;
3089 NOT_MATHERRD
3090 {
3091 WRITED_Y1_ZERO;
3092 ERRNO_DOMAIN;
3093 }
3094 }
3095 else
3096 {
3097 RETVAL_NEG_HUGE_VALD;
3098 NOT_MATHERRD {ERRNO_DOMAIN;}
3099 }
3100 *(double *)retval = exc.retval;
3101 break;
3102 }
3103 case y1f_zero:
3104 /* y1f(0) */
3105 {
3106 DOMAINF; NAMEF = (char *) "y1f";
3107 ifSVID
3108 {
3109 RETVAL_NEG_HUGEF;
3110 NOT_MATHERRF
3111 {
3112 WRITEF_Y1_ZERO;
3113 ERRNO_DOMAIN;
3114 }
3115 }else
3116 {
3117 RETVAL_NEG_HUGE_VALF;
3118 NOT_MATHERRF {ERRNO_DOMAIN;}
3119 }
3120 *(float *)retval = excf.retval;
3121 break;
3122 }
3123 case ynl_gt_loss:
3124 /* ynl > loss */
3125 {
3126 TLOSSL; NAMEL = (char *) "ynl";
3127 RETVAL_ZEROL;
3128 ifSVID
3129 {
3130 NOT_MATHERRL
3131 {
3132 WRITEL_YN_TLOSS;
3133 ERRNO_RANGE;
3134 }
3135 }
3136 else
3137 {
3138 NOT_MATHERRL {ERRNO_RANGE;}
3139 }
3140 *(long double *)retval = excl.retval;
3141 break;
3142 }
3143 case yn_gt_loss:
3144 /* yn > loss */
3145 {
3146 TLOSSD; NAMED = (char *) "yn";
3147 RETVAL_ZEROD;
3148 ifSVID
3149 {
3150 NOT_MATHERRD
3151 {
3152 WRITED_YN_TLOSS;
3153 ERRNO_RANGE;
3154 }
3155 }
3156 else
3157 {
3158 NOT_MATHERRD {ERRNO_RANGE;}
3159 }
3160 *(double*)retval = exc.retval;
3161 break;
3162 }
3163 case ynf_gt_loss:
3164 /* ynf > loss */
3165 {
3166 TLOSSF; NAMEF = (char *) "ynf";
3167 RETVAL_ZEROF;
3168 ifSVID
3169 {
3170 NOT_MATHERRF
3171 {
3172 WRITEF_YN_TLOSS;
3173 ERRNO_RANGE;
3174 }
3175 }
3176 else
3177 {
3178 NOT_MATHERRF {ERRNO_RANGE;}
3179 }
3180 *(float*)retval = excf.retval;
3181 break;
3182 }
3183 case ynl_zero:
3184 /* ynl(0) */
3185 {
3186 DOMAINL; NAMEL = (char *) "ynl";
3187 ifSVID
3188 {
3189 RETVAL_NEG_HUGEL;
3190 NOT_MATHERRL
3191 {
3192 WRITEL_YN_ZERO;
3193 ERRNO_DOMAIN;
3194 }
3195 }
3196 else
3197 {
3198 RETVAL_NEG_HUGE_VALL;
3199 NOT_MATHERRL {ERRNO_DOMAIN;}
3200 }
3201 *(long double *)retval = excl.retval;
3202 break;
3203 }
3204 case yn_zero:
3205 /* yn(0) */
3206 {
3207 DOMAIND; NAMED = (char *) "yn";
3208 ifSVID
3209 {
3210 RETVAL_NEG_HUGED;
3211 NOT_MATHERRD
3212 {
3213 WRITED_YN_ZERO;
3214 ERRNO_DOMAIN;
3215 }
3216 }
3217 else
3218 {
3219 RETVAL_NEG_HUGE_VALD;
3220 NOT_MATHERRD {ERRNO_DOMAIN;}
3221 }
3222 *(double *)retval = exc.retval;
3223 break;
3224 }
3225 case ynf_zero:
3226 /* ynf(0) */
3227 {
3228 DOMAINF; NAMEF = (char *) "ynf";
3229 ifSVID
3230 {
3231 RETVAL_NEG_HUGEF;
3232 NOT_MATHERRF
3233 {
3234 WRITEF_YN_ZERO;
3235 ERRNO_DOMAIN;
3236 }
3237 }
3238 else
3239 {
3240 RETVAL_NEG_HUGE_VALF;
3241 NOT_MATHERRF {ERRNO_DOMAIN;}
3242 }
3243 *(float *)retval = excf.retval;
3244 break;
3245 }
3246 case y0l_negative:
3247 /* y0l(x<0) */
3248 {
3249 DOMAINL; NAMEL = (char *) "y0l";
3250 ifSVID
3251 {
3252 RETVAL_NEG_HUGEL;
3253 NOT_MATHERRL
3254 {
3255 WRITEL_Y0_NEGATIVE;
3256 ERRNO_DOMAIN;
3257 }
3258 }
3259 else
3260 {
3261 RETVAL_NEG_HUGE_VALL;
3262 NOT_MATHERRL {ERRNO_DOMAIN;}
3263 }
3264 *(long double *)retval = excl.retval;
3265 break;
3266 }
3267 case y0_negative:
3268 /* y0(x<0) */
3269 {
3270 DOMAIND; NAMED = (char *) "y0";
3271 ifSVID
3272 {
3273 RETVAL_NEG_HUGED;
3274 NOT_MATHERRD
3275 {
3276 WRITED_Y0_NEGATIVE;
3277 ERRNO_DOMAIN;
3278 }
3279 }
3280 else
3281 {
3282 RETVAL_NEG_HUGE_VALD;
3283 NOT_MATHERRD {ERRNO_DOMAIN;}
3284 }
3285 *(double *)retval = exc.retval;
3286 break;
3287 }
3288 case y0f_negative:
3289 /* y0f(x<0) */
3290 {
3291 DOMAINF; NAMEF = (char *) "y0f";
3292 ifSVID
3293 {
3294 RETVAL_NEG_HUGEF;
3295 NOT_MATHERRF
3296 {
3297 WRITEF_Y0_NEGATIVE;
3298 ERRNO_DOMAIN;
3299 }
3300 }
3301 else
3302 {
3303 RETVAL_NEG_HUGE_VALF;
3304 NOT_MATHERRF {ERRNO_DOMAIN;}
3305 }
3306 *(float *)retval = excf.retval;
3307 break;
3308 }
3309 case y1l_negative:
3310 /* y1l(x<0) */
3311 {
3312 DOMAINL; NAMEL = (char *) "y1l";
3313 ifSVID
3314 {
3315 RETVAL_NEG_HUGEL;
3316 NOT_MATHERRL
3317 {
3318 WRITEL_Y1_NEGATIVE;
3319 ERRNO_DOMAIN;
3320 }
3321 }
3322 else
3323 {
3324 RETVAL_NEG_HUGE_VALL;
3325 NOT_MATHERRL {ERRNO_DOMAIN;}
3326 }
3327 *(long double *)retval = excl.retval;
3328 break;
3329 }
3330 case y1_negative:
3331 /* y1(x<0) */
3332 {
3333 DOMAIND; NAMED = (char *) "y1";
3334 ifSVID
3335 {
3336 RETVAL_NEG_HUGED;
3337 NOT_MATHERRD
3338 {
3339 WRITED_Y1_NEGATIUE;
3340 ERRNO_DOMAIN;
3341 }
3342 }
3343 else
3344 {
3345 RETVAL_NEG_HUGE_VALD;
3346 NOT_MATHERRD {ERRNO_DOMAIN;}
3347 }
3348 *(double *)retval = exc.retval;
3349 break;
3350 }
3351 case y1f_negative:
3352 /* y1f(x<0) */
3353 {
3354 DOMAINF; NAMEF = (char *) "y1f";
3355 ifSVID
3356 {
3357 RETVAL_NEG_HUGEF;
3358 NOT_MATHERRF
3359 {
3360 WRITEF_Y1_NEGATIVE;
3361 ERRNO_DOMAIN;
3362 }
3363 }
3364 else
3365 {
3366 RETVAL_NEG_HUGE_VALF;
3367 NOT_MATHERRF {ERRNO_DOMAIN;}
3368 }
3369 *(float *)retval = excf.retval;
3370 break;
3371 }
3372 case ynl_negative:
3373 /* ynl(x<0) */
3374 {
3375 DOMAINL; NAMEL = (char *) "ynl";
3376 ifSVID
3377 {
3378 RETVAL_NEG_HUGEL;
3379 NOT_MATHERRL
3380 {
3381 WRITEL_YN_NEGATIVE;
3382 ERRNO_DOMAIN;
3383 }
3384 }
3385 else
3386 {
3387 RETVAL_NEG_HUGE_VALL;
3388 NOT_MATHERRL {ERRNO_DOMAIN;}
3389 }
3390 *(long double *)retval = excl.retval;
3391 break;
3392 }
3393 case yn_negative:
3394 /* yn(x<0) */
3395 {
3396 DOMAIND; NAMED = (char *) "yn";
3397 ifSVID
3398 {
3399 RETVAL_NEG_HUGED;
3400 NOT_MATHERRD
3401 {
3402 WRITED_YN_NEGATIVE;
3403 ERRNO_DOMAIN;
3404 }
3405 }
3406 else
3407 {
3408 RETVAL_NEG_HUGE_VALD;
3409 NOT_MATHERRD {ERRNO_DOMAIN;}
3410 }
3411 *(double *)retval = exc.retval;
3412 break;
3413 }
3414 case ynf_negative:
3415 /* ynf(x<0) */
3416 {
3417 DOMAINF; NAMEF = (char *) "ynf";
3418 ifSVID
3419 {
3420 RETVAL_NEG_HUGEF;
3421 NOT_MATHERRF
3422 {
3423 WRITEF_YN_NEGATIVE;
3424 ERRNO_DOMAIN;
3425 }
3426 }
3427 else
3428 {
3429 RETVAL_NEG_HUGE_VALF;
3430 NOT_MATHERRF {ERRNO_DOMAIN;}
3431 }
3432 *(float *)retval = excf.retval;
3433 break;
3434 }
3435 case fmodl_by_zero:
3436 /* fmodl(x,0) */
3437 {
3438 DOMAINL; NAMEL = (char *) "fmodl";
3439 ifSVID
3440 {
3441 *(long double *)retval = *(long double *)arg1;
3442 NOT_MATHERRL
3443 {
3444 WRITEL_FMOD;
3445 ERRNO_DOMAIN;
3446 }
3447 }
3448 else
3449 { /* NaN already computed */
3450 NOT_MATHERRL {ERRNO_DOMAIN;}
3451 }
3452 *(long double *)retval = excl.retval;
3453 break;
3454 }
3455 case fmod_by_zero:
3456 /* fmod(x,0) */
3457 {
3458 DOMAIND; NAMED = (char *) "fmod";
3459 ifSVID
3460 {
3461 *(double *)retval = *(double *)arg1;
3462 NOT_MATHERRD
3463 {
3464 WRITED_FMOD;
3465 ERRNO_DOMAIN;
3466 }
3467 }
3468 else
3469 { /* NaN already computed */
3470 NOT_MATHERRD {ERRNO_DOMAIN;}
3471 }
3472 *(double *)retval = exc.retval;
3473 break;
3474 }
3475 case fmodf_by_zero:
3476 /* fmodf(x,0) */
3477 {
3478 DOMAINF; NAMEF = (char *) "fmodf";
3479 ifSVID
3480 {
3481 *(float *)retval = *(float *)arg1;
3482 NOT_MATHERRF
3483 {
3484 WRITEF_FMOD;
3485 ERRNO_DOMAIN;
3486 }
3487 }
3488 else
3489 {
3490 NOT_MATHERRF {ERRNO_DOMAIN;}
3491 }
3492 *(float *)retval = excf.retval;
3493 break;
3494 }
3495 case remainderl_by_zero:
3496 /* remainderl(x,0) */
3497 {
3498 DOMAINL; NAMEL = (char *) "remainderl";
3499 ifSVID
3500 {
3501 NOT_MATHERRL
3502 {
3503 WRITEL_REM;
3504 ERRNO_DOMAIN;
3505 }
3506 }
3507 else
3508 { /* NaN already computed */
3509 NOT_MATHERRL {ERRNO_DOMAIN;}
3510 }
3511 *(long double *)retval = excl.retval;
3512 break;
3513 }
3514 case remainder_by_zero:
3515 /* remainder(x,0) */
3516 {
3517 DOMAIND; NAMED = (char *) "remainder";
3518 ifSVID
3519 {
3520 NOT_MATHERRD
3521 {
3522 WRITED_REM;
3523 ERRNO_DOMAIN;
3524 }
3525 }
3526 else
3527 { /* NaN already computed */
3528 NOT_MATHERRD {ERRNO_DOMAIN;}
3529 }
3530 *(double *)retval = exc.retval;
3531 break;
3532 }
3533 case remainderf_by_zero:
3534 /* remainderf(x,0) */
3535 {
3536 DOMAINF; NAMEF = (char *) "remainderf";
3537 ifSVID
3538 {
3539 NOT_MATHERRF
3540 {
3541 WRITEF_REM;
3542 ERRNO_DOMAIN;
3543 }
3544 }
3545 else
3546 {
3547 NOT_MATHERRF {ERRNO_DOMAIN;}
3548 }
3549 *(float *)retval = excf.retval;
3550 break;
3551 }
3552 default:
3553 abort();
3554 }
3555 return;
3556 }
3557 }
sources.redhat.com git mirror of glibc CVS