1 /* Test SSE exceptions.  */
2 
3 #include <float.h>
4 #include <stdint.h>
5 #include <stdio.h>
6 
7 volatile float f_res;
8 volatile double d_res;
9 
10 volatile float f_snan = __builtin_nansf("");
11 volatile float f_half = 0.5f;
12 volatile float f_third = 1.0f / 3.0f;
13 volatile float f_nan = __builtin_nanl("");
14 volatile float f_inf = __builtin_inff();
15 volatile float f_ninf = -__builtin_inff();
16 volatile float f_one = 1.0f;
17 volatile float f_two = 2.0f;
18 volatile float f_zero = 0.0f;
19 volatile float f_nzero = -0.0f;
20 volatile float f_min = FLT_MIN;
21 volatile float f_true_min = 0x1p-149f;
22 volatile float f_max = FLT_MAX;
23 volatile float f_nmax = -FLT_MAX;
24 
25 volatile double d_snan = __builtin_nans("");
26 volatile double d_half = 0.5;
27 volatile double d_third = 1.0 / 3.0;
28 volatile double d_nan = __builtin_nan("");
29 volatile double d_inf = __builtin_inf();
30 volatile double d_ninf = -__builtin_inf();
31 volatile double d_one = 1.0;
32 volatile double d_two = 2.0;
33 volatile double d_zero = 0.0;
34 volatile double d_nzero = -0.0;
35 volatile double d_min = DBL_MIN;
36 volatile double d_true_min = 0x1p-1074;
37 volatile double d_max = DBL_MAX;
38 volatile double d_nmax = -DBL_MAX;
39 
40 volatile int32_t i32_max = INT32_MAX;
41 
42 #define IE (1 << 0)
43 #define ZE (1 << 2)
44 #define OE (1 << 3)
45 #define UE (1 << 4)
46 #define PE (1 << 5)
47 #define EXC (IE | ZE | OE | UE | PE)
48 
49 uint32_t mxcsr_default = 0x1f80;
50 uint32_t mxcsr_ftz = 0x9f80;
51 
main(void)52 int main(void)
53 {
54     uint32_t mxcsr;
55     int32_t i32_res;
56     int ret = 0;
57 
58     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
59     d_res = f_snan;
60     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
61     if ((mxcsr & EXC) != IE) {
62         printf("FAIL: widen float snan\n");
63         ret = 1;
64     }
65 
66     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
67     f_res = d_min;
68     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
69     if ((mxcsr & EXC) != (UE | PE)) {
70         printf("FAIL: narrow float underflow\n");
71         ret = 1;
72     }
73 
74     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
75     f_res = d_max;
76     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
77     if ((mxcsr & EXC) != (OE | PE)) {
78         printf("FAIL: narrow float overflow\n");
79         ret = 1;
80     }
81 
82     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
83     f_res = d_third;
84     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
85     if ((mxcsr & EXC) != PE) {
86         printf("FAIL: narrow float inexact\n");
87         ret = 1;
88     }
89 
90     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
91     f_res = d_snan;
92     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
93     if ((mxcsr & EXC) != IE) {
94         printf("FAIL: narrow float snan\n");
95         ret = 1;
96     }
97 
98     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
99     __asm__ volatile ("roundss $4, %0, %0" : "=x" (f_res) : "0" (f_min));
100     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
101     if ((mxcsr & EXC) != PE) {
102         printf("FAIL: roundss min\n");
103         ret = 1;
104     }
105     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
106     __asm__ volatile ("roundss $12, %0, %0" : "=x" (f_res) : "0" (f_min));
107     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
108     if ((mxcsr & EXC) != 0) {
109         printf("FAIL: roundss no-inexact min\n");
110         ret = 1;
111     }
112     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
113     __asm__ volatile ("roundss $4, %0, %0" : "=x" (f_res) : "0" (f_snan));
114     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
115     if ((mxcsr & EXC) != IE) {
116         printf("FAIL: roundss snan\n");
117         ret = 1;
118     }
119     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
120     __asm__ volatile ("roundss $12, %0, %0" : "=x" (f_res) : "0" (f_snan));
121     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
122     if ((mxcsr & EXC) != IE) {
123         printf("FAIL: roundss no-inexact snan\n");
124         ret = 1;
125     }
126 
127     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
128     __asm__ volatile ("roundsd $4, %0, %0" : "=x" (d_res) : "0" (d_min));
129     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
130     if ((mxcsr & EXC) != PE) {
131         printf("FAIL: roundsd min\n");
132         ret = 1;
133     }
134     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
135     __asm__ volatile ("roundsd $12, %0, %0" : "=x" (d_res) : "0" (d_min));
136     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
137     if ((mxcsr & EXC) != 0) {
138         printf("FAIL: roundsd no-inexact min\n");
139         ret = 1;
140     }
141     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
142     __asm__ volatile ("roundsd $4, %0, %0" : "=x" (d_res) : "0" (d_snan));
143     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
144     if ((mxcsr & EXC) != IE) {
145         printf("FAIL: roundsd snan\n");
146         ret = 1;
147     }
148     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
149     __asm__ volatile ("roundsd $12, %0, %0" : "=x" (d_res) : "0" (d_snan));
150     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
151     if ((mxcsr & EXC) != IE) {
152         printf("FAIL: roundsd no-inexact snan\n");
153         ret = 1;
154     }
155 
156     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
157     __asm__ volatile ("comiss %1, %0" : : "x" (f_nan), "x" (f_zero));
158     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
159     if ((mxcsr & EXC) != IE) {
160         printf("FAIL: comiss nan\n");
161         ret = 1;
162     }
163     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
164     __asm__ volatile ("ucomiss %1, %0" : : "x" (f_nan), "x" (f_zero));
165     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
166     if ((mxcsr & EXC) != 0) {
167         printf("FAIL: ucomiss nan\n");
168         ret = 1;
169     }
170     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
171     __asm__ volatile ("ucomiss %1, %0" : : "x" (f_snan), "x" (f_zero));
172     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
173     if ((mxcsr & EXC) != IE) {
174         printf("FAIL: ucomiss snan\n");
175         ret = 1;
176     }
177 
178     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
179     __asm__ volatile ("comisd %1, %0" : : "x" (d_nan), "x" (d_zero));
180     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
181     if ((mxcsr & EXC) != IE) {
182         printf("FAIL: comisd nan\n");
183         ret = 1;
184     }
185     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
186     __asm__ volatile ("ucomisd %1, %0" : : "x" (d_nan), "x" (d_zero));
187     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
188     if ((mxcsr & EXC) != 0) {
189         printf("FAIL: ucomisd nan\n");
190         ret = 1;
191     }
192     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
193     __asm__ volatile ("ucomisd %1, %0" : : "x" (d_snan), "x" (d_zero));
194     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
195     if ((mxcsr & EXC) != IE) {
196         printf("FAIL: ucomisd snan\n");
197         ret = 1;
198     }
199 
200     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
201     f_res = f_max + f_max;
202     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
203     if ((mxcsr & EXC) != (OE | PE)) {
204         printf("FAIL: float add overflow\n");
205         ret = 1;
206     }
207     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
208     f_res = f_max + f_min;
209     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
210     if ((mxcsr & EXC) != PE) {
211         printf("FAIL: float add inexact\n");
212         ret = 1;
213     }
214     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
215     f_res = f_inf + f_ninf;
216     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
217     if ((mxcsr & EXC) != IE) {
218         printf("FAIL: float add inf -inf\n");
219         ret = 1;
220     }
221     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
222     f_res = f_snan + f_third;
223     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
224     if ((mxcsr & EXC) != IE) {
225         printf("FAIL: float add snan\n");
226         ret = 1;
227     }
228     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_ftz));
229     f_res = f_true_min + f_true_min;
230     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
231     if ((mxcsr & EXC) != (UE | PE)) {
232         printf("FAIL: float add FTZ underflow\n");
233         ret = 1;
234     }
235 
236     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
237     d_res = d_max + d_max;
238     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
239     if ((mxcsr & EXC) != (OE | PE)) {
240         printf("FAIL: double add overflow\n");
241         ret = 1;
242     }
243     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
244     d_res = d_max + d_min;
245     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
246     if ((mxcsr & EXC) != PE) {
247         printf("FAIL: double add inexact\n");
248         ret = 1;
249     }
250     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
251     d_res = d_inf + d_ninf;
252     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
253     if ((mxcsr & EXC) != IE) {
254         printf("FAIL: double add inf -inf\n");
255         ret = 1;
256     }
257     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
258     d_res = d_snan + d_third;
259     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
260     if ((mxcsr & EXC) != IE) {
261         printf("FAIL: double add snan\n");
262         ret = 1;
263     }
264     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_ftz));
265     d_res = d_true_min + d_true_min;
266     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
267     if ((mxcsr & EXC) != (UE | PE)) {
268         printf("FAIL: double add FTZ underflow\n");
269         ret = 1;
270     }
271 
272     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
273     f_res = f_max - f_nmax;
274     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
275     if ((mxcsr & EXC) != (OE | PE)) {
276         printf("FAIL: float sub overflow\n");
277         ret = 1;
278     }
279     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
280     f_res = f_max - f_min;
281     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
282     if ((mxcsr & EXC) != PE) {
283         printf("FAIL: float sub inexact\n");
284         ret = 1;
285     }
286     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
287     f_res = f_inf - f_inf;
288     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
289     if ((mxcsr & EXC) != IE) {
290         printf("FAIL: float sub inf inf\n");
291         ret = 1;
292     }
293     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
294     f_res = f_snan - f_third;
295     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
296     if ((mxcsr & EXC) != IE) {
297         printf("FAIL: float sub snan\n");
298         ret = 1;
299     }
300     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_ftz));
301     f_res = f_min - f_true_min;
302     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
303     if ((mxcsr & EXC) != (UE | PE)) {
304         printf("FAIL: float sub FTZ underflow\n");
305         ret = 1;
306     }
307 
308     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
309     d_res = d_max - d_nmax;
310     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
311     if ((mxcsr & EXC) != (OE | PE)) {
312         printf("FAIL: double sub overflow\n");
313         ret = 1;
314     }
315     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
316     d_res = d_max - d_min;
317     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
318     if ((mxcsr & EXC) != PE) {
319         printf("FAIL: double sub inexact\n");
320         ret = 1;
321     }
322     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
323     d_res = d_inf - d_inf;
324     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
325     if ((mxcsr & EXC) != IE) {
326         printf("FAIL: double sub inf inf\n");
327         ret = 1;
328     }
329     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
330     d_res = d_snan - d_third;
331     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
332     if ((mxcsr & EXC) != IE) {
333         printf("FAIL: double sub snan\n");
334         ret = 1;
335     }
336     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_ftz));
337     d_res = d_min - d_true_min;
338     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
339     if ((mxcsr & EXC) != (UE | PE)) {
340         printf("FAIL: double sub FTZ underflow\n");
341         ret = 1;
342     }
343 
344     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
345     f_res = f_max * f_max;
346     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
347     if ((mxcsr & EXC) != (OE | PE)) {
348         printf("FAIL: float mul overflow\n");
349         ret = 1;
350     }
351     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
352     f_res = f_third * f_third;
353     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
354     if ((mxcsr & EXC) != PE) {
355         printf("FAIL: float mul inexact\n");
356         ret = 1;
357     }
358     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
359     f_res = f_min * f_min;
360     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
361     if ((mxcsr & EXC) != (UE | PE)) {
362         printf("FAIL: float mul underflow\n");
363         ret = 1;
364     }
365     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
366     f_res = f_inf * f_zero;
367     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
368     if ((mxcsr & EXC) != IE) {
369         printf("FAIL: float mul inf 0\n");
370         ret = 1;
371     }
372     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
373     f_res = f_snan * f_third;
374     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
375     if ((mxcsr & EXC) != IE) {
376         printf("FAIL: float mul snan\n");
377         ret = 1;
378     }
379     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_ftz));
380     f_res = f_min * f_half;
381     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
382     if ((mxcsr & EXC) != (UE | PE)) {
383         printf("FAIL: float mul FTZ underflow\n");
384         ret = 1;
385     }
386 
387     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
388     d_res = d_max * d_max;
389     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
390     if ((mxcsr & EXC) != (OE | PE)) {
391         printf("FAIL: double mul overflow\n");
392         ret = 1;
393     }
394     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
395     d_res = d_third * d_third;
396     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
397     if ((mxcsr & EXC) != PE) {
398         printf("FAIL: double mul inexact\n");
399         ret = 1;
400     }
401     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
402     d_res = d_min * d_min;
403     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
404     if ((mxcsr & EXC) != (UE | PE)) {
405         printf("FAIL: double mul underflow\n");
406         ret = 1;
407     }
408     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
409     d_res = d_inf * d_zero;
410     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
411     if ((mxcsr & EXC) != IE) {
412         printf("FAIL: double mul inf 0\n");
413         ret = 1;
414     }
415     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
416     d_res = d_snan * d_third;
417     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
418     if ((mxcsr & EXC) != IE) {
419         printf("FAIL: double mul snan\n");
420         ret = 1;
421     }
422     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_ftz));
423     d_res = d_min * d_half;
424     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
425     if ((mxcsr & EXC) != (UE | PE)) {
426         printf("FAIL: double mul FTZ underflow\n");
427         ret = 1;
428     }
429 
430     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
431     f_res = f_max / f_min;
432     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
433     if ((mxcsr & EXC) != (OE | PE)) {
434         printf("FAIL: float div overflow\n");
435         ret = 1;
436     }
437     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
438     f_res = f_one / f_third;
439     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
440     if ((mxcsr & EXC) != PE) {
441         printf("FAIL: float div inexact\n");
442         ret = 1;
443     }
444     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
445     f_res = f_min / f_max;
446     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
447     if ((mxcsr & EXC) != (UE | PE)) {
448         printf("FAIL: float div underflow\n");
449         ret = 1;
450     }
451     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
452     f_res = f_one / f_zero;
453     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
454     if ((mxcsr & EXC) != ZE) {
455         printf("FAIL: float div 1 0\n");
456         ret = 1;
457     }
458     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
459     f_res = f_inf / f_zero;
460     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
461     if ((mxcsr & EXC) != 0) {
462         printf("FAIL: float div inf 0\n");
463         ret = 1;
464     }
465     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
466     f_res = f_nan / f_zero;
467     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
468     if ((mxcsr & EXC) != 0) {
469         printf("FAIL: float div nan 0\n");
470         ret = 1;
471     }
472     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
473     f_res = f_zero / f_zero;
474     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
475     if ((mxcsr & EXC) != IE) {
476         printf("FAIL: float div 0 0\n");
477         ret = 1;
478     }
479     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
480     f_res = f_inf / f_inf;
481     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
482     if ((mxcsr & EXC) != IE) {
483         printf("FAIL: float div inf inf\n");
484         ret = 1;
485     }
486     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
487     f_res = f_snan / f_third;
488     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
489     if ((mxcsr & EXC) != IE) {
490         printf("FAIL: float div snan\n");
491         ret = 1;
492     }
493     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_ftz));
494     f_res = f_min / f_two;
495     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
496     if ((mxcsr & EXC) != (UE | PE)) {
497         printf("FAIL: float div FTZ underflow\n");
498         ret = 1;
499     }
500 
501     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
502     d_res = d_max / d_min;
503     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
504     if ((mxcsr & EXC) != (OE | PE)) {
505         printf("FAIL: double div overflow\n");
506         ret = 1;
507     }
508     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
509     d_res = d_one / d_third;
510     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
511     if ((mxcsr & EXC) != PE) {
512         printf("FAIL: double div inexact\n");
513         ret = 1;
514     }
515     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
516     d_res = d_min / d_max;
517     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
518     if ((mxcsr & EXC) != (UE | PE)) {
519         printf("FAIL: double div underflow\n");
520         ret = 1;
521     }
522     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
523     d_res = d_one / d_zero;
524     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
525     if ((mxcsr & EXC) != ZE) {
526         printf("FAIL: double div 1 0\n");
527         ret = 1;
528     }
529     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
530     d_res = d_inf / d_zero;
531     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
532     if ((mxcsr & EXC) != 0) {
533         printf("FAIL: double div inf 0\n");
534         ret = 1;
535     }
536     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
537     d_res = d_nan / d_zero;
538     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
539     if ((mxcsr & EXC) != 0) {
540         printf("FAIL: double div nan 0\n");
541         ret = 1;
542     }
543     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
544     d_res = d_zero / d_zero;
545     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
546     if ((mxcsr & EXC) != IE) {
547         printf("FAIL: double div 0 0\n");
548         ret = 1;
549     }
550     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
551     d_res = d_inf / d_inf;
552     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
553     if ((mxcsr & EXC) != IE) {
554         printf("FAIL: double div inf inf\n");
555         ret = 1;
556     }
557     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
558     d_res = d_snan / d_third;
559     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
560     if ((mxcsr & EXC) != IE) {
561         printf("FAIL: double div snan\n");
562         ret = 1;
563     }
564     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_ftz));
565     d_res = d_min / d_two;
566     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
567     if ((mxcsr & EXC) != (UE | PE)) {
568         printf("FAIL: double div FTZ underflow\n");
569         ret = 1;
570     }
571 
572     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
573     __asm__ volatile ("sqrtss %0, %0" : "=x" (f_res) : "0" (f_max));
574     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
575     if ((mxcsr & EXC) != PE) {
576         printf("FAIL: sqrtss inexact\n");
577         ret = 1;
578     }
579     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
580     __asm__ volatile ("sqrtss %0, %0" : "=x" (f_res) : "0" (f_nmax));
581     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
582     if ((mxcsr & EXC) != IE) {
583         printf("FAIL: sqrtss -max\n");
584         ret = 1;
585     }
586     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
587     __asm__ volatile ("sqrtss %0, %0" : "=x" (f_res) : "0" (f_ninf));
588     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
589     if ((mxcsr & EXC) != IE) {
590         printf("FAIL: sqrtss -inf\n");
591         ret = 1;
592     }
593     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
594     __asm__ volatile ("sqrtss %0, %0" : "=x" (f_res) : "0" (f_snan));
595     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
596     if ((mxcsr & EXC) != IE) {
597         printf("FAIL: sqrtss snan\n");
598         ret = 1;
599     }
600     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
601     __asm__ volatile ("sqrtss %0, %0" : "=x" (f_res) : "0" (f_nzero));
602     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
603     if ((mxcsr & EXC) != 0) {
604         printf("FAIL: sqrtss -0\n");
605         ret = 1;
606     }
607     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
608     __asm__ volatile ("sqrtss %0, %0" : "=x" (f_res) :
609                       "0" (-__builtin_nanf("")));
610     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
611     if ((mxcsr & EXC) != 0) {
612         printf("FAIL: sqrtss -nan\n");
613         ret = 1;
614     }
615 
616     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
617     __asm__ volatile ("sqrtsd %0, %0" : "=x" (d_res) : "0" (d_max));
618     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
619     if ((mxcsr & EXC) != PE) {
620         printf("FAIL: sqrtsd inexact\n");
621         ret = 1;
622     }
623     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
624     __asm__ volatile ("sqrtsd %0, %0" : "=x" (d_res) : "0" (d_nmax));
625     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
626     if ((mxcsr & EXC) != IE) {
627         printf("FAIL: sqrtsd -max\n");
628         ret = 1;
629     }
630     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
631     __asm__ volatile ("sqrtsd %0, %0" : "=x" (d_res) : "0" (d_ninf));
632     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
633     if ((mxcsr & EXC) != IE) {
634         printf("FAIL: sqrtsd -inf\n");
635         ret = 1;
636     }
637     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
638     __asm__ volatile ("sqrtsd %0, %0" : "=x" (d_res) : "0" (d_snan));
639     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
640     if ((mxcsr & EXC) != IE) {
641         printf("FAIL: sqrtsd snan\n");
642         ret = 1;
643     }
644     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
645     __asm__ volatile ("sqrtsd %0, %0" : "=x" (d_res) : "0" (d_nzero));
646     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
647     if ((mxcsr & EXC) != 0) {
648         printf("FAIL: sqrtsd -0\n");
649         ret = 1;
650     }
651     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
652     __asm__ volatile ("sqrtsd %0, %0" : "=x" (d_res) :
653                       "0" (-__builtin_nan("")));
654     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
655     if ((mxcsr & EXC) != 0) {
656         printf("FAIL: sqrtsd -nan\n");
657         ret = 1;
658     }
659 
660     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
661     __asm__ volatile ("maxss %1, %0" : : "x" (f_nan), "x" (f_zero));
662     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
663     if ((mxcsr & EXC) != IE) {
664         printf("FAIL: maxss nan\n");
665         ret = 1;
666     }
667     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
668     __asm__ volatile ("minss %1, %0" : : "x" (f_nan), "x" (f_zero));
669     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
670     if ((mxcsr & EXC) != IE) {
671         printf("FAIL: minss nan\n");
672         ret = 1;
673     }
674 
675     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
676     __asm__ volatile ("maxsd %1, %0" : : "x" (d_nan), "x" (d_zero));
677     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
678     if ((mxcsr & EXC) != IE) {
679         printf("FAIL: maxsd nan\n");
680         ret = 1;
681     }
682     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
683     __asm__ volatile ("minsd %1, %0" : : "x" (d_nan), "x" (d_zero));
684     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
685     if ((mxcsr & EXC) != IE) {
686         printf("FAIL: minsd nan\n");
687         ret = 1;
688     }
689 
690     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
691     __asm__ volatile ("cvtsi2ss %1, %0" : "=x" (f_res) : "m" (i32_max));
692     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
693     if ((mxcsr & EXC) != PE) {
694         printf("FAIL: cvtsi2ss inexact\n");
695         ret = 1;
696     }
697 
698     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
699     __asm__ volatile ("cvtsi2sd %1, %0" : "=x" (d_res) : "m" (i32_max));
700     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
701     if ((mxcsr & EXC) != 0) {
702         printf("FAIL: cvtsi2sd exact\n");
703         ret = 1;
704     }
705 
706     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
707     __asm__ volatile ("cvtss2si %1, %0" : "=r" (i32_res) : "x" (1.5f));
708     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
709     if ((mxcsr & EXC) != PE) {
710         printf("FAIL: cvtss2si inexact\n");
711         ret = 1;
712     }
713     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
714     __asm__ volatile ("cvtss2si %1, %0" : "=r" (i32_res) : "x" (0x1p31f));
715     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
716     if ((mxcsr & EXC) != IE) {
717         printf("FAIL: cvtss2si 0x1p31\n");
718         ret = 1;
719     }
720     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
721     __asm__ volatile ("cvtss2si %1, %0" : "=r" (i32_res) : "x" (f_inf));
722     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
723     if ((mxcsr & EXC) != IE) {
724         printf("FAIL: cvtss2si inf\n");
725         ret = 1;
726     }
727 
728     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
729     __asm__ volatile ("cvtsd2si %1, %0" : "=r" (i32_res) : "x" (1.5));
730     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
731     if ((mxcsr & EXC) != PE) {
732         printf("FAIL: cvtsd2si inexact\n");
733         ret = 1;
734     }
735     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
736     __asm__ volatile ("cvtsd2si %1, %0" : "=r" (i32_res) : "x" (0x1p31));
737     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
738     if ((mxcsr & EXC) != IE) {
739         printf("FAIL: cvtsd2si 0x1p31\n");
740         ret = 1;
741     }
742     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
743     __asm__ volatile ("cvtsd2si %1, %0" : "=r" (i32_res) : "x" (d_inf));
744     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
745     if ((mxcsr & EXC) != IE) {
746         printf("FAIL: cvtsd2si inf\n");
747         ret = 1;
748     }
749 
750     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
751     __asm__ volatile ("cvttss2si %1, %0" : "=r" (i32_res) : "x" (1.5f));
752     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
753     if ((mxcsr & EXC) != PE) {
754         printf("FAIL: cvttss2si inexact\n");
755         ret = 1;
756     }
757     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
758     __asm__ volatile ("cvttss2si %1, %0" : "=r" (i32_res) : "x" (0x1p31f));
759     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
760     if ((mxcsr & EXC) != IE) {
761         printf("FAIL: cvttss2si 0x1p31\n");
762         ret = 1;
763     }
764     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
765     __asm__ volatile ("cvttss2si %1, %0" : "=r" (i32_res) : "x" (f_inf));
766     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
767     if ((mxcsr & EXC) != IE) {
768         printf("FAIL: cvttss2si inf\n");
769         ret = 1;
770     }
771 
772     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
773     __asm__ volatile ("cvttsd2si %1, %0" : "=r" (i32_res) : "x" (1.5));
774     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
775     if ((mxcsr & EXC) != PE) {
776         printf("FAIL: cvttsd2si inexact\n");
777         ret = 1;
778     }
779     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
780     __asm__ volatile ("cvttsd2si %1, %0" : "=r" (i32_res) : "x" (0x1p31));
781     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
782     if ((mxcsr & EXC) != IE) {
783         printf("FAIL: cvttsd2si 0x1p31\n");
784         ret = 1;
785     }
786     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
787     __asm__ volatile ("cvttsd2si %1, %0" : "=r" (i32_res) : "x" (d_inf));
788     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
789     if ((mxcsr & EXC) != IE) {
790         printf("FAIL: cvttsd2si inf\n");
791         ret = 1;
792     }
793 
794     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
795     __asm__ volatile ("rcpss %0, %0" : "=x" (f_res) : "0" (f_snan));
796     f_res += f_one;
797     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
798     if ((mxcsr & EXC) != 0) {
799         printf("FAIL: rcpss snan\n");
800         ret = 1;
801     }
802 
803     __asm__ volatile ("ldmxcsr %0" : : "m" (mxcsr_default));
804     __asm__ volatile ("rsqrtss %0, %0" : "=x" (f_res) : "0" (f_snan));
805     f_res += f_one;
806     __asm__ volatile ("stmxcsr %0" : "=m" (mxcsr));
807     if ((mxcsr & EXC) != 0) {
808         printf("FAIL: rsqrtss snan\n");
809         ret = 1;
810     }
811 
812     return ret;
813 }
814