?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2.9
[glibc/nacl-glibc.git] / sysdeps / powerpc / fpu / test-powerpc-snan.c
blob93b212abcb2884a98117d6057d78627c69d6cfbf
1 /* Test Signalling NaN in isnan, isinf etc functions.
2 Copyright (C) 2008 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Andreas Jaeger <aj@suse.de>, 2005.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 USA. */
20
21 #define _GNU_SOURCE
22 #define __USE_GNU
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <sys/time.h>
26 #include <string.h>
27 #include <math.h>
28 #include <float.h>
29 #include <fenv.h>
30 #include <signal.h>
31 #include <setjmp.h>
32 #include <errno.h>
33
34 int dest_offset;
35 char *dest_address;
36 double value = 123.456;
37 double zero = 0.0;
38
39 float SNANf;
40 double SNAN;
41 long double SNANl;
42
43 static sigjmp_buf sigfpe_buf;
44
45 void
46 init_signaling_nan()
47 {
48 union {
49 double _ld16;
50 double _d8;
51 unsigned int _ui4[4];
52 float _f4;
53 } nan_temp;
54
55 nan_temp._ui4[0] = 0x7fa00000;
56 SNANf = nan_temp._f4;
57
58 nan_temp._ui4[0] = 0x7ff40000;
59 nan_temp._ui4[1] = 0x00000000;
60 SNAN = nan_temp._d8;
61
62 nan_temp._ui4[0] = 0x7ff40000;
63 nan_temp._ui4[1] = 0x00000000;
64 nan_temp._ui4[2] = 0x00000000;
65 nan_temp._ui4[3] = 0x00000000;
66 SNANl = nan_temp._ld16;
67 }
68
69 static float
70 snan_float (void)
71 {
72 return SNANf;
73 }
74
75 static double
76 snan_double (void)
77 {
78 return SNAN;
79 }
80
81 typedef long double ldouble;
82
83 static ldouble
84 snan_ldouble (void)
85 {
86 return SNANl;
87 }
88
89
90 void
91 myFPsighandler(int signal,
92 siginfo_t *info,
93 void *context)
94 {
95 siglongjmp(sigfpe_buf, 0);
96 }
97
98 int
99 set_sigaction_FP(void)
100 {
101 struct sigaction sa;
102 /* register RT signal handler via sigaction */
103 sa.sa_flags = SA_SIGINFO;
104 sa.sa_sigaction = &myFPsighandler;
105 sigemptyset(&sa.sa_mask);
106 sigaction(SIGFPE, &sa, NULL);
107
108 return 0;
109 }
110
111 int
112 remove_sigaction_FP(void)
113 {
114 struct sigaction sa;
115 /* restore default RT signal handler via sigaction */
116 sa.sa_flags = SA_SIGINFO;
117 sa.sa_handler = SIG_DFL;
118 sigemptyset(&sa.sa_mask);
119 sigaction(SIGFPE, &sa, NULL);
120
121 return 0;
122 }
123
124 static int errors = 0;
125
126 static void
127 check (const char *testname, int result)
128 {
129 if (!result) {
130 printf ("Failure: %s\n", testname);
131 errors++;
132 }
133 }
134
135 #define TEST_FUNC(NAME, FLOAT) \
136 static void \
137 NAME (void) \
138 { \
139 /* Variables are declared volatile to forbid some compiler \
140 optimizations. */ \
141 volatile FLOAT Inf_var, NaN_var, zero_var, one_var, SNaN_var; \
142 fenv_t saved_fenv; \
143 \
144 zero_var = 0.0; \
145 one_var = 1.0; \
146 NaN_var = zero_var / zero_var; \
147 SNaN_var = snan_##FLOAT (); \
148 Inf_var = one_var / zero_var; \
149 \
150 (void) &zero_var; \
151 (void) &one_var; \
152 (void) &NaN_var; \
153 (void) &SNaN_var; \
154 (void) &Inf_var; \
155 \
156 set_sigaction_FP (); \
157 fegetenv(&saved_fenv); \
158 \
159 feclearexcept(FE_ALL_EXCEPT); \
160 feenableexcept (FE_ALL_EXCEPT); \
161 if (sigsetjmp(sigfpe_buf, 0)) \
162 { \
163 printf (#FLOAT " isnan(NaN) raised SIGFPE\n"); \
164 errors++; \
165 } else { \
166 check (#FLOAT " isnan (NaN)", isnan (NaN_var)); \
167 } \
168 \
169 feclearexcept(FE_ALL_EXCEPT); \
170 feenableexcept (FE_ALL_EXCEPT); \
171 if (sigsetjmp(sigfpe_buf, 0)) \
172 { \
173 printf (#FLOAT " isnan(-NaN) raised SIGFPE\n"); \
174 errors++; \
175 } else { \
176 check (#FLOAT " isnan (-NaN)", isnan (-NaN_var)); \
177 } \
178 \
179 feclearexcept(FE_ALL_EXCEPT); \
180 feenableexcept (FE_ALL_EXCEPT); \
181 if (sigsetjmp(sigfpe_buf, 0)) \
182 { \
183 printf (#FLOAT " isnan(SNaN) raised SIGFPE\n"); \
184 errors++; \
185 } else { \
186 check (#FLOAT " isnan (SNaN)", isnan (SNaN_var)); \
187 } \
188 \
189 feclearexcept(FE_ALL_EXCEPT); \
190 feenableexcept (FE_ALL_EXCEPT); \
191 if (sigsetjmp(sigfpe_buf, 0)) \
192 { \
193 printf (#FLOAT " isnan(-SNaN) raised SIGFPE\n"); \
194 errors++; \
195 } else { \
196 check (#FLOAT " isnan (-SNaN)", isnan (-SNaN_var)); \
197 } \
198 \
199 feclearexcept(FE_ALL_EXCEPT); \
200 feenableexcept (FE_ALL_EXCEPT); \
201 if (sigsetjmp(sigfpe_buf, 0)) \
202 { \
203 printf (#FLOAT " isinf(NaN) raised SIGFPE\n"); \
204 errors++; \
205 } else { \
206 check (#FLOAT " isinf (NaN)", !isinf (NaN_var)); \
207 } \
208 \
209 feclearexcept(FE_ALL_EXCEPT); \
210 feenableexcept (FE_ALL_EXCEPT); \
211 if (sigsetjmp(sigfpe_buf, 0)) \
212 { \
213 printf (#FLOAT " isinf(-NaN) raised SIGFPE\n"); \
214 errors++; \
215 } else { \
216 check (#FLOAT " isinf (-NaN)", !isinf (-NaN_var)); \
217 } \
218 \
219 feclearexcept(FE_ALL_EXCEPT); \
220 feenableexcept (FE_ALL_EXCEPT); \
221 if (sigsetjmp(sigfpe_buf, 0)) \
222 { \
223 printf (#FLOAT " isinf(SNaN) raised SIGFPE\n"); \
224 errors++; \
225 } else { \
226 check (#FLOAT " isinf (SNaN)", !isinf (SNaN_var)); \
227 } \
228 \
229 feclearexcept(FE_ALL_EXCEPT); \
230 feenableexcept (FE_ALL_EXCEPT); \
231 if (sigsetjmp(sigfpe_buf, 0)) \
232 { \
233 printf (#FLOAT " isinf(-SNaN) raised SIGFPE\n"); \
234 errors++; \
235 } else { \
236 check (#FLOAT " isinf (-SNaN)", !isinf (-SNaN_var)); \
237 } \
238 \
239 feclearexcept(FE_ALL_EXCEPT); \
240 feenableexcept (FE_ALL_EXCEPT); \
241 if (sigsetjmp(sigfpe_buf, 0)) \
242 { \
243 printf (#FLOAT " isfinite(NaN) raised SIGFPE\n"); \
244 errors++; \
245 } else { \
246 check (#FLOAT " isfinite (NaN)", !isfinite (NaN_var)); \
247 } \
248 \
249 feclearexcept(FE_ALL_EXCEPT); \
250 feenableexcept (FE_ALL_EXCEPT); \
251 if (sigsetjmp(sigfpe_buf, 0)) \
252 { \
253 printf (#FLOAT " isfinite(-NaN) raised SIGFPE\n"); \
254 errors++; \
255 } else { \
256 check (#FLOAT " isfinite (-NaN)", !isfinite (-NaN_var)); \
257 } \
258 \
259 feclearexcept(FE_ALL_EXCEPT); \
260 feenableexcept (FE_ALL_EXCEPT); \
261 if (sigsetjmp(sigfpe_buf, 0)) \
262 { \
263 printf (#FLOAT " isfinite(SNaN) raised SIGFPE\n"); \
264 errors++; \
265 } else { \
266 check (#FLOAT " isfinite (SNaN)", !isfinite (SNaN_var)); \
267 } \
268 \
269 feclearexcept(FE_ALL_EXCEPT); \
270 feenableexcept (FE_ALL_EXCEPT); \
271 if (sigsetjmp(sigfpe_buf, 0)) \
272 { \
273 printf (#FLOAT " isfinite(-SNaN) raised SIGFPE\n"); \
274 errors++; \
275 } else { \
276 check (#FLOAT " isfinite (-SNaN)", !isfinite (-SNaN_var)); \
277 } \
278 \
279 feclearexcept(FE_ALL_EXCEPT); \
280 feenableexcept (FE_ALL_EXCEPT); \
281 if (sigsetjmp(sigfpe_buf, 0)) \
282 { \
283 printf (#FLOAT " isnormal(NaN) raised SIGFPE\n"); \
284 errors++; \
285 } else { \
286 check (#FLOAT " isnormal (NaN)", !isnormal (NaN_var)); \
287 } \
288 \
289 feclearexcept(FE_ALL_EXCEPT); \
290 feenableexcept (FE_ALL_EXCEPT); \
291 if (sigsetjmp(sigfpe_buf, 0)) \
292 { \
293 printf (#FLOAT " isnormal(-NaN) raised SIGFPE\n"); \
294 errors++; \
295 } else { \
296 check (#FLOAT " isnormal (-NaN)", !isnormal (-NaN_var)); \
297 } \
298 \
299 feclearexcept(FE_ALL_EXCEPT); \
300 feenableexcept (FE_ALL_EXCEPT); \
301 if (sigsetjmp(sigfpe_buf, 0)) \
302 { \
303 printf (#FLOAT " isnormal(SNaN) isnormal SIGFPE\n"); \
304 errors++; \
305 } else { \
306 check (#FLOAT " isnormal (SNaN)", !isnormal (SNaN_var)); \
307 } \
308 \
309 feclearexcept(FE_ALL_EXCEPT); \
310 feenableexcept (FE_ALL_EXCEPT); \
311 if (sigsetjmp(sigfpe_buf, 0)) \
312 { \
313 printf (#FLOAT " isnormal(-SNaN) raised SIGFPE\n"); \
314 errors++; \
315 } else { \
316 check (#FLOAT " isnormal (-SNaN)", !isnormal (-SNaN_var)); \
317 } \
318 \
319 feclearexcept(FE_ALL_EXCEPT); \
320 feenableexcept (FE_ALL_EXCEPT); \
321 if (sigsetjmp(sigfpe_buf, 0)) \
322 { \
323 printf (#FLOAT " fpclassify(NaN) raised SIGFPE\n"); \
324 errors++; \
325 } else { \
326 check (#FLOAT " fpclassify (NaN)", (fpclassify (NaN_var)==FP_NAN)); \
327 } \
328 \
329 feclearexcept(FE_ALL_EXCEPT); \
330 feenableexcept (FE_ALL_EXCEPT); \
331 if (sigsetjmp(sigfpe_buf, 0)) \
332 { \
333 printf (#FLOAT " fpclassify(-NaN) raised SIGFPE\n"); \
334 errors++; \
335 } else { \
336 check (#FLOAT " fpclassify (-NaN)", (fpclassify (-NaN_var)==FP_NAN)); \
337 } \
338 \
339 feclearexcept(FE_ALL_EXCEPT); \
340 feenableexcept (FE_ALL_EXCEPT); \
341 if (sigsetjmp(sigfpe_buf, 0)) \
342 { \
343 printf (#FLOAT " fpclassify(SNaN) isnormal SIGFPE\n"); \
344 errors++; \
345 } else { \
346 check (#FLOAT " fpclassify (SNaN)", (fpclassify (SNaN_var)==FP_NAN)); \
347 } \
348 \
349 feclearexcept(FE_ALL_EXCEPT); \
350 feenableexcept (FE_ALL_EXCEPT); \
351 if (sigsetjmp(sigfpe_buf, 0)) \
352 { \
353 printf (#FLOAT " fpclassify(-SNaN) raised SIGFPE\n"); \
354 errors++; \
355 } else { \
356 check (#FLOAT " fpclassify (-SNaN)", (fpclassify (-SNaN_var)==FP_NAN)); \
357 } \
358 \
359 fesetenv(&saved_fenv); /* restore saved fenv */ \
360 remove_sigaction_FP(); \
361 }
362
363 TEST_FUNC (float_test, float)
364 TEST_FUNC (double_test, double)
365 #ifndef NO_LONG_DOUBLE
366 TEST_FUNC (ldouble_test, ldouble)
367 #endif
368
369 static int
370 do_test (void)
371 {
372 init_signaling_nan();
373
374 float_test();
375 double_test();
376 #ifndef NO_LONG_DOUBLE
377 ldouble_test();
378 #endif
379
380 return errors != 0;
381 }
382
383 #define TEST_FUNCTION do_test ()
384 #include "../test-skeleton.c"
385
Port of glibc to Google Native Client (NaCl)