?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
5261 libm should stop using synonyms.h
[illumos-gate.git] / usr / src / lib / libm / common / m9x / __fex_sparc.c
blob2b9a2a3cfc7968fa3e6ee27fca11c98cd66f50f7
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
24 */
25 /*
26 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
27 * Use is subject to license terms.
28 */
29
30 #if defined(__sparc)
31 #include <stdio.h>
32 #include <unistd.h>
33 #include <string.h>
34 #include <signal.h>
35 #include <siginfo.h>
36 #include <thread.h>
37 #include <ucontext.h>
38 #include <math.h>
39 #if defined(__SUNPRO_C)
40 #include <sunmath.h>
41 #endif
42 #include <fenv.h>
43
44 #include "fenv_inlines.h"
45 #include "libm_inlines.h"
46
47 #ifdef __sparcv9
48
49 #define FPreg(X) &uap->uc_mcontext.fpregs.fpu_fr.fpu_regs[X]
50
51 #define FPREG(X) &uap->uc_mcontext.fpregs.fpu_fr.fpu_dregs[(X>>1)| \
52 ((X&1)<<4)]
53
54 #else
55
56 #include <sys/procfs.h>
57
58 #define FPxreg(X) &((prxregset_t*)uap->uc_mcontext.xrs.xrs_ptr)->pr_un.pr_v8p.pr_xfr.pr_regs[X]
59
60 #define FPreg(X) &uap->uc_mcontext.fpregs.fpu_fr.fpu_regs[X]
61
62 #define FPREG(X) ((X & 1)? FPxreg(X - 1) : FPreg(X))
63
64 #endif /* __sparcv9 */
65
66 #include "fex_handler.h"
67
68 /* avoid dependence on libsunmath */
69 static enum fp_class_type
70 my_fp_classl(long double *a)
71 {
72 int msw = *(int*)a & ~0x80000000;
73
74 if (msw >= 0x7fff0000) {
75 if (((msw & 0xffff) | *(1+(int*)a) | *(2+(int*)a) | *(3+(int*)a)) == 0)
76 return fp_infinity;
77 else if (msw & 0x8000)
78 return fp_quiet;
79 else
80 return fp_signaling;
81 } else if (msw < 0x10000) {
82 if ((msw | *(1+(int*)a) | *(2+(int*)a) | *(3+(int*)a)) == 0)
83 return fp_zero;
84 else
85 return fp_subnormal;
86 } else
87 return fp_normal;
88 }
89
90 /*
91 * Determine which type of invalid operation exception occurred
92 */
93 enum fex_exception
94 __fex_get_invalid_type(siginfo_t *sip, ucontext_t *uap)
95 {
96 unsigned instr, opf, rs1, rs2;
97 enum fp_class_type t1, t2;
98
99 /* parse the instruction which caused the exception */
100 instr = uap->uc_mcontext.fpregs.fpu_q->FQu.fpq.fpq_instr;
101 opf = (instr >> 5) & 0x1ff;
102 rs1 = (instr >> 14) & 0x1f;
103 rs2 = instr & 0x1f;
104
105 /* determine the classes of the operands */
106 switch (opf & 3) {
107 case 1: /* single */
108 t1 = fp_classf(*(float*)FPreg(rs1));
109 t2 = fp_classf(*(float*)FPreg(rs2));
110 break;
111
112 case 2: /* double */
113 t1 = fp_class(*(double*)FPREG(rs1));
114 t2 = fp_class(*(double*)FPREG(rs2));
115 break;
116
117 case 3: /* quad */
118 t1 = my_fp_classl((long double*)FPREG(rs1));
119 t2 = my_fp_classl((long double*)FPREG(rs2));
120 break;
121
122 default: /* integer operands never cause an invalid operation */
123 return (enum fex_exception) -1;
124 }
125
126 /* if rs2 is snan, return immediately */
127 if (t2 == fp_signaling)
128 return fex_inv_snan;
129
130 /* determine the type of operation */
131 switch ((instr >> 19) & 0x183f) {
132 case 0x1034: /* add, subtract, multiply, divide, square root, convert */
133 switch (opf & 0x1fc) {
134 case 0x40:
135 case 0x44: /* add or subtract */
136 if (t1 == fp_signaling)
137 return fex_inv_snan;
138 else
139 return fex_inv_isi;
140
141 case 0x48:
142 case 0x68:
143 case 0x6c: /* multiply */
144 if (t1 == fp_signaling)
145 return fex_inv_snan;
146 else
147 return fex_inv_zmi;
148
149 case 0x4c: /* divide */
150 if (t1 == fp_signaling)
151 return fex_inv_snan;
152 else if (t1 == fp_zero)
153 return fex_inv_zdz;
154 else
155 return fex_inv_idi;
156
157 case 0x28: /* square root */
158 return fex_inv_sqrt;
159
160 case 0x80:
161 case 0xd0: /* convert to integer */
162 return fex_inv_int;
163 }
164 break;
165
166 case 0x1035: /* compare */
167 if (t1 == fp_signaling)
168 return fex_inv_snan;
169 else
170 return fex_inv_cmp;
171 }
172
173 return (enum fex_exception) -1;
174 }
175
176 #ifdef __sparcv9
177 extern void _Qp_sqrt(long double *, const long double *);
178 #else
179 extern long double _Q_sqrt(long double);
180 #endif
181
182 /*
183 * Get the operands, generate the default untrapped result with
184 * exceptions, and set a code indicating the type of operation
185 */
186 void
187 __fex_get_op(siginfo_t *sip, ucontext_t *uap, fex_info_t *info)
188 {
189 unsigned long fsr;
190 unsigned instr, opf, rs1, rs2;
191 volatile int c;
192
193 /* parse the instruction which caused the exception */
194 instr = uap->uc_mcontext.fpregs.fpu_q->FQu.fpq.fpq_instr;
195 opf = (instr >> 5) & 0x1ff;
196 rs1 = (instr >> 14) & 0x1f;
197 rs2 = instr & 0x1f;
198
199 /* get the operands */
200 switch (opf & 3) {
201 case 0: /* integer */
202 info->op1.type = fex_nodata;
203 if (opf & 0x40) {
204 info->op2.type = fex_int;
205 info->op2.val.i = *(int*)FPreg(rs2);
206 }
207 else {
208 info->op2.type = fex_llong;
209 info->op2.val.l = *(long long*)FPREG(rs2);
210 }
211 break;
212
213 case 1: /* single */
214 info->op1.type = info->op2.type = fex_float;
215 info->op1.val.f = *(float*)FPreg(rs1);
216 info->op2.val.f = *(float*)FPreg(rs2);
217 break;
218
219 case 2: /* double */
220 info->op1.type = info->op2.type = fex_double;
221 info->op1.val.d = *(double*)FPREG(rs1);
222 info->op2.val.d = *(double*)FPREG(rs2);
223 break;
224
225 case 3: /* quad */
226 info->op1.type = info->op2.type = fex_ldouble;
227 info->op1.val.q = *(long double*)FPREG(rs1);
228 info->op2.val.q = *(long double*)FPREG(rs2);
229 break;
230 }
231
232 /* initialize res to the default untrapped result and ex to the
233 corresponding flags (assume trapping is disabled and flags
234 are clear) */
235 info->op = fex_other;
236 info->res.type = fex_nodata;
237 switch ((instr >> 19) & 0x183f) {
238 case 0x1035: /* compare */
239 info->op = fex_cmp;
240 switch (opf) {
241 case 0x51: /* compare single */
242 c = (info->op1.val.f == info->op2.val.f);
243 break;
244
245 case 0x52: /* compare double */
246 c = (info->op1.val.d == info->op2.val.d);
247 break;
248
249 case 0x53: /* compare quad */
250 c = (info->op1.val.q == info->op2.val.q);
251 break;
252
253 case 0x55: /* compare single with exception */
254 c = (info->op1.val.f < info->op2.val.f);
255 break;
256
257 case 0x56: /* compare double with exception */
258 c = (info->op1.val.d < info->op2.val.d);
259 break;
260
261 case 0x57: /* compare quad with exception */
262 c = (info->op1.val.q < info->op2.val.q);
263 break;
264 }
265 break;
266
267 case 0x1034: /* add, subtract, multiply, divide, square root, convert */
268 switch (opf) {
269 case 0x41: /* add single */
270 info->op = fex_add;
271 info->res.type = fex_float;
272 info->res.val.f = info->op1.val.f + info->op2.val.f;
273 break;
274
275 case 0x42: /* add double */
276 info->op = fex_add;
277 info->res.type = fex_double;
278 info->res.val.d = info->op1.val.d + info->op2.val.d;
279 break;
280
281 case 0x43: /* add quad */
282 info->op = fex_add;
283 info->res.type = fex_ldouble;
284 info->res.val.q = info->op1.val.q + info->op2.val.q;
285 break;
286
287 case 0x45: /* subtract single */
288 info->op = fex_sub;
289 info->res.type = fex_float;
290 info->res.val.f = info->op1.val.f - info->op2.val.f;
291 break;
292
293 case 0x46: /* subtract double */
294 info->op = fex_sub;
295 info->res.type = fex_double;
296 info->res.val.d = info->op1.val.d - info->op2.val.d;
297 break;
298
299 case 0x47: /* subtract quad */
300 info->op = fex_sub;
301 info->res.type = fex_ldouble;
302 info->res.val.q = info->op1.val.q - info->op2.val.q;
303 break;
304
305 case 0x49: /* multiply single */
306 info->op = fex_mul;
307 info->res.type = fex_float;
308 info->res.val.f = info->op1.val.f * info->op2.val.f;
309 break;
310
311 case 0x4a: /* multiply double */
312 info->op = fex_mul;
313 info->res.type = fex_double;
314 info->res.val.d = info->op1.val.d * info->op2.val.d;
315 break;
316
317 case 0x4b: /* multiply quad */
318 info->op = fex_mul;
319 info->res.type = fex_ldouble;
320 info->res.val.q = info->op1.val.q * info->op2.val.q;
321 break;
322
323 case 0x69: /* fsmuld */
324 info->op = fex_mul;
325 info->res.type = fex_double;
326 info->res.val.d = (double)info->op1.val.f * (double)info->op2.val.f;
327 break;
328
329 case 0x6e: /* fdmulq */
330 info->op = fex_mul;
331 info->res.type = fex_ldouble;
332 info->res.val.q = (long double)info->op1.val.d *
333 (long double)info->op2.val.d;
334 break;
335
336 case 0x4d: /* divide single */
337 info->op = fex_div;
338 info->res.type = fex_float;
339 info->res.val.f = info->op1.val.f / info->op2.val.f;
340 break;
341
342 case 0x4e: /* divide double */
343 info->op = fex_div;
344 info->res.type = fex_double;
345 info->res.val.d = info->op1.val.d / info->op2.val.d;
346 break;
347
348 case 0x4f: /* divide quad */
349 info->op = fex_div;
350 info->res.type = fex_ldouble;
351 info->res.val.q = info->op1.val.q / info->op2.val.q;
352 break;
353
354 case 0x29: /* square root single */
355 info->op = fex_sqrt;
356 info->op1 = info->op2;
357 info->op2.type = fex_nodata;
358 info->res.type = fex_float;
359 info->res.val.f = sqrtf(info->op1.val.f);
360 break;
361
362 case 0x2a: /* square root double */
363 info->op = fex_sqrt;
364 info->op1 = info->op2;
365 info->op2.type = fex_nodata;
366 info->res.type = fex_double;
367 info->res.val.d = sqrt(info->op1.val.d);
368 break;
369
370 case 0x2b: /* square root quad */
371 info->op = fex_sqrt;
372 info->op1 = info->op2;
373 info->op2.type = fex_nodata;
374 info->res.type = fex_ldouble;
375 #ifdef __sparcv9
376 _Qp_sqrt(&info->res.val.q, &info->op1.val.q);
377 #else
378 info->res.val.q = _Q_sqrt(info->op1.val.q);
379 #endif
380 break;
381
382 default: /* conversions */
383 info->op = fex_cnvt;
384 info->op1 = info->op2;
385 info->op2.type = fex_nodata;
386 switch (opf) {
387 case 0xd1: /* convert single to int */
388 info->res.type = fex_int;
389 info->res.val.i = (int) info->op1.val.f;
390 break;
391
392 case 0xd2: /* convert double to int */
393 info->res.type = fex_int;
394 info->res.val.i = (int) info->op1.val.d;
395 break;
396
397 case 0xd3: /* convert quad to int */
398 info->res.type = fex_int;
399 info->res.val.i = (int) info->op1.val.q;
400 break;
401
402 case 0x81: /* convert single to long long */
403 info->res.type = fex_llong;
404 info->res.val.l = (long long) info->op1.val.f;
405 break;
406
407 case 0x82: /* convert double to long long */
408 info->res.type = fex_llong;
409 info->res.val.l = (long long) info->op1.val.d;
410 break;
411
412 case 0x83: /* convert quad to long long */
413 info->res.type = fex_llong;
414 info->res.val.l = (long long) info->op1.val.q;
415 break;
416
417 case 0xc4: /* convert int to single */
418 info->res.type = fex_float;
419 info->res.val.f = (float) info->op1.val.i;
420 break;
421
422 case 0x84: /* convert long long to single */
423 info->res.type = fex_float;
424 info->res.val.f = (float) info->op1.val.l;
425 break;
426
427 case 0x88: /* convert long long to double */
428 info->res.type = fex_double;
429 info->res.val.d = (double) info->op1.val.l;
430 break;
431
432 case 0xc6: /* convert double to single */
433 info->res.type = fex_float;
434 info->res.val.f = (float) info->op1.val.d;
435 break;
436
437 case 0xc7: /* convert quad to single */
438 info->res.type = fex_float;
439 info->res.val.f = (float) info->op1.val.q;
440 break;
441
442 case 0xc9: /* convert single to double */
443 info->res.type = fex_double;
444 info->res.val.d = (double) info->op1.val.f;
445 break;
446
447 case 0xcb: /* convert quad to double */
448 info->res.type = fex_double;
449 info->res.val.d = (double) info->op1.val.q;
450 break;
451
452 case 0xcd: /* convert single to quad */
453 info->res.type = fex_ldouble;
454 info->res.val.q = (long double) info->op1.val.f;
455 break;
456
457 case 0xce: /* convert double to quad */
458 info->res.type = fex_ldouble;
459 info->res.val.q = (long double) info->op1.val.d;
460 break;
461 }
462 }
463 break;
464 }
465 __fenv_getfsr(&fsr);
466 info->flags = (int)__fenv_get_ex(fsr);
467 __fenv_set_ex(fsr, 0);
468 __fenv_setfsr(&fsr);
469 }
470
471 /*
472 * Store the specified result; if no result is given but the exception
473 * is underflow or overflow, supply the default trapped result
474 */
475 void
476 __fex_st_result(siginfo_t *sip, ucontext_t *uap, fex_info_t *info)
477 {
478 unsigned instr, opf, rs1, rs2, rd;
479 long double qscl;
480 double dscl;
481 float fscl;
482
483 /* parse the instruction which caused the exception */
484 instr = uap->uc_mcontext.fpregs.fpu_q->FQu.fpq.fpq_instr;
485 opf = (instr >> 5) & 0x1ff;
486 rs1 = (instr >> 14) & 0x1f;
487 rs2 = instr & 0x1f;
488 rd = (instr >> 25) & 0x1f;
489
490 /* if the instruction is a compare, just set fcc to unordered */
491 if (((instr >> 19) & 0x183f) == 0x1035) {
492 if (rd == 0)
493 uap->uc_mcontext.fpregs.fpu_fsr |= 0xc00;
494 else {
495 #ifdef __sparcv9
496 uap->uc_mcontext.fpregs.fpu_fsr |= (3l << ((rd << 1) + 30));
497 #else
498 ((prxregset_t*)uap->uc_mcontext.xrs.xrs_ptr)->pr_un.pr_v8p.pr_xfsr |= (3 << ((rd - 1) << 1));
499 #endif
500 }
501 return;
502 }
503
504 /* if there is no result available, try to generate the untrapped
505 default */
506 if (info->res.type == fex_nodata) {
507 /* set scale factors for exponent wrapping */
508 switch (sip->si_code) {
509 case FPE_FLTOVF:
510 fscl = 1.262177448e-29f; /* 2^-96 */
511 dscl = 6.441148769597133308e-232; /* 2^-768 */
512 qscl = 8.778357852076208839765066529179033145e-3700l;/* 2^-12288 */
513 break;
514
515 case FPE_FLTUND:
516 fscl = 7.922816251e+28f; /* 2^96 */
517 dscl = 1.552518092300708935e+231; /* 2^768 */
518 qscl = 1.139165225263043370845938579315932009e+3699l;/* 2^12288 */
519 break;
520
521 default:
522 /* user may have blown away the default result by mistake,
523 so try to regenerate it */
524 (void) __fex_get_op(sip, uap, info);
525 if (info->res.type != fex_nodata)
526 goto stuff;
527 /* couldn't do it */
528 return;
529 }
530
531 /* get the operands */
532 switch (opf & 3) {
533 case 1: /* single */
534 info->op1.val.f = *(float*)FPreg(rs1);
535 info->op2.val.f = *(float*)FPreg(rs2);
536 break;
537
538 case 2: /* double */
539 info->op1.val.d = *(double*)FPREG(rs1);
540 info->op2.val.d = *(double*)FPREG(rs2);
541 break;
542
543 case 3: /* quad */
544 info->op1.val.q = *(long double*)FPREG(rs1);
545 info->op2.val.q = *(long double*)FPREG(rs2);
546 break;
547 }
548
549 /* generate the wrapped result */
550 switch (opf) {
551 case 0x41: /* add single */
552 info->res.type = fex_float;
553 info->res.val.f = fscl * (fscl * info->op1.val.f +
554 fscl * info->op2.val.f);
555 break;
556
557 case 0x42: /* add double */
558 info->res.type = fex_double;
559 info->res.val.d = dscl * (dscl * info->op1.val.d +
560 dscl * info->op2.val.d);
561 break;
562
563 case 0x43: /* add quad */
564 info->res.type = fex_ldouble;
565 info->res.val.q = qscl * (qscl * info->op1.val.q +
566 qscl * info->op2.val.q);
567 break;
568
569 case 0x45: /* subtract single */
570 info->res.type = fex_float;
571 info->res.val.f = fscl * (fscl * info->op1.val.f -
572 fscl * info->op2.val.f);
573 break;
574
575 case 0x46: /* subtract double */
576 info->res.type = fex_double;
577 info->res.val.d = dscl * (dscl * info->op1.val.d -
578 dscl * info->op2.val.d);
579 break;
580
581 case 0x47: /* subtract quad */
582 info->res.type = fex_ldouble;
583 info->res.val.q = qscl * (qscl * info->op1.val.q -
584 qscl * info->op2.val.q);
585 break;
586
587 case 0x49: /* multiply single */
588 info->res.type = fex_float;
589 info->res.val.f = (fscl * info->op1.val.f) *
590 (fscl * info->op2.val.f);
591 break;
592
593 case 0x4a: /* multiply double */
594 info->res.type = fex_double;
595 info->res.val.d = (dscl * info->op1.val.d) *
596 (dscl * info->op2.val.d);
597 break;
598
599 case 0x4b: /* multiply quad */
600 info->res.type = fex_ldouble;
601 info->res.val.q = (qscl * info->op1.val.q) *
602 (qscl * info->op2.val.q);
603 break;
604
605 case 0x4d: /* divide single */
606 info->res.type = fex_float;
607 info->res.val.f = (fscl * info->op1.val.f) /
608 (info->op2.val.f / fscl);
609 break;
610
611 case 0x4e: /* divide double */
612 info->res.type = fex_double;
613 info->res.val.d = (dscl * info->op1.val.d) /
614 (info->op2.val.d / dscl);
615 break;
616
617 case 0x4f: /* divide quad */
618 info->res.type = fex_ldouble;
619 info->res.val.q = (qscl * info->op1.val.q) /
620 (info->op2.val.q / qscl);
621 break;
622
623 case 0xc6: /* convert double to single */
624 info->res.type = fex_float;
625 info->res.val.f = (float) (fscl * (fscl * info->op1.val.d));
626 break;
627
628 case 0xc7: /* convert quad to single */
629 info->res.type = fex_float;
630 info->res.val.f = (float) (fscl * (fscl * info->op1.val.q));
631 break;
632
633 case 0xcb: /* convert quad to double */
634 info->res.type = fex_double;
635 info->res.val.d = (double) (dscl * (dscl * info->op1.val.q));
636 break;
637 }
638
639 if (info->res.type == fex_nodata)
640 /* couldn't do it */
641 return;
642 }
643
644 stuff:
645 /* stick the result in the destination */
646 if (opf & 0x80) { /* conversion */
647 if (opf & 0x10) { /* result is an int */
648 switch (info->res.type) {
649 case fex_llong:
650 info->res.val.i = (int) info->res.val.l;
651 break;
652
653 case fex_float:
654 info->res.val.i = (int) info->res.val.f;
655 break;
656
657 case fex_double:
658 info->res.val.i = (int) info->res.val.d;
659 break;
660
661 case fex_ldouble:
662 info->res.val.i = (int) info->res.val.q;
663 break;
664
665 default:
666 break;
667 }
668 *(int*)FPreg(rd) = info->res.val.i;
669 return;
670 }
671
672 switch (opf & 0xc) {
673 case 0: /* result is long long */
674 switch (info->res.type) {
675 case fex_int:
676 info->res.val.l = (long long) info->res.val.i;
677 break;
678
679 case fex_float:
680 info->res.val.l = (long long) info->res.val.f;
681 break;
682
683 case fex_double:
684 info->res.val.l = (long long) info->res.val.d;
685 break;
686
687 case fex_ldouble:
688 info->res.val.l = (long long) info->res.val.q;
689 break;
690
691 default:
692 break;
693 }
694 *(long long*)FPREG(rd) = info->res.val.l;
695 break;
696
697 case 0x4: /* result is float */
698 switch (info->res.type) {
699 case fex_int:
700 info->res.val.f = (float) info->res.val.i;
701 break;
702
703 case fex_llong:
704 info->res.val.f = (float) info->res.val.l;
705 break;
706
707 case fex_double:
708 info->res.val.f = (float) info->res.val.d;
709 break;
710
711 case fex_ldouble:
712 info->res.val.f = (float) info->res.val.q;
713 break;
714
715 default:
716 break;
717 }
718 *(float*)FPreg(rd) = info->res.val.f;
719 break;
720
721 case 0x8: /* result is double */
722 switch (info->res.type) {
723 case fex_int:
724 info->res.val.d = (double) info->res.val.i;
725 break;
726
727 case fex_llong:
728 info->res.val.d = (double) info->res.val.l;
729 break;
730
731 case fex_float:
732 info->res.val.d = (double) info->res.val.f;
733 break;
734
735 case fex_ldouble:
736 info->res.val.d = (double) info->res.val.q;
737 break;
738
739 default:
740 break;
741 }
742 *(double*)FPREG(rd) = info->res.val.d;
743 break;
744
745 case 0xc: /* result is long double */
746 switch (info->res.type) {
747 case fex_int:
748 info->res.val.q = (long double) info->res.val.i;
749 break;
750
751 case fex_llong:
752 info->res.val.q = (long double) info->res.val.l;
753 break;
754
755 case fex_float:
756 info->res.val.q = (long double) info->res.val.f;
757 break;
758
759 case fex_double:
760 info->res.val.q = (long double) info->res.val.d;
761 break;
762
763 default:
764 break;
765 }
766 *(long double*)FPREG(rd) = info->res.val.q;
767 break;
768 }
769 return;
770 }
771
772 if ((opf & 0xf0) == 0x60) { /* fsmuld, fdmulq */
773 switch (opf & 0xc0) {
774 case 0x8: /* result is double */
775 switch (info->res.type) {
776 case fex_int:
777 info->res.val.d = (double) info->res.val.i;
778 break;
779
780 case fex_llong:
781 info->res.val.d = (double) info->res.val.l;
782 break;
783
784 case fex_float:
785 info->res.val.d = (double) info->res.val.f;
786 break;
787
788 case fex_ldouble:
789 info->res.val.d = (double) info->res.val.q;
790 break;
791
792 default:
793 break;
794 }
795 *(double*)FPREG(rd) = info->res.val.d;
796 break;
797
798 case 0xc: /* result is long double */
799 switch (info->res.type) {
800 case fex_int:
801 info->res.val.q = (long double) info->res.val.i;
802 break;
803
804 case fex_llong:
805 info->res.val.q = (long double) info->res.val.l;
806 break;
807
808 case fex_float:
809 info->res.val.q = (long double) info->res.val.f;
810 break;
811
812 case fex_double:
813 info->res.val.q = (long double) info->res.val.d;
814 break;
815
816 default:
817 break;
818 }
819 *(long double*)FPREG(rd) = info->res.val.q;
820 break;
821 }
822 return;
823 }
824
825 switch (opf & 3) { /* other arithmetic op */
826 case 1: /* result is float */
827 switch (info->res.type) {
828 case fex_int:
829 info->res.val.f = (float) info->res.val.i;
830 break;
831
832 case fex_llong:
833 info->res.val.f = (float) info->res.val.l;
834 break;
835
836 case fex_double:
837 info->res.val.f = (float) info->res.val.d;
838 break;
839
840 case fex_ldouble:
841 info->res.val.f = (float) info->res.val.q;
842 break;
843
844 default:
845 break;
846 }
847 *(float*)FPreg(rd) = info->res.val.f;
848 break;
849
850 case 2: /* result is double */
851 switch (info->res.type) {
852 case fex_int:
853 info->res.val.d = (double) info->res.val.i;
854 break;
855
856 case fex_llong:
857 info->res.val.d = (double) info->res.val.l;
858 break;
859
860 case fex_float:
861 info->res.val.d = (double) info->res.val.f;
862 break;
863
864 case fex_ldouble:
865 info->res.val.d = (double) info->res.val.q;
866 break;
867
868 default:
869 break;
870 }
871 *(double*)FPREG(rd) = info->res.val.d;
872 break;
873
874 case 3: /* result is long double */
875 switch (info->res.type) {
876 case fex_int:
877 info->res.val.q = (long double) info->res.val.i;
878 break;
879
880 case fex_llong:
881 info->res.val.q = (long double) info->res.val.l;
882 break;
883
884 case fex_float:
885 info->res.val.q = (long double) info->res.val.f;
886 break;
887
888 case fex_double:
889 info->res.val.q = (long double) info->res.val.d;
890 break;
891
892 default:
893 break;
894 }
895 *(long double*)FPREG(rd) = info->res.val.q;
896 break;
897 }
898 }
899 #endif /* defined(__sparc) */
Community developed and maintained version of the OS/Net consolidation