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 #include "fenv_synonyms.h"
  31 #include <stdio.h>
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <signal.h>
  36 #include <siginfo.h>
  37 #include <ucontext.h>
  38 #include <thread.h>
  39 #include <math.h>
  40 #if defined(__SUNPRO_C)
  41 #include <sunmath.h>
  42 #endif
  43 #include <fenv.h>
  44 #include "fex_handler.h"
  45 #include "fenv_inlines.h"
  46 
  47 #if defined(__amd64)
  48 #define test_sse_hw     1
  49 #else
  50 /*
  51  * The following variable lives in libc on Solaris 10, where it
  52  * gets set to a nonzero value at startup time on systems with SSE.
  53  */
  54 int _sse_hw = 0;
  55 #pragma weak _sse_hw
  56 #define test_sse_hw     &_sse_hw && _sse_hw
  57 #endif
  58 
  59 static int accrued = 0;
  60 static thread_key_t accrued_key;
  61 static mutex_t accrued_key_lock = DEFAULTMUTEX;
  62 
  63 int *
  64 __fex_accrued()
  65 {
  66         int             *p;
  67 
  68         if (thr_main())
  69                 return &accrued;
  70         else {
  71                 p = NULL;
  72                 mutex_lock(&accrued_key_lock);
  73                 if (thr_getspecific(accrued_key, (void **)&p) != 0 &&
  74                         thr_keycreate(&accrued_key, free) != 0) {
  75                         mutex_unlock(&accrued_key_lock);
  76                         return NULL;
  77                 }
  78                 mutex_unlock(&accrued_key_lock);
  79                 if (!p) {
  80                         if ((p = (int*) malloc(sizeof(int))) == NULL)
  81                                 return NULL;
  82                         if (thr_setspecific(accrued_key, (void *)p) != 0) {
  83                                 (void)free(p);
  84                                 return NULL;
  85                         }
  86                         *p = 0;
  87                 }
  88                 return p;
  89         }
  90 }
  91 
  92 void
  93 __fenv_getfsr(unsigned long *fsr)
  94 {
  95         unsigned int    cwsw, mxcsr;
  96 
  97         __fenv_getcwsw(&cwsw);
  98         /* clear reserved bits for no particularly good reason */
  99         cwsw &= ~0xe0c00000u;
 100         if (test_sse_hw) {
 101                 /* pick up exception flags (excluding denormal operand
 102                    flag) from mxcsr */
 103                 __fenv_getmxcsr(&mxcsr);
 104                 cwsw |= (mxcsr & 0x3d);
 105         }
 106         cwsw |= *__fex_accrued();
 107         *fsr = cwsw ^ 0x003f0000u;
 108 }
 109 
 110 void
 111 __fenv_setfsr(const unsigned long *fsr)
 112 {
 113         unsigned int    cwsw, mxcsr;
 114         int                             te;
 115 
 116         /* save accrued exception flags corresponding to enabled exceptions */
 117         cwsw = (unsigned int)*fsr;
 118         te = __fenv_get_te(cwsw);
 119         *__fex_accrued() = cwsw & te;
 120         cwsw = (cwsw & ~te) ^ 0x003f0000;
 121         if (test_sse_hw) {
 122                 /* propagate rounding direction, masks, and exception flags
 123                    (excluding denormal operand mask and flag) to mxcsr */
 124                 __fenv_getmxcsr(&mxcsr);
 125                 mxcsr = (mxcsr & ~0x7ebd) | ((cwsw >> 13) & 0x6000) |
 126                         ((cwsw >> 9) & 0x1e80) | (cwsw & 0x3d);
 127                 __fenv_setmxcsr(&mxcsr);
 128         }
 129         __fenv_setcwsw(&cwsw);
 130 }
 131 
 132 /* Offsets into the fp environment save area (assumes 32-bit protected mode) */
 133 #define CW      0       /* control word */
 134 #define SW      1       /* status word */
 135 #define TW      2       /* tag word */
 136 #define IP      3       /* instruction pointer */
 137 #define OP      4       /* opcode */
 138 #define EA      5       /* operand address */
 139 
 140 /* macro for accessing fp registers in the save area */
 141 #if defined(__amd64)
 142 #define fpreg(u,x)      *(long double *)(10*(x)+(char*)&(u)->uc_mcontext.fpregs.fp_reg_set.fpchip_state.st)
 143 #else
 144 #define fpreg(u,x)      *(long double *)(10*(x)+(char*)&(u)->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[7])
 145 #endif
 146 
 147 /*
 148 *  Fix sip->si_code; the Solaris x86 kernel can get it wrong
 149 */
 150 void
 151 __fex_get_x86_exc(siginfo_t *sip, ucontext_t *uap)
 152 {
 153         unsigned        sw, cw;
 154 
 155         sw = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.status;
 156 #if defined(__amd64)
 157         cw = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.cw;
 158 #else
 159         cw = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[CW];
 160 #endif
 161         if ((sw & FE_INVALID) && !(cw & (1 << fp_trap_invalid)))
 162                 /* store 0 for stack fault, FPE_FLTINV for IEEE invalid op */
 163                 sip->si_code = ((sw & 0x40)? 0 : FPE_FLTINV);
 164         else if ((sw & FE_DIVBYZERO) && !(cw & (1 << fp_trap_division)))
 165                 sip->si_code = FPE_FLTDIV;
 166         else if ((sw & FE_OVERFLOW) && !(cw & (1 << fp_trap_overflow)))
 167                 sip->si_code = FPE_FLTOVF;
 168         else if ((sw & FE_UNDERFLOW) && !(cw & (1 << fp_trap_underflow)))
 169                 sip->si_code = FPE_FLTUND;
 170         else if ((sw & FE_INEXACT) && !(cw & (1 << fp_trap_inexact)))
 171                 sip->si_code = FPE_FLTRES;
 172         else
 173                 sip->si_code = 0;
 174 }
 175 
 176 static enum fp_class_type
 177 my_fp_classf(float *x)
 178 {
 179         int             i = *(int*)x & ~0x80000000;
 180 
 181         if (i < 0x7f800000) {
 182                 if (i < 0x00800000)
 183                         return ((i == 0)? fp_zero : fp_subnormal);
 184                 return fp_normal;
 185         }
 186         else if (i == 0x7f800000)
 187                 return fp_infinity;
 188         else if (i & 0x400000)
 189                 return fp_quiet;
 190         else
 191                 return fp_signaling;
 192 }
 193 
 194 static enum fp_class_type
 195 my_fp_class(double *x)
 196 {
 197         int             i = *(1+(int*)x) & ~0x80000000;
 198 
 199         if (i < 0x7ff00000) {
 200                 if (i < 0x00100000)
 201                         return (((i | *(int*)x) == 0)? fp_zero : fp_subnormal);
 202                 return fp_normal;
 203         }
 204         else if (i == 0x7ff00000 && *(int*)x == 0)
 205                 return fp_infinity;
 206         else if (i & 0x80000)
 207                 return fp_quiet;
 208         else
 209                 return fp_signaling;
 210 }
 211 
 212 static enum fp_class_type
 213 my_fp_classl(long double *x)
 214 {
 215         int             i = *(2+(int*)x) & 0x7fff;
 216 
 217         if (i < 0x7fff) {
 218                 if (i < 1) {
 219                         if (*(1+(int*)x) < 0) return fp_normal; /* pseudo-denormal */
 220                         return (((*(1+(int*)x) | *(int*)x) == 0)?       
 221                                 fp_zero : fp_subnormal);
 222                 }
 223                 return ((*(1+(int*)x) < 0)? fp_normal :
 224                         (enum fp_class_type) -1); /* unsupported format */
 225         }
 226         else if (*(1+(int*)x) == 0x80000000 && *(int*)x == 0)
 227                 return fp_infinity;
 228         else if (*(1+(unsigned*)x) >= 0xc0000000)
 229                 return fp_quiet;
 230         else if (*(1+(int*)x) < 0)
 231                 return fp_signaling;
 232         else
 233                 return (enum fp_class_type) -1; /* unsupported format */
 234 }
 235 
 236 /*
 237 *  Determine which type of invalid operation exception occurred
 238 */
 239 enum fex_exception
 240 __fex_get_invalid_type(siginfo_t *sip, ucontext_t *uap)
 241 {
 242         unsigned                        op;
 243         unsigned long                   ea;
 244         enum fp_class_type      t1, t2;
 245 
 246         /* get the opcode and data address */
 247 #if defined(__amd64)
 248         op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.fop >> 16;
 249         ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.rdp;
 250 #else
 251         op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[OP] >> 16;
 252         ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[EA];
 253 #endif
 254 
 255         /* if the instruction is fld, the source must be snan (it can't be
 256            an unsupported format, since fldt doesn't raise any exceptions) */
 257         switch (op & 0x7f8) {
 258         case 0x100:
 259         case 0x140:
 260         case 0x180:
 261         case 0x500:
 262         case 0x540:
 263         case 0x580:
 264                 return fex_inv_snan;
 265         }
 266 
 267         /* otherwise st is one of the operands; see if it's snan */
 268         t1 = my_fp_classl(&fpreg(uap, 0));
 269         if (t1 == fp_signaling)
 270                 return fex_inv_snan;
 271         else if (t1 == (enum fp_class_type) -1)
 272                 return (enum fex_exception) -1;
 273 
 274         /* determine the class of the second operand if there is one */
 275         t2 = fp_normal;
 276         switch (op & 0x7e0) {
 277         case 0x600:
 278         case 0x620:
 279         case 0x640:
 280         case 0x660:
 281         case 0x680:
 282         case 0x6a0:
 283                 /* short memory operand */
 284                 if (!ea)
 285                         return (enum fex_exception) -1;
 286                 if (*(short *)ea == 0)
 287                         t2 = fp_zero;
 288                 break;
 289 
 290         case 0x200:
 291         case 0x220:
 292         case 0x240:
 293         case 0x260:
 294         case 0x280:
 295         case 0x2a0:
 296                 /* int memory operand */
 297                 if (!ea)
 298                         return (enum fex_exception) -1;
 299                 if (*(int *)ea == 0)
 300                         t2 = fp_zero;
 301                 break;
 302 
 303         case 0x000:
 304         case 0x020:
 305         case 0x040:
 306         case 0x060:
 307         case 0x080:
 308         case 0x0a0:
 309                 /* single precision memory operand */
 310                 if (!ea)
 311                         return (enum fex_exception) -1;
 312                 t2 = my_fp_classf((float *)ea);
 313                 break;
 314 
 315         case 0x400:
 316         case 0x420:
 317         case 0x440:
 318         case 0x460:
 319         case 0x480:
 320         case 0x4a0:
 321                 /* double precision memory operand */
 322                 if (!ea)
 323                         return (enum fex_exception) -1;
 324                 t2 = my_fp_class((double *)ea);
 325                 break;
 326 
 327         case 0x0c0:
 328         case 0x0e0:
 329         case 0x3e0:
 330         case 0x4c0:
 331         case 0x4e0:
 332         case 0x5e0:
 333         case 0x6c0:
 334         case 0x6e0:
 335         case 0x7e0:
 336                 /* register operand determined by opcode */
 337                 switch (op & 0x7f8) {
 338                 case 0x3e0:
 339                 case 0x3f8:
 340                 case 0x5f0:
 341                 case 0x5f8:
 342                 case 0x7e0:
 343                 case 0x7f8:
 344                         /* weed out nonexistent opcodes */
 345                         break;
 346 
 347                 default:
 348                         t2 = my_fp_classl(&fpreg(uap, op & 7));
 349                 }
 350                 break;
 351 
 352         case 0x1e0:
 353         case 0x2e0:
 354                 /* special forms */
 355                 switch (op) {
 356                 case 0x1f1: /* fyl2x */
 357                 case 0x1f3: /* fpatan */
 358                 case 0x1f5: /* fprem1 */
 359                 case 0x1f8: /* fprem */
 360                 case 0x1f9: /* fyl2xp1 */
 361                 case 0x1fd: /* fscale */
 362                 case 0x2e9: /* fucompp */
 363                         t2 = my_fp_classl(&fpreg(uap, 1));
 364                         break;
 365                 }
 366                 break;
 367         }
 368 
 369         /* see if the second op is snan */
 370         if (t2 == fp_signaling)
 371                 return fex_inv_snan;
 372         else if (t2 == (enum fp_class_type) -1)
 373                 return (enum fex_exception) -1;
 374 
 375         /* determine the type of operation */
 376         switch (op & 0x7f8) {
 377         case 0x000:
 378         case 0x020:
 379         case 0x028:
 380         case 0x040:
 381         case 0x060:
 382         case 0x068:
 383         case 0x080:
 384         case 0x0a0:
 385         case 0x0a8:
 386         case 0x0c0:
 387         case 0x0e0:
 388         case 0x0e8:
 389         case 0x400:
 390         case 0x420:
 391         case 0x428:
 392         case 0x440:
 393         case 0x460:
 394         case 0x468:
 395         case 0x480:
 396         case 0x4a0:
 397         case 0x4a8:
 398         case 0x4c0:
 399         case 0x4e0:
 400         case 0x4e8:
 401         case 0x6c0:
 402         case 0x6e0:
 403         case 0x6e8:
 404                 /* fadd, fsub, fsubr */
 405                 if (t1 == fp_infinity && t2 == fp_infinity)
 406                         return fex_inv_isi;
 407                 break;
 408 
 409         case 0x008:
 410         case 0x048:
 411         case 0x088:
 412         case 0x0c8:
 413         case 0x208:
 414         case 0x248:
 415         case 0x288:
 416         case 0x408:
 417         case 0x448:
 418         case 0x488:
 419         case 0x4c8:
 420         case 0x608:
 421         case 0x648:
 422         case 0x688:
 423         case 0x6c8:
 424                 /* fmul */
 425                 if ((t1 == fp_zero && t2 == fp_infinity) || (t2 == fp_zero &&
 426                   t1 == fp_infinity))
 427                         return fex_inv_zmi;
 428                 break;
 429 
 430         case 0x030:
 431         case 0x038:
 432         case 0x070:
 433         case 0x078:
 434         case 0x0b0:
 435         case 0x0b8:
 436         case 0x0f0:
 437         case 0x0f8:
 438         case 0x230:
 439         case 0x238:
 440         case 0x270:
 441         case 0x278:
 442         case 0x2b0:
 443         case 0x2b8:
 444         case 0x430:
 445         case 0x438:
 446         case 0x470:
 447         case 0x478:
 448         case 0x4b0:
 449         case 0x4b8:
 450         case 0x4f0:
 451         case 0x4f8:
 452         case 0x630:
 453         case 0x638:
 454         case 0x670:
 455         case 0x678:
 456         case 0x6b0:
 457         case 0x6b8:
 458         case 0x6f0:
 459         case 0x6f8:
 460                 /* fdiv */
 461                 if (t1 == fp_zero && t2 == fp_zero)
 462                         return fex_inv_zdz;
 463                 else if (t1 == fp_infinity && t2 == fp_infinity)
 464                         return fex_inv_idi;
 465                 break;
 466 
 467         case 0x1f0:
 468         case 0x1f8:
 469                 /* fsqrt, other special ops */
 470                 return fex_inv_sqrt;
 471 
 472         case 0x010:
 473         case 0x018:
 474         case 0x050:
 475         case 0x058:
 476         case 0x090:
 477         case 0x098:
 478         case 0x0d0:
 479         case 0x0d8:
 480         case 0x210:
 481         case 0x218:
 482         case 0x250:
 483         case 0x258:
 484         case 0x290:
 485         case 0x298:
 486         case 0x2e8:
 487         case 0x3f0:
 488         case 0x410:
 489         case 0x418:
 490         case 0x450:
 491         case 0x458:
 492         case 0x490:
 493         case 0x498:
 494         case 0x4d0:
 495         case 0x4d8:
 496         case 0x5e0:
 497         case 0x5e8:
 498         case 0x610:
 499         case 0x618:
 500         case 0x650:
 501         case 0x658:
 502         case 0x690:
 503         case 0x698:
 504         case 0x6d0:
 505         case 0x6d8:
 506         case 0x7f0:
 507                 /* fcom */
 508                 if (t1 == fp_quiet || t2 == fp_quiet)
 509                         return fex_inv_cmp;
 510                 break;
 511 
 512         case 0x1e0:
 513                 /* ftst */
 514                 if (op == 0x1e4 && t1 == fp_quiet)
 515                         return fex_inv_cmp;
 516                 break;
 517 
 518         case 0x310:
 519         case 0x318:
 520         case 0x350:
 521         case 0x358:
 522         case 0x390:
 523         case 0x398:
 524         case 0x710:
 525         case 0x718:
 526         case 0x730:
 527         case 0x738:
 528         case 0x750:
 529         case 0x758:
 530         case 0x770:
 531         case 0x778:
 532         case 0x790:
 533         case 0x798:
 534         case 0x7b0:
 535         case 0x7b8:
 536                 /* fist, fbst */
 537                 return fex_inv_int;
 538         }
 539 
 540         return (enum fex_exception) -1;
 541 }
 542 
 543 /* scale factors for exponent unwrapping */
 544 static const long double
 545         two12288 = 1.139165225263043370845938579315932009e+3699l,       /* 2^12288 */
 546         twom12288 = 8.778357852076208839765066529179033145e-3700l,      /* 2^-12288 */
 547         twom12288mulp = 8.778357852076208839289190796475222545e-3700l;
 548                 /* (")*(1-2^-64) */
 549 
 550 /* inline templates */
 551 extern long double f2xm1(long double);
 552 extern long double fyl2x(long double, long double);
 553 extern long double fptan(long double);
 554 extern long double fpatan(long double, long double);
 555 extern long double fxtract(long double);
 556 extern long double fprem1(long double, long double);
 557 extern long double fprem(long double, long double);
 558 extern long double fyl2xp1(long double, long double);
 559 extern long double fsqrt(long double);
 560 extern long double fsincos(long double);
 561 extern long double frndint(long double);
 562 extern long double fscale(long double, long double);
 563 extern long double fsin(long double);
 564 extern long double fcos(long double);
 565 
 566 /*
 567 *  Get the operands, generate the default untrapped result with
 568 *  exceptions, and set a code indicating the type of operation
 569 */
 570 void
 571 __fex_get_op(siginfo_t *sip, ucontext_t *uap, fex_info_t *info)
 572 {
 573         fex_numeric_t                   t;
 574         long double                     op2v, x;
 575         unsigned int                    cwsw, ex, sw, op;
 576         unsigned long                   ea;
 577         volatile int                    c;
 578 
 579         /* get the exception type, status word, opcode, and data address */
 580         ex = sip->si_code;
 581         sw = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.status;
 582 #if defined(__amd64)
 583         op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.fop >> 16;
 584         ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.rdp;
 585 #else
 586         op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[OP] >> 16;
 587         ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[EA];
 588 #endif
 589 
 590         /* initialize res to the default untrapped result and ex to the
 591            corresponding flags (assume trapping is disabled and flags
 592            are clear) */
 593 
 594         /* single operand instructions */
 595         info->op = fex_cnvt;
 596         info->op2.type = fex_nodata;
 597         switch (op & 0x7f8) {
 598         /* load instructions */
 599         case 0x100:
 600         case 0x140:
 601         case 0x180:
 602                 if (!ea) {
 603                         info->op = fex_other;
 604                         info->op1.type = info->op2.type = info->res.type = fex_nodata;
 605                         info->flags = 0;
 606                         return;
 607                 }
 608                 info->op1.type = fex_float;
 609                 info->op1.val.f = *(float *)ea;
 610                 info->res.type = fex_ldouble;
 611                 info->res.val.q = (long double) info->op1.val.f;
 612                 goto done;
 613 
 614         case 0x500:
 615         case 0x540:
 616         case 0x580:
 617                 if (!ea) {
 618                         info->op = fex_other;
 619                         info->op1.type = info->op2.type = info->res.type = fex_nodata;
 620                         info->flags = 0;
 621                         return;
 622                 }
 623                 info->op1.type = fex_double;
 624                 info->op1.val.d = *(double *)ea;
 625                 info->res.type = fex_ldouble;
 626                 info->res.val.q = (long double) info->op1.val.d;
 627                 goto done;
 628 
 629         /* store instructions */
 630         case 0x110:
 631         case 0x118:
 632         case 0x150:
 633         case 0x158:
 634         case 0x190:
 635         case 0x198:
 636                 info->res.type = fex_float;
 637                 if (ex == FPE_FLTRES && (op & 8) != 0) {
 638                         /* inexact, stack popped */
 639                         if (!ea) {
 640                                 info->op = fex_other;
 641                                 info->op1.type = info->op2.type = info->res.type = fex_nodata;
 642                                 info->flags = 0;
 643                                 return;
 644                         }
 645                         info->op1.type = fex_nodata;
 646                         info->res.val.f = *(float *)ea;
 647                         info->flags = FE_INEXACT;
 648                         return;
 649                 }
 650                 info->op1.type = fex_ldouble;
 651                 info->op1.val.q = fpreg(uap, 0);
 652                 info->res.val.f = (float) info->op1.val.q;
 653                 goto done;
 654 
 655         case 0x310:
 656         case 0x318:
 657         case 0x350:
 658         case 0x358:
 659         case 0x390:
 660         case 0x398:
 661                 info->res.type = fex_int;
 662                 if (ex == FPE_FLTRES && (op & 8) != 0) {
 663                         /* inexact, stack popped */
 664                         if (!ea) {
 665                                 info->op = fex_other;
 666                                 info->op1.type = info->op2.type = info->res.type = fex_nodata;
 667                                 info->flags = 0;
 668                                 return;
 669                         }
 670                         info->op1.type = fex_nodata;
 671                         info->res.val.i = *(int *)ea;
 672                         info->flags = FE_INEXACT;
 673                         return;
 674                 }
 675                 info->op1.type = fex_ldouble;
 676                 info->op1.val.q = fpreg(uap, 0);
 677                 info->res.val.i = (int) info->op1.val.q;
 678                 goto done;
 679 
 680         case 0x510:
 681         case 0x518:
 682         case 0x550:
 683         case 0x558:
 684         case 0x590:
 685         case 0x598:
 686                 info->res.type = fex_double;
 687                 if (ex == FPE_FLTRES && (op & 8) != 0) {
 688                         /* inexact, stack popped */
 689                         if (!ea) {
 690                                 info->op = fex_other;
 691                                 info->op1.type = info->op2.type = info->res.type = fex_nodata;
 692                                 info->flags = 0;
 693                                 return;
 694                         }
 695                         info->op1.type = fex_nodata;
 696                         info->res.val.d = *(double *)ea;
 697                         info->flags = FE_INEXACT;
 698                         return;
 699                 }
 700                 info->op1.type = fex_ldouble;
 701                 info->op1.val.q = fpreg(uap, 0);
 702                 info->res.val.d = (double) info->op1.val.q;
 703                 goto done;
 704 
 705         case 0x710:
 706         case 0x718:
 707         case 0x750:
 708         case 0x758:
 709         case 0x790:
 710         case 0x798:
 711                 info->res.type = fex_int;
 712                 if (ex == FPE_FLTRES && (op & 8) != 0) {
 713                         /* inexact, stack popped */
 714                         if (!ea) {
 715                                 info->op = fex_other;
 716                                 info->op1.type = info->op2.type = info->res.type = fex_nodata;
 717                                 info->flags = 0;
 718                                 return;
 719                         }
 720                         info->op1.type = fex_nodata;
 721                         info->res.val.i = *(short *)ea;
 722                         info->flags = FE_INEXACT;
 723                         return;
 724                 }
 725                 info->op1.type = fex_ldouble;
 726                 info->op1.val.q = fpreg(uap, 0);
 727                 info->res.val.i = (short) info->op1.val.q;
 728                 goto done;
 729 
 730         case 0x730:
 731         case 0x770:
 732         case 0x7b0:
 733                 /* fbstp; don't bother */
 734                 info->op = fex_other;
 735                 info->op1.type = info->res.type = fex_nodata;
 736                 info->flags = 0;
 737                 return;
 738 
 739         case 0x738:
 740         case 0x778:
 741         case 0x7b8:
 742                 info->res.type = fex_llong;
 743                 if (ex == FPE_FLTRES) {
 744                         /* inexact, stack popped */
 745                         if (!ea) {
 746                                 info->op = fex_other;
 747                                 info->op1.type = info->op2.type = info->res.type = fex_nodata;
 748                                 info->flags = 0;
 749                                 return;
 750                         }
 751                         info->op1.type = fex_nodata;
 752                         info->res.val.l = *(long long *)ea;
 753                         info->flags = FE_INEXACT;
 754                         return;
 755                 }
 756                 info->op1.type = fex_ldouble;
 757                 info->op1.val.q = fpreg(uap, 0);
 758                 info->res.val.l = (long long) info->op1.val.q;
 759                 goto done;
 760         }
 761 
 762         /* all other ops (except compares) have destinations on the stack
 763            so overflow, underflow, and inexact will stomp their operands */
 764         if (ex == FPE_FLTOVF || ex == FPE_FLTUND || ex == FPE_FLTRES) {
 765                 /* find the trapped result */
 766                 info->op1.type = info->op2.type = fex_nodata;
 767                 info->res.type = fex_ldouble;
 768                 switch (op & 0x7f8) {
 769                 case 0x1f0:
 770                         /* fptan pushes 1.0 afterward, so result is in st(1) */
 771                         info->res.val.q = ((op == 0x1f2)? fpreg(uap, 1) :
 772                                 fpreg(uap, 0));
 773                         break;
 774 
 775                 case 0x4c0:
 776                 case 0x4c8:
 777                 case 0x4e0:
 778                 case 0x4e8:
 779                 case 0x4f0:
 780                 case 0x4f8:
 781                         info->res.val.q = fpreg(uap, op & 7);
 782                         break;
 783 
 784                 case 0x6c0:
 785                 case 0x6c8:
 786                 case 0x6e0:
 787                 case 0x6e8:
 788                 case 0x6f0:
 789                 case 0x6f8:
 790                         /* stack was popped afterward */
 791                         info->res.val.q = fpreg(uap, (op - 1) & 7);
 792                         break;
 793 
 794                 default:
 795                         info->res.val.q = fpreg(uap, 0);
 796                 }
 797 
 798                 /* reconstruct default untrapped result */
 799                 if (ex == FPE_FLTOVF) {
 800                         /* generate an overflow with the sign of the result */
 801                         x = two12288;
 802                         *(4+(short*)&x) |= (*(4+(short*)&info->res.val.q) & 0x8000);
 803                         info->res.val.q = x * two12288;
 804                         info->flags = FE_OVERFLOW | FE_INEXACT;
 805                         __fenv_getcwsw(&cwsw);
 806                         cwsw &= ~FE_ALL_EXCEPT;
 807                         __fenv_setcwsw(&cwsw);
 808                 }
 809                 else if (ex == FPE_FLTUND) {
 810                         /* undo the scaling; we can't distinguish a chopped result
 811                            from an exact one without futzing around to trap all in-
 812                            exact exceptions so as to keep the flag clear, so we just
 813                            punt */
 814                         if (sw & 0x200) /* result was rounded up */
 815                                 info->res.val.q = (info->res.val.q * twom12288) * twom12288mulp;
 816                         else
 817                                 info->res.val.q = (info->res.val.q * twom12288) * twom12288;
 818                         __fenv_getcwsw(&cwsw);
 819                         info->flags = (cwsw & FE_INEXACT) | FE_UNDERFLOW;
 820                         cwsw &= ~FE_ALL_EXCEPT;
 821                         __fenv_setcwsw(&cwsw);
 822                 }
 823                 else
 824                         info->flags = FE_INEXACT;
 825 
 826                 /* determine the operation code */
 827                 switch (op) {
 828                 case 0x1f0: /* f2xm1 */
 829                 case 0x1f1: /* fyl2x */
 830                 case 0x1f2: /* fptan */
 831                 case 0x1f3: /* fpatan */
 832                 case 0x1f5: /* fprem1 */
 833                 case 0x1f8: /* fprem */
 834                 case 0x1f9: /* fyl2xp1 */
 835                 case 0x1fb: /* fsincos */
 836                 case 0x1fc: /* frndint */
 837                 case 0x1fd: /* fscale */
 838                 case 0x1fe: /* fsin */
 839                 case 0x1ff: /* fcos */
 840                         info->op = fex_other;
 841                         return;
 842 
 843                 case 0x1fa: /* fsqrt */
 844                         info->op = fex_sqrt;
 845                         return;
 846                 }
 847 
 848                 info->op = fex_other;
 849                 switch (op & 0x7c0) {
 850                 case 0x000:
 851                 case 0x040:
 852                 case 0x080:
 853                 case 0x0c0:
 854                 case 0x200:
 855                 case 0x240:
 856                 case 0x280:
 857                 case 0x400:
 858                 case 0x440:
 859                 case 0x480:
 860                 case 0x4c0:
 861                 case 0x600:
 862                 case 0x640:
 863                 case 0x680:
 864                 case 0x6c0:
 865                         switch (op & 0x38) {
 866                         case 0x00:
 867                                 info->op = fex_add;
 868                                 break;
 869 
 870                         case 0x08:
 871                                 info->op = fex_mul;
 872                                 break;
 873 
 874                         case 0x20:
 875                         case 0x28:
 876                                 info->op = fex_sub;
 877                                 break;
 878 
 879                         case 0x30:
 880                         case 0x38:
 881                                 info->op = fex_div;
 882                                 break;
 883                         }
 884                 }
 885                 return;
 886         }
 887 
 888         /* for other exceptions, the operands are preserved, so we can
 889            just emulate the operation with traps disabled */
 890 
 891         /* one operand is always in st */
 892         info->op1.type = fex_ldouble;
 893         info->op1.val.q = fpreg(uap, 0);
 894 
 895         /* oddball instructions */
 896         info->op = fex_other;
 897         switch (op) {
 898         case 0x1e4: /* ftst */
 899                 info->op = fex_cmp;
 900                 info->op2.type = fex_ldouble;
 901                 info->op2.val.q = 0.0l;
 902                 info->res.type = fex_nodata;
 903                 c = (info->op1.val.q < info->op2.val.q);
 904                 goto done;
 905 
 906         case 0x1f0: /* f2xm1 */
 907                 info->res.type = fex_ldouble;
 908                 info->res.val.q = f2xm1(info->op1.val.q);
 909                 goto done;
 910 
 911         case 0x1f1: /* fyl2x */
 912                 info->op2.type = fex_ldouble;
 913                 info->op2.val.q = fpreg(uap, 1);
 914                 info->res.type = fex_ldouble;
 915                 info->res.val.q = fyl2x(info->op1.val.q, info->op2.val.q);
 916                 goto done;
 917 
 918         case 0x1f2: /* fptan */
 919                 info->res.type = fex_ldouble;
 920                 info->res.val.q = fptan(info->op1.val.q);
 921                 goto done;
 922 
 923         case 0x1f3: /* fpatan */
 924                 info->op2.type = fex_ldouble;
 925                 info->op2.val.q = fpreg(uap, 1);
 926                 info->res.type = fex_ldouble;
 927                 info->res.val.q = fpatan(info->op1.val.q, info->op2.val.q);
 928                 goto done;
 929 
 930         case 0x1f4: /* fxtract */
 931                 info->res.type = fex_ldouble;
 932                 info->res.val.q = fxtract(info->op1.val.q);
 933                 goto done;
 934 
 935         case 0x1f5: /* fprem1 */
 936                 info->op2.type = fex_ldouble;
 937                 info->op2.val.q = fpreg(uap, 1);
 938                 info->res.type = fex_ldouble;
 939                 info->res.val.q = fprem1(info->op1.val.q, info->op2.val.q);
 940                 goto done;
 941 
 942         case 0x1f8: /* fprem */
 943                 info->op2.type = fex_ldouble;
 944                 info->op2.val.q = fpreg(uap, 1);
 945                 info->res.type = fex_ldouble;
 946                 info->res.val.q = fprem(info->op1.val.q, info->op2.val.q);
 947                 goto done;
 948 
 949         case 0x1f9: /* fyl2xp1 */
 950                 info->op2.type = fex_ldouble;
 951                 info->op2.val.q = fpreg(uap, 1);
 952                 info->res.type = fex_ldouble;
 953                 info->res.val.q = fyl2xp1(info->op1.val.q, info->op2.val.q);
 954                 goto done;
 955 
 956         case 0x1fa: /* fsqrt */
 957                 info->op = fex_sqrt;
 958                 info->res.type = fex_ldouble;
 959                 info->res.val.q = fsqrt(info->op1.val.q);
 960                 goto done;
 961 
 962         case 0x1fb: /* fsincos */
 963                 info->res.type = fex_ldouble;
 964                 info->res.val.q = fsincos(info->op1.val.q);
 965                 goto done;
 966 
 967         case 0x1fc: /* frndint */
 968                 info->res.type = fex_ldouble;
 969                 info->res.val.q = frndint(info->op1.val.q);
 970                 goto done;
 971 
 972         case 0x1fd: /* fscale */
 973                 info->op2.type = fex_ldouble;
 974                 info->op2.val.q = fpreg(uap, 1);
 975                 info->res.type = fex_ldouble;
 976                 info->res.val.q = fscale(info->op1.val.q, info->op2.val.q);
 977                 goto done;
 978 
 979         case 0x1fe: /* fsin */
 980                 info->res.type = fex_ldouble;
 981                 info->res.val.q = fsin(info->op1.val.q);
 982                 goto done;
 983 
 984         case 0x1ff: /* fcos */
 985                 info->res.type = fex_ldouble;
 986                 info->res.val.q = fcos(info->op1.val.q);
 987                 goto done;
 988 
 989         case 0x2e9: /* fucompp */
 990                 info->op = fex_cmp;
 991                 info->op2.type = fex_ldouble;
 992                 info->op2.val.q = fpreg(uap, 1);
 993                 info->res.type = fex_nodata;
 994                 c = (info->op1.val.q == info->op2.val.q);
 995                 goto done;
 996         }
 997 
 998         /* fucom[p], fcomi[p], fucomi[p] */
 999         switch (op & 0x7f8) {
1000         case 0x3e8:
1001         case 0x5e0:
1002         case 0x5e8:
1003         case 0x7e8: /* unordered compares */
1004                 info->op = fex_cmp;
1005                 info->op2.type = fex_ldouble;
1006                 info->op2.val.q = fpreg(uap, op & 7);
1007                 info->res.type = fex_nodata;
1008                 c = (info->op1.val.q == info->op2.val.q);
1009                 goto done;
1010 
1011         case 0x3f0:
1012         case 0x7f0: /* ordered compares */
1013                 info->op = fex_cmp;
1014                 info->op2.type = fex_ldouble;
1015                 info->op2.val.q = fpreg(uap, op & 7);
1016                 info->res.type = fex_nodata;
1017                 c = (info->op1.val.q < info->op2.val.q);
1018                 goto done;
1019         }
1020 
1021         /* all other instructions come in groups of the form
1022            fadd, fmul, fcom, fcomp, fsub, fsubr, fdiv, fdivr */
1023 
1024         /* get the second operand */
1025         switch (op & 0x7c0) {
1026         case 0x000:
1027         case 0x040:
1028         case 0x080:
1029                 if (!ea) {
1030                         info->op = fex_other;
1031                         info->op1.type = info->op2.type = info->res.type = fex_nodata;
1032                         info->flags = 0;
1033                         return;
1034                 }
1035                 info->op2.type = fex_float;
1036                 info->op2.val.f = *(float *)ea;
1037                 op2v = (long double) info->op2.val.f;
1038                 break;
1039 
1040         case 0x0c0:
1041                 info->op2.type = fex_ldouble;
1042                 op2v = info->op2.val.q = fpreg(uap, op & 7);
1043                 break;
1044 
1045         case 0x200:
1046         case 0x240:
1047         case 0x280:
1048                 if (!ea) {
1049                         info->op = fex_other;
1050                         info->op1.type = info->op2.type = info->res.type = fex_nodata;
1051                         info->flags = 0;
1052                         return;
1053                 }
1054                 info->op2.type = fex_int;
1055                 info->op2.val.i = *(int *)ea;
1056                 op2v = (long double) info->op2.val.i;
1057                 break;
1058 
1059         case 0x400:
1060         case 0x440:
1061         case 0x480:
1062                 if (!ea) {
1063                         info->op = fex_other;
1064                         info->op1.type = info->op2.type = info->res.type = fex_nodata;
1065                         info->flags = 0;
1066                         return;
1067                 }
1068                 info->op2.type = fex_double;
1069                 info->op2.val.d = *(double *)ea;
1070                 op2v = (long double) info->op2.val.d;
1071                 break;
1072 
1073         case 0x4c0:
1074         case 0x6c0:
1075                 info->op2.type = fex_ldouble;
1076                 info->op2.val.q = fpreg(uap, op & 7);
1077                 t = info->op1;
1078                 info->op1 = info->op2;
1079                 info->op2 = t;
1080                 op2v = info->op2.val.q;
1081                 break;
1082 
1083         case 0x600:
1084         case 0x640:
1085         case 0x680:
1086                 if (!ea) {
1087                         info->op = fex_other;
1088                         info->op1.type = info->op2.type = info->res.type = fex_nodata;
1089                         info->flags = 0;
1090                         return;
1091                 }
1092                 info->op2.type = fex_int;
1093                 info->op2.val.i = *(short *)ea;
1094                 op2v = (long double) info->op2.val.i;
1095                 break;
1096 
1097         default:
1098                 info->op = fex_other;
1099                 info->op1.type = info->op2.type = info->res.type = fex_nodata;
1100                 info->flags = 0;
1101                 return;
1102         }
1103 
1104         /* distinguish different operations in the group */
1105         info->res.type = fex_ldouble;
1106         switch (op & 0x38) {
1107         case 0x00:
1108                 info->op = fex_add;
1109                 info->res.val.q = info->op1.val.q + op2v;
1110                 break;
1111 
1112         case 0x08:
1113                 info->op = fex_mul;
1114                 info->res.val.q = info->op1.val.q * op2v;
1115                 break;
1116 
1117         case 0x10:
1118         case 0x18:
1119                 info->op = fex_cmp;
1120                 info->res.type = fex_nodata;
1121                 c = (info->op1.val.q < op2v);
1122                 break;
1123 
1124         case 0x20:
1125                 info->op = fex_sub;
1126                 info->res.val.q = info->op1.val.q - op2v;
1127                 break;
1128 
1129         case 0x28:
1130                 info->op = fex_sub;
1131                 info->res.val.q = op2v - info->op1.val.q;
1132                 t = info->op1;
1133                 info->op1 = info->op2;
1134                 info->op2 = t;
1135                 break;
1136 
1137         case 0x30:
1138                 info->op = fex_div;
1139                 info->res.val.q = info->op1.val.q / op2v;
1140                 break;
1141 
1142         case 0x38:
1143                 info->op = fex_div;
1144                 info->res.val.q = op2v / info->op1.val.q;
1145                 t = info->op1;
1146                 info->op1 = info->op2;
1147                 info->op2 = t;
1148                 break;
1149 
1150         default:
1151                 info->op = fex_other;
1152                 info->op1.type = info->op2.type = info->res.type = fex_nodata;
1153                 info->flags = 0;
1154                 return;
1155         }
1156 
1157 done:
1158         __fenv_getcwsw(&cwsw);
1159         info->flags = cwsw & FE_ALL_EXCEPT;
1160         cwsw &= ~FE_ALL_EXCEPT;
1161         __fenv_setcwsw(&cwsw);
1162 }
1163 
1164 /* pop the saved stack */
1165 static void pop(ucontext_t *uap)
1166 {
1167         unsigned top;
1168 
1169         fpreg(uap, 0) = fpreg(uap, 1);
1170         fpreg(uap, 1) = fpreg(uap, 2);
1171         fpreg(uap, 2) = fpreg(uap, 3);
1172         fpreg(uap, 3) = fpreg(uap, 4);
1173         fpreg(uap, 4) = fpreg(uap, 5);
1174         fpreg(uap, 5) = fpreg(uap, 6);
1175         fpreg(uap, 6) = fpreg(uap, 7);
1176 #if defined(__amd64)
1177         top = (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw >> 10)
1178                 & 0xe;
1179         uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.fctw |= (3 << top);
1180         top = (top + 2) & 0xe;
1181         uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw =
1182                 (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw & ~0x3800)
1183                 | (top << 10);
1184 #else
1185         top = (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] >> 10)
1186                 & 0xe;
1187         uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[TW] |= (3 << top);
1188         top = (top + 2) & 0xe;
1189         uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] =
1190                 (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] & ~0x3800)
1191                 | (top << 10);
1192 #endif
1193 }
1194 
1195 /* push x onto the saved stack */
1196 static void push(long double x, ucontext_t *uap)
1197 {
1198         unsigned top;
1199 
1200         fpreg(uap, 7) = fpreg(uap, 6);
1201         fpreg(uap, 6) = fpreg(uap, 5);
1202         fpreg(uap, 5) = fpreg(uap, 4);
1203         fpreg(uap, 4) = fpreg(uap, 3);
1204         fpreg(uap, 3) = fpreg(uap, 2);
1205         fpreg(uap, 2) = fpreg(uap, 1);
1206         fpreg(uap, 1) = fpreg(uap, 0);
1207         fpreg(uap, 0) = x;
1208 #if defined(__amd64)
1209         top = (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw >> 10)
1210                 & 0xe;
1211         top = (top - 2) & 0xe;
1212         uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.fctw &= ~(3 << top);
1213         uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw =
1214                 (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw & ~0x3800)
1215                 | (top << 10);
1216 #else
1217         top = (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] >> 10)
1218                 & 0xe;
1219         top = (top - 2) & 0xe;
1220         uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[TW] &= ~(3 << top);
1221         uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] =
1222                 (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] & ~0x3800)
1223                 | (top << 10);
1224 #endif
1225 }
1226 
1227 /* scale factors for exponent wrapping */
1228 static const float
1229         fun = 7.922816251e+28f, /* 2^96 */
1230         fov = 1.262177448e-29f; /* 2^-96 */
1231 static const double
1232         dun = 1.552518092300708935e+231,        /* 2^768 */
1233         dov = 6.441148769597133308e-232;        /* 2^-768 */
1234 
1235 /*
1236 *  Store the specified result; if no result is given but the exception
1237 *  is underflow or overflow, use the default trapped result
1238 */
1239 void
1240 __fex_st_result(siginfo_t *sip, ucontext_t *uap, fex_info_t *info)
1241 {
1242         fex_numeric_t   r;
1243         unsigned long           ex, op, ea, stack;
1244 
1245         /* get the exception type, opcode, and data address */
1246         ex = sip->si_code;
1247 #if defined(__amd64)
1248         op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.fop >> 16;
1249         ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.rdp; /*???*/
1250 #else
1251         op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[OP] >> 16;
1252         ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[EA];
1253 #endif
1254 
1255         /* if the instruction is a compare, set the condition codes
1256            to unordered and update the stack */
1257         switch (op & 0x7f8) {
1258         case 0x010:
1259         case 0x050:
1260         case 0x090:
1261         case 0x0d0:
1262         case 0x210:
1263         case 0x250:
1264         case 0x290:
1265         case 0x410:
1266         case 0x450:
1267         case 0x490:
1268         case 0x4d0:
1269         case 0x5e0:
1270         case 0x610:
1271         case 0x650:
1272         case 0x690:
1273                 /* f[u]com */
1274 #if defined(__amd64)
1275                 uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw |= 0x4500;
1276 #else
1277                 uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] |= 0x4500;
1278 #endif
1279                 return;
1280 
1281         case 0x018:
1282         case 0x058:
1283         case 0x098:
1284         case 0x0d8:
1285         case 0x218:
1286         case 0x258:
1287         case 0x298:
1288         case 0x418:
1289         case 0x458:
1290         case 0x498:
1291         case 0x4d8:
1292         case 0x5e8:
1293         case 0x618:
1294         case 0x658:
1295         case 0x698:
1296         case 0x6d0:
1297                 /* f[u]comp */
1298 #if defined(__amd64)
1299                 uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw |= 0x4500;
1300 #else
1301                 uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] |= 0x4500;
1302 #endif
1303                 pop(uap);
1304                 return;
1305 
1306         case 0x2e8:
1307         case 0x6d8:
1308                 /* f[u]compp */
1309 #if defined(__amd64)
1310                 uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw |= 0x4500;
1311 #else
1312                 uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] |= 0x4500;
1313 #endif
1314                 pop(uap);
1315                 pop(uap);
1316                 return;
1317 
1318         case 0x1e0:
1319                 if (op == 0x1e4) { /* ftst */
1320 #if defined(__amd64)
1321                         uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw |= 0x4500;
1322 #else
1323                         uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] |= 0x4500;
1324 #endif
1325                         return;
1326                 }
1327                 break;
1328 
1329         case 0x3e8:
1330         case 0x3f0:
1331                 /* f[u]comi */
1332 #if defined(__amd64)
1333                 uap->uc_mcontext.gregs[REG_PS] |= 0x45;
1334 #else
1335                 uap->uc_mcontext.gregs[EFL] |= 0x45;
1336 #endif
1337                 return;
1338 
1339         case 0x7e8:
1340         case 0x7f0:
1341                 /* f[u]comip */
1342 #if defined(__amd64)
1343                 uap->uc_mcontext.gregs[REG_PS] |= 0x45;
1344 #else
1345                 uap->uc_mcontext.gregs[EFL] |= 0x45;
1346 #endif
1347                 pop(uap);
1348                 return;
1349         }
1350 
1351         /* if there is no result available and the exception is overflow
1352            or underflow, use the wrapped result */
1353         r = info->res;
1354         if (r.type == fex_nodata) {
1355                 if (ex == FPE_FLTOVF || ex == FPE_FLTUND) {
1356                         /* for store instructions, do the scaling and store */
1357                         switch (op & 0x7f8) {
1358                         case 0x110:
1359                         case 0x118:
1360                         case 0x150:
1361                         case 0x158:
1362                         case 0x190:
1363                         case 0x198:
1364                                 if (!ea)
1365                                         return;
1366                                 if (ex == FPE_FLTOVF)
1367                                         *(float *)ea = (fpreg(uap, 0) * fov) * fov;
1368                                 else
1369                                         *(float *)ea = (fpreg(uap, 0) * fun) * fun;
1370                                 if ((op & 8) != 0)
1371                                         pop(uap);
1372                                 break;
1373 
1374                         case 0x510:
1375                         case 0x518:
1376                         case 0x550:
1377                         case 0x558:
1378                         case 0x590:
1379                         case 0x598:
1380                                 if (!ea)
1381                                         return;
1382                                 if (ex == FPE_FLTOVF)
1383                                         *(double *)ea = (fpreg(uap, 0) * dov) * dov;
1384                                 else
1385                                         *(double *)ea = (fpreg(uap, 0) * dun) * dun;
1386                                 if ((op & 8) != 0)
1387                                         pop(uap);
1388                                 break;
1389                         }
1390                 }
1391 #ifdef DEBUG
1392                 else if (ex != FPE_FLTRES)
1393                         printf( "No result supplied, stack may be hosed\n" );
1394 #endif
1395                 return;
1396         }
1397 
1398         /* otherwise convert the supplied result to the correct type,
1399            put it in the destination, and update the stack as need be */
1400 
1401         /* store instructions */
1402         switch (op & 0x7f8) {
1403         case 0x110:
1404         case 0x118:
1405         case 0x150:
1406         case 0x158:
1407         case 0x190:
1408         case 0x198:
1409                 if (!ea)
1410                         return;
1411                 switch (r.type) {
1412                 case fex_int:
1413                         *(float *)ea = (float) r.val.i;
1414                         break;
1415 
1416                 case fex_llong:
1417                         *(float *)ea = (float) r.val.l;
1418                         break;
1419 
1420                 case fex_float:
1421                         *(float *)ea = r.val.f;
1422                         break;
1423 
1424                 case fex_double:
1425                         *(float *)ea = (float) r.val.d;
1426                         break;
1427 
1428                 case fex_ldouble:
1429                         *(float *)ea = (float) r.val.q;
1430                         break;
1431 
1432                 default:
1433                         break;
1434                 }
1435                 if (ex != FPE_FLTRES && (op & 8) != 0)
1436                         pop(uap);
1437                 return;
1438 
1439         case 0x310:
1440         case 0x318:
1441         case 0x350:
1442         case 0x358:
1443         case 0x390:
1444         case 0x398:
1445                 if (!ea)
1446                         return;
1447                 switch (r.type) {
1448                 case fex_int:
1449                         *(int *)ea = r.val.i;
1450                         break;
1451 
1452                 case fex_llong:
1453                         *(int *)ea = (int) r.val.l;
1454                         break;
1455 
1456                 case fex_float:
1457                         *(int *)ea = (int) r.val.f;
1458                         break;
1459 
1460                 case fex_double:
1461                         *(int *)ea = (int) r.val.d;
1462                         break;
1463 
1464                 case fex_ldouble:
1465                         *(int *)ea = (int) r.val.q;
1466                         break;
1467 
1468                 default:
1469                         break;
1470                 }
1471                 if (ex != FPE_FLTRES && (op & 8) != 0)
1472                         pop(uap);
1473                 return;
1474 
1475         case 0x510:
1476         case 0x518:
1477         case 0x550:
1478         case 0x558:
1479         case 0x590:
1480         case 0x598:
1481                 if (!ea)
1482                         return;
1483                 switch (r.type) {
1484                 case fex_int:
1485                         *(double *)ea = (double) r.val.i;
1486                         break;
1487 
1488                 case fex_llong:
1489                         *(double *)ea = (double) r.val.l;
1490                         break;
1491 
1492                 case fex_float:
1493                         *(double *)ea = (double) r.val.f;
1494                         break;
1495 
1496                 case fex_double:
1497                         *(double *)ea = r.val.d;
1498                         break;
1499 
1500                 case fex_ldouble:
1501                         *(double *)ea = (double) r.val.q;
1502                         break;
1503 
1504                 default:
1505                         break;
1506                 }
1507                 if (ex != FPE_FLTRES && (op & 8) != 0)
1508                         pop(uap);
1509                 return;
1510 
1511         case 0x710:
1512         case 0x718:
1513         case 0x750:
1514         case 0x758:
1515         case 0x790:
1516         case 0x798:
1517                 if (!ea)
1518                         return;
1519                 switch (r.type) {
1520                 case fex_int:
1521                         *(short *)ea = (short) r.val.i;
1522                         break;
1523 
1524                 case fex_llong:
1525                         *(short *)ea = (short) r.val.l;
1526                         break;
1527 
1528                 case fex_float:
1529                         *(short *)ea = (short) r.val.f;
1530                         break;
1531 
1532                 case fex_double:
1533                         *(short *)ea = (short) r.val.d;
1534                         break;
1535 
1536                 case fex_ldouble:
1537                         *(short *)ea = (short) r.val.q;
1538                         break;
1539 
1540                 default:
1541                         break;
1542                 }
1543                 if (ex != FPE_FLTRES && (op & 8) != 0)
1544                         pop(uap);
1545                 return;
1546 
1547         case 0x730:
1548         case 0x770:
1549         case 0x7b0:
1550                 /* fbstp; don't bother */
1551                 if (ea && ex != FPE_FLTRES)
1552                         pop(uap);
1553                 return;
1554 
1555         case 0x738:
1556         case 0x778:
1557         case 0x7b8:
1558                 if (!ea)
1559                         return;
1560                 switch (r.type) {
1561                 case fex_int:
1562                         *(long long *)ea = (long long) r.val.i;
1563                         break;
1564 
1565                 case fex_llong:
1566                         *(long long *)ea = r.val.l;
1567                         break;
1568 
1569                 case fex_float:
1570                         *(long long *)ea = (long long) r.val.f;
1571                         break;
1572 
1573                 case fex_double:
1574                         *(long long *)ea = (long long) r.val.d;
1575                         break;
1576 
1577                 case fex_ldouble:
1578                         *(long long *)ea = (long long) r.val.q;
1579                         break;
1580 
1581                 default:
1582                         break;
1583                 }
1584                 if (ex != FPE_FLTRES)
1585                         pop(uap);
1586                 return;
1587         }
1588 
1589         /* for all other instructions, the result goes into a register */
1590         switch (r.type) {
1591         case fex_int:
1592                 r.val.q = (long double) r.val.i;
1593                 break;
1594 
1595         case fex_llong:
1596                 r.val.q = (long double) r.val.l;
1597                 break;
1598 
1599         case fex_float:
1600                 r.val.q = (long double) r.val.f;
1601                 break;
1602 
1603         case fex_double:
1604                 r.val.q = (long double) r.val.d;
1605                 break;
1606 
1607         default:
1608                 break;
1609         }
1610 
1611         /* for load instructions, push the result onto the stack */
1612         switch (op & 0x7f8) {
1613         case 0x100:
1614         case 0x140:
1615         case 0x180:
1616         case 0x500:
1617         case 0x540:
1618         case 0x580:
1619                 if (ea)
1620                         push(r.val.q, uap);
1621                 return;
1622         }
1623 
1624         /* for all other instructions, if the exception is overflow,
1625            underflow, or inexact, the stack has already been updated */
1626         stack = (ex == FPE_FLTOVF || ex == FPE_FLTUND || ex == FPE_FLTRES);
1627         switch (op & 0x7f8) {
1628         case 0x1f0: /* oddballs */
1629                 switch (op) {
1630                 case 0x1f1: /* fyl2x */
1631                 case 0x1f3: /* fpatan */
1632                 case 0x1f9: /* fyl2xp1 */
1633                         /* pop the stack, leaving the result in st */
1634                         if (!stack)
1635                                 pop(uap);
1636                         fpreg(uap, 0) = r.val.q;
1637                         return;
1638 
1639                 case 0x1f2: /* fpatan */
1640                         /* fptan pushes 1.0 afterward */
1641                         if (stack)
1642                                 fpreg(uap, 1) = r.val.q;
1643                         else {
1644                                 fpreg(uap, 0) = r.val.q;
1645                                 push(1.0L, uap);
1646                         }
1647                         return;
1648 
1649                 case 0x1f4: /* fxtract */
1650                 case 0x1fb: /* fsincos */
1651                         /* leave the supplied result in st */
1652                         if (stack)
1653                                 fpreg(uap, 0) = r.val.q;
1654                         else {
1655                                 fpreg(uap, 0) = 0.0; /* punt */
1656                                 push(r.val.q, uap);
1657                         }
1658                         return;
1659                 }
1660 
1661                 /* all others leave the stack alone and the result in st */
1662                 fpreg(uap, 0) = r.val.q;
1663                 return;
1664 
1665         case 0x4c0:
1666         case 0x4c8:
1667         case 0x4e0:
1668         case 0x4e8:
1669         case 0x4f0:
1670         case 0x4f8:
1671                 fpreg(uap, op & 7) = r.val.q;
1672                 return;
1673 
1674         case 0x6c0:
1675         case 0x6c8:
1676         case 0x6e0:
1677         case 0x6e8:
1678         case 0x6f0:
1679         case 0x6f8:
1680                 /* stack is popped afterward */
1681                 if (stack)
1682                         fpreg(uap, (op - 1) & 7) = r.val.q;
1683                 else {
1684                         fpreg(uap, op & 7) = r.val.q;
1685                         pop(uap);
1686                 }
1687                 return;
1688 
1689         default:
1690                 fpreg(uap, 0) = r.val.q;
1691                 return;
1692         }
1693 }