common/m9x/__fex_i386.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <siginfo.h>
#include <ucontext.h>
#include <thread.h>
#include <math.h>
#if defined(__SUNPRO_C)
#include <sunmath.h>
#endif
#include <fenv.h>
#include "fex_handler.h"
#include "fenv_inlines.h"

#if defined(__amd64)
#define test_sse_hw 1
#else
/*
 * The following variable lives in libc on Solaris 10, where it
 * gets set to a nonzero value at startup time on systems with SSE.
 */
extern int _sse_hw;
#define test_sse_hw _sse_hw
#endif

static int accrued = 0;
static thread_key_t accrued_key;
static mutex_t accrued_key_lock = DEFAULTMUTEX;

int *
__fex_accrued()
{
    int     *p;

    if (thr_main())
        return &accrued;
    else {
        p = NULL;
        mutex_lock(&accrued_key_lock);
        if (thr_getspecific(accrued_key, (void **)&p) != 0 &&
            thr_keycreate(&accrued_key, free) != 0) {
            mutex_unlock(&accrued_key_lock);
            return NULL;
        }
        mutex_unlock(&accrued_key_lock);
        if (!p) {
            if ((p = (int*) malloc(sizeof(int))) == NULL)
                return NULL;
            if (thr_setspecific(accrued_key, (void *)p) != 0) {
                (void)free(p);
                return NULL;
            }
            *p = 0;
        }
        return p;
    }
}

void
__fenv_getfsr(unsigned long *fsr)
{
    unsigned int    cwsw, mxcsr;

    __fenv_getcwsw(&cwsw);
    /* clear reserved bits for no particularly good reason */
    cwsw &= ~0xe0c00000u;
    if (test_sse_hw) {
        /* pick up exception flags (excluding denormal operand
           flag) from mxcsr */
        __fenv_getmxcsr(&mxcsr);
        cwsw |= (mxcsr & 0x3d);
    }
    cwsw |= *__fex_accrued();
    *fsr = cwsw ^ 0x003f0000u;
}

void
__fenv_setfsr(const unsigned long *fsr)
{
    unsigned int    cwsw, mxcsr;
    int             te;

    /* save accrued exception flags corresponding to enabled exceptions */
    cwsw = (unsigned int)*fsr;
    te = __fenv_get_te(cwsw);
    *__fex_accrued() = cwsw & te;
    cwsw = (cwsw & ~te) ^ 0x003f0000;
    if (test_sse_hw) {
        /* propagate rounding direction, masks, and exception flags
           (excluding denormal operand mask and flag) to mxcsr */
        __fenv_getmxcsr(&mxcsr);
        mxcsr = (mxcsr & ~0x7ebd) | ((cwsw >> 13) & 0x6000) |
            ((cwsw >> 9) & 0x1e80) | (cwsw & 0x3d);
        __fenv_setmxcsr(&mxcsr);
    }
    __fenv_setcwsw(&cwsw);
}

/* Offsets into the fp environment save area (assumes 32-bit protected mode) */
#define CW  0   /* control word */
#define SW  1   /* status word */
#define TW  2   /* tag word */
#define IP  3   /* instruction pointer */
#define OP  4   /* opcode */
#define EA  5   /* operand address */

/* macro for accessing fp registers in the save area */
#if defined(__amd64)
#define fpreg(u,x)  *(long double *)(10*(x)+(char*)&(u)->uc_mcontext.fpregs.fp_reg_set.fpchip_state.st)
#else
#define fpreg(u,x)  *(long double *)(10*(x)+(char*)&(u)->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[7])
#endif

/*
*  Fix sip->si_code; the Solaris x86 kernel can get it wrong
*/
void
__fex_get_x86_exc(siginfo_t *sip, ucontext_t *uap)
{
    unsigned    sw, cw;

    sw = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.status;
#if defined(__amd64)
    cw = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.cw;
#else
    cw = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[CW];
#endif
    if ((sw & FE_INVALID) && !(cw & (1 << fp_trap_invalid)))
        /* store 0 for stack fault, FPE_FLTINV for IEEE invalid op */
        sip->si_code = ((sw & 0x40)? 0 : FPE_FLTINV);
    else if ((sw & FE_DIVBYZERO) && !(cw & (1 << fp_trap_division)))
        sip->si_code = FPE_FLTDIV;
    else if ((sw & FE_OVERFLOW) && !(cw & (1 << fp_trap_overflow)))
        sip->si_code = FPE_FLTOVF;
    else if ((sw & FE_UNDERFLOW) && !(cw & (1 << fp_trap_underflow)))
        sip->si_code = FPE_FLTUND;
    else if ((sw & FE_INEXACT) && !(cw & (1 << fp_trap_inexact)))
        sip->si_code = FPE_FLTRES;
    else
        sip->si_code = 0;
}

static enum fp_class_type
my_fp_classf(float *x)
{
    int     i = *(int*)x & ~0x80000000;

    if (i < 0x7f800000) {
        if (i < 0x00800000)
            return ((i == 0)? fp_zero : fp_subnormal);
        return fp_normal;
    }
    else if (i == 0x7f800000)
        return fp_infinity;
    else if (i & 0x400000)
        return fp_quiet;
    else
        return fp_signaling;
}

static enum fp_class_type
my_fp_class(double *x)
{
    int     i = *(1+(int*)x) & ~0x80000000;

    if (i < 0x7ff00000) {
        if (i < 0x00100000)
            return (((i | *(int*)x) == 0)? fp_zero : fp_subnormal);
        return fp_normal;
    }
    else if (i == 0x7ff00000 && *(int*)x == 0)
        return fp_infinity;
    else if (i & 0x80000)
        return fp_quiet;
    else
        return fp_signaling;
}

static enum fp_class_type
my_fp_classl(long double *x)
{
    int     i = *(2+(int*)x) & 0x7fff;

    if (i < 0x7fff) {
        if (i < 1) {
            if (*(1+(int*)x) < 0) return fp_normal; /* pseudo-denormal */
            return (((*(1+(int*)x) | *(int*)x) == 0)?
                fp_zero : fp_subnormal);
        }
        return ((*(1+(int*)x) < 0)? fp_normal :
            (enum fp_class_type) -1); /* unsupported format */
    }
    else if (*(1+(int*)x) == 0x80000000 && *(int*)x == 0)
        return fp_infinity;
    else if (*(1+(unsigned*)x) >= 0xc0000000)
        return fp_quiet;
    else if (*(1+(int*)x) < 0)
        return fp_signaling;
    else
        return (enum fp_class_type) -1; /* unsupported format */
}

/*
*  Determine which type of invalid operation exception occurred
*/
enum fex_exception
__fex_get_invalid_type(siginfo_t *sip, ucontext_t *uap)
{
    unsigned            op;
    unsigned long           ea;
    enum fp_class_type  t1, t2;

    /* get the opcode and data address */
#if defined(__amd64)
    op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.fop >> 16;
    ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.rdp;
#else
    op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[OP] >> 16;
    ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[EA];
#endif

    /* if the instruction is fld, the source must be snan (it can't be
       an unsupported format, since fldt doesn't raise any exceptions) */
    switch (op & 0x7f8) {
    case 0x100:
    case 0x140:
    case 0x180:
    case 0x500:
    case 0x540:
    case 0x580:
        return fex_inv_snan;
    }

    /* otherwise st is one of the operands; see if it's snan */
    t1 = my_fp_classl(&fpreg(uap, 0));
    if (t1 == fp_signaling)
        return fex_inv_snan;
    else if (t1 == (enum fp_class_type) -1)
        return (enum fex_exception) -1;

    /* determine the class of the second operand if there is one */
    t2 = fp_normal;
    switch (op & 0x7e0) {
    case 0x600:
    case 0x620:
    case 0x640:
    case 0x660:
    case 0x680:
    case 0x6a0:
        /* short memory operand */
        if (!ea)
            return (enum fex_exception) -1;
        if (*(short *)ea == 0)
            t2 = fp_zero;
        break;

    case 0x200:
    case 0x220:
    case 0x240:
    case 0x260:
    case 0x280:
    case 0x2a0:
        /* int memory operand */
        if (!ea)
            return (enum fex_exception) -1;
        if (*(int *)ea == 0)
            t2 = fp_zero;
        break;

    case 0x000:
    case 0x020:
    case 0x040:
    case 0x060:
    case 0x080:
    case 0x0a0:
        /* single precision memory operand */
        if (!ea)
            return (enum fex_exception) -1;
        t2 = my_fp_classf((float *)ea);
        break;

    case 0x400:
    case 0x420:
    case 0x440:
    case 0x460:
    case 0x480:
    case 0x4a0:
        /* double precision memory operand */
        if (!ea)
            return (enum fex_exception) -1;
        t2 = my_fp_class((double *)ea);
        break;

    case 0x0c0:
    case 0x0e0:
    case 0x3e0:
    case 0x4c0:
    case 0x4e0:
    case 0x5e0:
    case 0x6c0:
    case 0x6e0:
    case 0x7e0:
        /* register operand determined by opcode */
        switch (op & 0x7f8) {
        case 0x3e0:
        case 0x3f8:
        case 0x5f0:
        case 0x5f8:
        case 0x7e0:
        case 0x7f8:
            /* weed out nonexistent opcodes */
            break;

        default:
            t2 = my_fp_classl(&fpreg(uap, op & 7));
        }
        break;

    case 0x1e0:
    case 0x2e0:
        /* special forms */
        switch (op) {
        case 0x1f1: /* fyl2x */
        case 0x1f3: /* fpatan */
        case 0x1f5: /* fprem1 */
        case 0x1f8: /* fprem */
        case 0x1f9: /* fyl2xp1 */
        case 0x1fd: /* fscale */
        case 0x2e9: /* fucompp */
            t2 = my_fp_classl(&fpreg(uap, 1));
            break;
        }
        break;
    }

    /* see if the second op is snan */
    if (t2 == fp_signaling)
        return fex_inv_snan;
    else if (t2 == (enum fp_class_type) -1)
        return (enum fex_exception) -1;

    /* determine the type of operation */
    switch (op & 0x7f8) {
    case 0x000:
    case 0x020:
    case 0x028:
    case 0x040:
    case 0x060:
    case 0x068:
    case 0x080:
    case 0x0a0:
    case 0x0a8:
    case 0x0c0:
    case 0x0e0:
    case 0x0e8:
    case 0x400:
    case 0x420:
    case 0x428:
    case 0x440:
    case 0x460:
    case 0x468:
    case 0x480:
    case 0x4a0:
    case 0x4a8:
    case 0x4c0:
    case 0x4e0:
    case 0x4e8:
    case 0x6c0:
    case 0x6e0:
    case 0x6e8:
        /* fadd, fsub, fsubr */
        if (t1 == fp_infinity && t2 == fp_infinity)
            return fex_inv_isi;
        break;

    case 0x008:
    case 0x048:
    case 0x088:
    case 0x0c8:
    case 0x208:
    case 0x248:
    case 0x288:
    case 0x408:
    case 0x448:
    case 0x488:
    case 0x4c8:
    case 0x608:
    case 0x648:
    case 0x688:
    case 0x6c8:
        /* fmul */
        if ((t1 == fp_zero && t2 == fp_infinity) || (t2 == fp_zero &&
          t1 == fp_infinity))
            return fex_inv_zmi;
        break;

    case 0x030:
    case 0x038:
    case 0x070:
    case 0x078:
    case 0x0b0:
    case 0x0b8:
    case 0x0f0:
    case 0x0f8:
    case 0x230:
    case 0x238:
    case 0x270:
    case 0x278:
    case 0x2b0:
    case 0x2b8:
    case 0x430:
    case 0x438:
    case 0x470:
    case 0x478:
    case 0x4b0:
    case 0x4b8:
    case 0x4f0:
    case 0x4f8:
    case 0x630:
    case 0x638:
    case 0x670:
    case 0x678:
    case 0x6b0:
    case 0x6b8:
    case 0x6f0:
    case 0x6f8:
        /* fdiv */
        if (t1 == fp_zero && t2 == fp_zero)
            return fex_inv_zdz;
        else if (t1 == fp_infinity && t2 == fp_infinity)
            return fex_inv_idi;
        break;

    case 0x1f0:
    case 0x1f8:
        /* fsqrt, other special ops */
        return fex_inv_sqrt;

    case 0x010:
    case 0x018:
    case 0x050:
    case 0x058:
    case 0x090:
    case 0x098:
    case 0x0d0:
    case 0x0d8:
    case 0x210:
    case 0x218:
    case 0x250:
    case 0x258:
    case 0x290:
    case 0x298:
    case 0x2e8:
    case 0x3f0:
    case 0x410:
    case 0x418:
    case 0x450:
    case 0x458:
    case 0x490:
    case 0x498:
    case 0x4d0:
    case 0x4d8:
    case 0x5e0:
    case 0x5e8:
    case 0x610:
    case 0x618:
    case 0x650:
    case 0x658:
    case 0x690:
    case 0x698:
    case 0x6d0:
    case 0x6d8:
    case 0x7f0:
        /* fcom */
        if (t1 == fp_quiet || t2 == fp_quiet)
            return fex_inv_cmp;
        break;

    case 0x1e0:
        /* ftst */
        if (op == 0x1e4 && t1 == fp_quiet)
            return fex_inv_cmp;
        break;

    case 0x310:
    case 0x318:
    case 0x350:
    case 0x358:
    case 0x390:
    case 0x398:
    case 0x710:
    case 0x718:
    case 0x730:
    case 0x738:
    case 0x750:
    case 0x758:
    case 0x770:
    case 0x778:
    case 0x790:
    case 0x798:
    case 0x7b0:
    case 0x7b8:
        /* fist, fbst */
        return fex_inv_int;
    }

    return (enum fex_exception) -1;
}

/* scale factors for exponent unwrapping */
static const long double
    two12288 = 1.139165225263043370845938579315932009e+3699l,   /* 2^12288 */
    twom12288 = 8.778357852076208839765066529179033145e-3700l,  /* 2^-12288 */
    twom12288mulp = 8.778357852076208839289190796475222545e-3700l;
        /* (")*(1-2^-64) */

/* inline templates */
extern long double f2xm1(long double);
extern long double fyl2x(long double, long double);
extern long double fptan(long double);
extern long double fpatan(long double, long double);
extern long double fxtract(long double);
extern long double fprem1(long double, long double);
extern long double fprem(long double, long double);
extern long double fyl2xp1(long double, long double);
extern long double fsqrt(long double);
extern long double fsincos(long double);
extern long double frndint(long double);
extern long double fscale(long double, long double);
extern long double fsin(long double);
extern long double fcos(long double);

/*
*  Get the operands, generate the default untrapped result with
*  exceptions, and set a code indicating the type of operation
*/
void
__fex_get_op(siginfo_t *sip, ucontext_t *uap, fex_info_t *info)
{
    fex_numeric_t           t;
    long double         op2v, x;
    unsigned int            cwsw, ex, sw, op;
    unsigned long           ea;
    volatile int            c;

    /* get the exception type, status word, opcode, and data address */
    ex = sip->si_code;
    sw = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.status;
#if defined(__amd64)
    op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.fop >> 16;
    ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.rdp;
#else
    op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[OP] >> 16;
    ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[EA];
#endif

    /* initialize res to the default untrapped result and ex to the
       corresponding flags (assume trapping is disabled and flags
       are clear) */

    /* single operand instructions */
    info->op = fex_cnvt;
    info->op2.type = fex_nodata;
    switch (op & 0x7f8) {
    /* load instructions */
    case 0x100:
    case 0x140:
    case 0x180:
        if (!ea) {
            info->op = fex_other;
            info->op1.type = info->op2.type = info->res.type = fex_nodata;
            info->flags = 0;
            return;
        }
        info->op1.type = fex_float;
        info->op1.val.f = *(float *)ea;
        info->res.type = fex_ldouble;
        info->res.val.q = (long double) info->op1.val.f;
        goto done;

    case 0x500:
    case 0x540:
    case 0x580:
        if (!ea) {
            info->op = fex_other;
            info->op1.type = info->op2.type = info->res.type = fex_nodata;
            info->flags = 0;
            return;
        }
        info->op1.type = fex_double;
        info->op1.val.d = *(double *)ea;
        info->res.type = fex_ldouble;
        info->res.val.q = (long double) info->op1.val.d;
        goto done;

    /* store instructions */
    case 0x110:
    case 0x118:
    case 0x150:
    case 0x158:
    case 0x190:
    case 0x198:
        info->res.type = fex_float;
        if (ex == FPE_FLTRES && (op & 8) != 0) {
            /* inexact, stack popped */
            if (!ea) {
                info->op = fex_other;
                info->op1.type = info->op2.type = info->res.type = fex_nodata;
                info->flags = 0;
                return;
            }
            info->op1.type = fex_nodata;
            info->res.val.f = *(float *)ea;
            info->flags = FE_INEXACT;
            return;
        }
        info->op1.type = fex_ldouble;
        info->op1.val.q = fpreg(uap, 0);
        info->res.val.f = (float) info->op1.val.q;
        goto done;

    case 0x310:
    case 0x318:
    case 0x350:
    case 0x358:
    case 0x390:
    case 0x398:
        info->res.type = fex_int;
        if (ex == FPE_FLTRES && (op & 8) != 0) {
            /* inexact, stack popped */
            if (!ea) {
                info->op = fex_other;
                info->op1.type = info->op2.type = info->res.type = fex_nodata;
                info->flags = 0;
                return;
            }
            info->op1.type = fex_nodata;
            info->res.val.i = *(int *)ea;
            info->flags = FE_INEXACT;
            return;
        }
        info->op1.type = fex_ldouble;
        info->op1.val.q = fpreg(uap, 0);
        info->res.val.i = (int) info->op1.val.q;
        goto done;

    case 0x510:
    case 0x518:
    case 0x550:
    case 0x558:
    case 0x590:
    case 0x598:
        info->res.type = fex_double;
        if (ex == FPE_FLTRES && (op & 8) != 0) {
            /* inexact, stack popped */
            if (!ea) {
                info->op = fex_other;
                info->op1.type = info->op2.type = info->res.type = fex_nodata;
                info->flags = 0;
                return;
            }
            info->op1.type = fex_nodata;
            info->res.val.d = *(double *)ea;
            info->flags = FE_INEXACT;
            return;
        }
        info->op1.type = fex_ldouble;
        info->op1.val.q = fpreg(uap, 0);
        info->res.val.d = (double) info->op1.val.q;
        goto done;

    case 0x710:
    case 0x718:
    case 0x750:
    case 0x758:
    case 0x790:
    case 0x798:
        info->res.type = fex_int;
        if (ex == FPE_FLTRES && (op & 8) != 0) {
            /* inexact, stack popped */
            if (!ea) {
                info->op = fex_other;
                info->op1.type = info->op2.type = info->res.type = fex_nodata;
                info->flags = 0;
                return;
            }
            info->op1.type = fex_nodata;
            info->res.val.i = *(short *)ea;
            info->flags = FE_INEXACT;
            return;
        }
        info->op1.type = fex_ldouble;
        info->op1.val.q = fpreg(uap, 0);
        info->res.val.i = (short) info->op1.val.q;
        goto done;

    case 0x730:
    case 0x770:
    case 0x7b0:
        /* fbstp; don't bother */
        info->op = fex_other;
        info->op1.type = info->res.type = fex_nodata;
        info->flags = 0;
        return;

    case 0x738:
    case 0x778:
    case 0x7b8:
        info->res.type = fex_llong;
        if (ex == FPE_FLTRES) {
            /* inexact, stack popped */
            if (!ea) {
                info->op = fex_other;
                info->op1.type = info->op2.type = info->res.type = fex_nodata;
                info->flags = 0;
                return;
            }
            info->op1.type = fex_nodata;
            info->res.val.l = *(long long *)ea;
            info->flags = FE_INEXACT;
            return;
        }
        info->op1.type = fex_ldouble;
        info->op1.val.q = fpreg(uap, 0);
        info->res.val.l = (long long) info->op1.val.q;
        goto done;
    }

    /* all other ops (except compares) have destinations on the stack
       so overflow, underflow, and inexact will stomp their operands */
    if (ex == FPE_FLTOVF || ex == FPE_FLTUND || ex == FPE_FLTRES) {
        /* find the trapped result */
        info->op1.type = info->op2.type = fex_nodata;
        info->res.type = fex_ldouble;
        switch (op & 0x7f8) {
        case 0x1f0:
            /* fptan pushes 1.0 afterward, so result is in st(1) */
            info->res.val.q = ((op == 0x1f2)? fpreg(uap, 1) :
                fpreg(uap, 0));
            break;

        case 0x4c0:
        case 0x4c8:
        case 0x4e0:
        case 0x4e8:
        case 0x4f0:
        case 0x4f8:
            info->res.val.q = fpreg(uap, op & 7);
            break;

        case 0x6c0:
        case 0x6c8:
        case 0x6e0:
        case 0x6e8:
        case 0x6f0:
        case 0x6f8:
            /* stack was popped afterward */
            info->res.val.q = fpreg(uap, (op - 1) & 7);
            break;

        default:
            info->res.val.q = fpreg(uap, 0);
        }

        /* reconstruct default untrapped result */
        if (ex == FPE_FLTOVF) {
            /* generate an overflow with the sign of the result */
            x = two12288;
            *(4+(short*)&x) |= (*(4+(short*)&info->res.val.q) & 0x8000);
            info->res.val.q = x * two12288;
            info->flags = FE_OVERFLOW | FE_INEXACT;
            __fenv_getcwsw(&cwsw);
            cwsw &= ~FE_ALL_EXCEPT;
            __fenv_setcwsw(&cwsw);
        }
        else if (ex == FPE_FLTUND) {
            /* undo the scaling; we can't distinguish a chopped result
               from an exact one without futzing around to trap all in-
               exact exceptions so as to keep the flag clear, so we just
               punt */
            if (sw & 0x200) /* result was rounded up */
                info->res.val.q = (info->res.val.q * twom12288) * twom12288mulp;
            else
                info->res.val.q = (info->res.val.q * twom12288) * twom12288;
            __fenv_getcwsw(&cwsw);
            info->flags = (cwsw & FE_INEXACT) | FE_UNDERFLOW;
            cwsw &= ~FE_ALL_EXCEPT;
            __fenv_setcwsw(&cwsw);
        }
        else
            info->flags = FE_INEXACT;

        /* determine the operation code */
        switch (op) {
        case 0x1f0: /* f2xm1 */
        case 0x1f1: /* fyl2x */
        case 0x1f2: /* fptan */
        case 0x1f3: /* fpatan */
        case 0x1f5: /* fprem1 */
        case 0x1f8: /* fprem */
        case 0x1f9: /* fyl2xp1 */
        case 0x1fb: /* fsincos */
        case 0x1fc: /* frndint */
        case 0x1fd: /* fscale */
        case 0x1fe: /* fsin */
        case 0x1ff: /* fcos */
            info->op = fex_other;
            return;

        case 0x1fa: /* fsqrt */
            info->op = fex_sqrt;
            return;
        }

        info->op = fex_other;
        switch (op & 0x7c0) {
        case 0x000:
        case 0x040:
        case 0x080:
        case 0x0c0:
        case 0x200:
        case 0x240:
        case 0x280:
        case 0x400:
        case 0x440:
        case 0x480:
        case 0x4c0:
        case 0x600:
        case 0x640:
        case 0x680:
        case 0x6c0:
            switch (op & 0x38) {
            case 0x00:
                info->op = fex_add;
                break;

            case 0x08:
                info->op = fex_mul;
                break;

            case 0x20:
            case 0x28:
                info->op = fex_sub;
                break;

            case 0x30:
            case 0x38:
                info->op = fex_div;
                break;
            }
        }
        return;
    }

    /* for other exceptions, the operands are preserved, so we can
       just emulate the operation with traps disabled */

    /* one operand is always in st */
    info->op1.type = fex_ldouble;
    info->op1.val.q = fpreg(uap, 0);

    /* oddball instructions */
    info->op = fex_other;
    switch (op) {
    case 0x1e4: /* ftst */
        info->op = fex_cmp;
        info->op2.type = fex_ldouble;
        info->op2.val.q = 0.0l;
        info->res.type = fex_nodata;
        c = (info->op1.val.q < info->op2.val.q);
        goto done;

    case 0x1f0: /* f2xm1 */
        info->res.type = fex_ldouble;
        info->res.val.q = f2xm1(info->op1.val.q);
        goto done;

    case 0x1f1: /* fyl2x */
        info->op2.type = fex_ldouble;
        info->op2.val.q = fpreg(uap, 1);
        info->res.type = fex_ldouble;
        info->res.val.q = fyl2x(info->op1.val.q, info->op2.val.q);
        goto done;

    case 0x1f2: /* fptan */
        info->res.type = fex_ldouble;
        info->res.val.q = fptan(info->op1.val.q);
        goto done;

    case 0x1f3: /* fpatan */
        info->op2.type = fex_ldouble;
        info->op2.val.q = fpreg(uap, 1);
        info->res.type = fex_ldouble;
        info->res.val.q = fpatan(info->op1.val.q, info->op2.val.q);
        goto done;

    case 0x1f4: /* fxtract */
        info->res.type = fex_ldouble;
        info->res.val.q = fxtract(info->op1.val.q);
        goto done;

    case 0x1f5: /* fprem1 */
        info->op2.type = fex_ldouble;
        info->op2.val.q = fpreg(uap, 1);
        info->res.type = fex_ldouble;
        info->res.val.q = fprem1(info->op1.val.q, info->op2.val.q);
        goto done;

    case 0x1f8: /* fprem */
        info->op2.type = fex_ldouble;
        info->op2.val.q = fpreg(uap, 1);
        info->res.type = fex_ldouble;
        info->res.val.q = fprem(info->op1.val.q, info->op2.val.q);
        goto done;

    case 0x1f9: /* fyl2xp1 */
        info->op2.type = fex_ldouble;
        info->op2.val.q = fpreg(uap, 1);
        info->res.type = fex_ldouble;
        info->res.val.q = fyl2xp1(info->op1.val.q, info->op2.val.q);
        goto done;

    case 0x1fa: /* fsqrt */
        info->op = fex_sqrt;
        info->res.type = fex_ldouble;
        info->res.val.q = fsqrt(info->op1.val.q);
        goto done;

    case 0x1fb: /* fsincos */
        info->res.type = fex_ldouble;
        info->res.val.q = fsincos(info->op1.val.q);
        goto done;

    case 0x1fc: /* frndint */
        info->res.type = fex_ldouble;
        info->res.val.q = frndint(info->op1.val.q);
        goto done;

    case 0x1fd: /* fscale */
        info->op2.type = fex_ldouble;
        info->op2.val.q = fpreg(uap, 1);
        info->res.type = fex_ldouble;
        info->res.val.q = fscale(info->op1.val.q, info->op2.val.q);
        goto done;

    case 0x1fe: /* fsin */
        info->res.type = fex_ldouble;
        info->res.val.q = fsin(info->op1.val.q);
        goto done;

    case 0x1ff: /* fcos */
        info->res.type = fex_ldouble;
        info->res.val.q = fcos(info->op1.val.q);
        goto done;

    case 0x2e9: /* fucompp */
        info->op = fex_cmp;
        info->op2.type = fex_ldouble;
        info->op2.val.q = fpreg(uap, 1);
        info->res.type = fex_nodata;
        c = (info->op1.val.q == info->op2.val.q);
        goto done;
    }

    /* fucom[p], fcomi[p], fucomi[p] */
    switch (op & 0x7f8) {
    case 0x3e8:
    case 0x5e0:
    case 0x5e8:
    case 0x7e8: /* unordered compares */
        info->op = fex_cmp;
        info->op2.type = fex_ldouble;
        info->op2.val.q = fpreg(uap, op & 7);
        info->res.type = fex_nodata;
        c = (info->op1.val.q == info->op2.val.q);
        goto done;

    case 0x3f0:
    case 0x7f0: /* ordered compares */
        info->op = fex_cmp;
        info->op2.type = fex_ldouble;
        info->op2.val.q = fpreg(uap, op & 7);
        info->res.type = fex_nodata;
        c = (info->op1.val.q < info->op2.val.q);
        goto done;
    }

    /* all other instructions come in groups of the form
       fadd, fmul, fcom, fcomp, fsub, fsubr, fdiv, fdivr */

    /* get the second operand */
    switch (op & 0x7c0) {
    case 0x000:
    case 0x040:
    case 0x080:
        if (!ea) {
            info->op = fex_other;
            info->op1.type = info->op2.type = info->res.type = fex_nodata;
            info->flags = 0;
            return;
        }
        info->op2.type = fex_float;
        info->op2.val.f = *(float *)ea;
        op2v = (long double) info->op2.val.f;
        break;

    case 0x0c0:
        info->op2.type = fex_ldouble;
        op2v = info->op2.val.q = fpreg(uap, op & 7);
        break;

    case 0x200:
    case 0x240:
    case 0x280:
        if (!ea) {
            info->op = fex_other;
            info->op1.type = info->op2.type = info->res.type = fex_nodata;
            info->flags = 0;
            return;
        }
        info->op2.type = fex_int;
        info->op2.val.i = *(int *)ea;
        op2v = (long double) info->op2.val.i;
        break;

    case 0x400:
    case 0x440:
    case 0x480:
        if (!ea) {
            info->op = fex_other;
            info->op1.type = info->op2.type = info->res.type = fex_nodata;
            info->flags = 0;
            return;
        }
        info->op2.type = fex_double;
        info->op2.val.d = *(double *)ea;
        op2v = (long double) info->op2.val.d;
        break;

    case 0x4c0:
    case 0x6c0:
        info->op2.type = fex_ldouble;
        info->op2.val.q = fpreg(uap, op & 7);
        t = info->op1;
        info->op1 = info->op2;
        info->op2 = t;
        op2v = info->op2.val.q;
        break;

    case 0x600:
    case 0x640:
    case 0x680:
        if (!ea) {
            info->op = fex_other;
            info->op1.type = info->op2.type = info->res.type = fex_nodata;
            info->flags = 0;
            return;
        }
        info->op2.type = fex_int;
        info->op2.val.i = *(short *)ea;
        op2v = (long double) info->op2.val.i;
        break;

    default:
        info->op = fex_other;
        info->op1.type = info->op2.type = info->res.type = fex_nodata;
        info->flags = 0;
        return;
    }

    /* distinguish different operations in the group */
    info->res.type = fex_ldouble;
    switch (op & 0x38) {
    case 0x00:
        info->op = fex_add;
        info->res.val.q = info->op1.val.q + op2v;
        break;

    case 0x08:
        info->op = fex_mul;
        info->res.val.q = info->op1.val.q * op2v;
        break;

    case 0x10:
    case 0x18:
        info->op = fex_cmp;
        info->res.type = fex_nodata;
        c = (info->op1.val.q < op2v);
        break;

    case 0x20:
        info->op = fex_sub;
        info->res.val.q = info->op1.val.q - op2v;
        break;

    case 0x28:
        info->op = fex_sub;
        info->res.val.q = op2v - info->op1.val.q;
        t = info->op1;
        info->op1 = info->op2;
        info->op2 = t;
        break;

    case 0x30:
        info->op = fex_div;
        info->res.val.q = info->op1.val.q / op2v;
        break;

    case 0x38:
        info->op = fex_div;
        info->res.val.q = op2v / info->op1.val.q;
        t = info->op1;
        info->op1 = info->op2;
        info->op2 = t;
        break;

    default:
        info->op = fex_other;
        info->op1.type = info->op2.type = info->res.type = fex_nodata;
        info->flags = 0;
        return;
    }

done:
    __fenv_getcwsw(&cwsw);
    info->flags = cwsw & FE_ALL_EXCEPT;
    cwsw &= ~FE_ALL_EXCEPT;
    __fenv_setcwsw(&cwsw);
}

/* pop the saved stack */
static void pop(ucontext_t *uap)
{
    unsigned top;

    fpreg(uap, 0) = fpreg(uap, 1);
    fpreg(uap, 1) = fpreg(uap, 2);
    fpreg(uap, 2) = fpreg(uap, 3);
    fpreg(uap, 3) = fpreg(uap, 4);
    fpreg(uap, 4) = fpreg(uap, 5);
    fpreg(uap, 5) = fpreg(uap, 6);
    fpreg(uap, 6) = fpreg(uap, 7);
#if defined(__amd64)
    top = (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw >> 10)
        & 0xe;
    uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.fctw |= (3 << top);
    top = (top + 2) & 0xe;
    uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw =
        (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw & ~0x3800)
        | (top << 10);
#else
    top = (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] >> 10)
        & 0xe;
    uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[TW] |= (3 << top);
    top = (top + 2) & 0xe;
    uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] =
        (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] & ~0x3800)
        | (top << 10);
#endif
}

/* push x onto the saved stack */
static void push(long double x, ucontext_t *uap)
{
    unsigned top;

    fpreg(uap, 7) = fpreg(uap, 6);
    fpreg(uap, 6) = fpreg(uap, 5);
    fpreg(uap, 5) = fpreg(uap, 4);
    fpreg(uap, 4) = fpreg(uap, 3);
    fpreg(uap, 3) = fpreg(uap, 2);
    fpreg(uap, 2) = fpreg(uap, 1);
    fpreg(uap, 1) = fpreg(uap, 0);
    fpreg(uap, 0) = x;
#if defined(__amd64)
    top = (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw >> 10)
        & 0xe;
    top = (top - 2) & 0xe;
    uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.fctw &= ~(3 << top);
    uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw =
        (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw & ~0x3800)
        | (top << 10);
#else
    top = (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] >> 10)
        & 0xe;
    top = (top - 2) & 0xe;
    uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[TW] &= ~(3 << top);
    uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] =
        (uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] & ~0x3800)
        | (top << 10);
#endif
}

/* scale factors for exponent wrapping */
static const float
    fun = 7.922816251e+28f, /* 2^96 */
    fov = 1.262177448e-29f; /* 2^-96 */
static const double
    dun = 1.552518092300708935e+231,    /* 2^768 */
    dov = 6.441148769597133308e-232;    /* 2^-768 */

/*
*  Store the specified result; if no result is given but the exception
*  is underflow or overflow, use the default trapped result
*/
void
__fex_st_result(siginfo_t *sip, ucontext_t *uap, fex_info_t *info)
{
    fex_numeric_t   r;
    unsigned long       ex, op, ea, stack;

    /* get the exception type, opcode, and data address */
    ex = sip->si_code;
#if defined(__amd64)
    op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.fop >> 16;
    ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.rdp; /*???*/
#else
    op = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[OP] >> 16;
    ea = uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[EA];
#endif

    /* if the instruction is a compare, set the condition codes
       to unordered and update the stack */
    switch (op & 0x7f8) {
    case 0x010:
    case 0x050:
    case 0x090:
    case 0x0d0:
    case 0x210:
    case 0x250:
    case 0x290:
    case 0x410:
    case 0x450:
    case 0x490:
    case 0x4d0:
    case 0x5e0:
    case 0x610:
    case 0x650:
    case 0x690:
        /* f[u]com */
#if defined(__amd64)
        uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw |= 0x4500;
#else
        uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] |= 0x4500;
#endif
        return;

    case 0x018:
    case 0x058:
    case 0x098:
    case 0x0d8:
    case 0x218:
    case 0x258:
    case 0x298:
    case 0x418:
    case 0x458:
    case 0x498:
    case 0x4d8:
    case 0x5e8:
    case 0x618:
    case 0x658:
    case 0x698:
    case 0x6d0:
        /* f[u]comp */
#if defined(__amd64)
        uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw |= 0x4500;
#else
        uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] |= 0x4500;
#endif
        pop(uap);
        return;

    case 0x2e8:
    case 0x6d8:
        /* f[u]compp */
#if defined(__amd64)
        uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw |= 0x4500;
#else
        uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] |= 0x4500;
#endif
        pop(uap);
        pop(uap);
        return;

    case 0x1e0:
        if (op == 0x1e4) { /* ftst */
#if defined(__amd64)
            uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.sw |= 0x4500;
#else
            uap->uc_mcontext.fpregs.fp_reg_set.fpchip_state.state[SW] |= 0x4500;
#endif
            return;
        }
        break;

    case 0x3e8:
    case 0x3f0:
        /* f[u]comi */
#if defined(__amd64)
        uap->uc_mcontext.gregs[REG_PS] |= 0x45;
#else
        uap->uc_mcontext.gregs[EFL] |= 0x45;
#endif
        return;

    case 0x7e8:
    case 0x7f0:
        /* f[u]comip */
#if defined(__amd64)
        uap->uc_mcontext.gregs[REG_PS] |= 0x45;
#else
        uap->uc_mcontext.gregs[EFL] |= 0x45;
#endif
        pop(uap);
        return;
    }

    /* if there is no result available and the exception is overflow
       or underflow, use the wrapped result */
    r = info->res;
    if (r.type == fex_nodata) {
        if (ex == FPE_FLTOVF || ex == FPE_FLTUND) {
            /* for store instructions, do the scaling and store */
            switch (op & 0x7f8) {
            case 0x110:
            case 0x118:
            case 0x150:
            case 0x158:
            case 0x190:
            case 0x198:
                if (!ea)
                    return;
                if (ex == FPE_FLTOVF)
                    *(float *)ea = (fpreg(uap, 0) * fov) * fov;
                else
                    *(float *)ea = (fpreg(uap, 0) * fun) * fun;
                if ((op & 8) != 0)
                    pop(uap);
                break;

            case 0x510:
            case 0x518:
            case 0x550:
            case 0x558:
            case 0x590:
            case 0x598:
                if (!ea)
                    return;
                if (ex == FPE_FLTOVF)
                    *(double *)ea = (fpreg(uap, 0) * dov) * dov;
                else
                    *(double *)ea = (fpreg(uap, 0) * dun) * dun;
                if ((op & 8) != 0)
                    pop(uap);
                break;
            }
        }
#ifdef DEBUG
        else if (ex != FPE_FLTRES)
            printf("No result supplied, stack may be hosed\n");
#endif
        return;
    }

    /* otherwise convert the supplied result to the correct type,
       put it in the destination, and update the stack as need be */

    /* store instructions */
    switch (op & 0x7f8) {
    case 0x110:
    case 0x118:
    case 0x150:
    case 0x158:
    case 0x190:
    case 0x198:
        if (!ea)
            return;
        switch (r.type) {
        case fex_int:
            *(float *)ea = (float) r.val.i;
            break;

        case fex_llong:
            *(float *)ea = (float) r.val.l;
            break;

        case fex_float:
            *(float *)ea = r.val.f;
            break;

        case fex_double:
            *(float *)ea = (float) r.val.d;
            break;

        case fex_ldouble:
            *(float *)ea = (float) r.val.q;
            break;

        default:
            break;
        }
        if (ex != FPE_FLTRES && (op & 8) != 0)
            pop(uap);
        return;

    case 0x310:
    case 0x318:
    case 0x350:
    case 0x358:
    case 0x390:
    case 0x398:
        if (!ea)
            return;
        switch (r.type) {
        case fex_int:
            *(int *)ea = r.val.i;
            break;

        case fex_llong:
            *(int *)ea = (int) r.val.l;
            break;

        case fex_float:
            *(int *)ea = (int) r.val.f;
            break;

        case fex_double:
            *(int *)ea = (int) r.val.d;
            break;

        case fex_ldouble:
            *(int *)ea = (int) r.val.q;
            break;

        default:
            break;
        }
        if (ex != FPE_FLTRES && (op & 8) != 0)
            pop(uap);
        return;

    case 0x510:
    case 0x518:
    case 0x550:
    case 0x558:
    case 0x590:
    case 0x598:
        if (!ea)
            return;
        switch (r.type) {
        case fex_int:
            *(double *)ea = (double) r.val.i;
            break;

        case fex_llong:
            *(double *)ea = (double) r.val.l;
            break;

        case fex_float:
            *(double *)ea = (double) r.val.f;
            break;

        case fex_double:
            *(double *)ea = r.val.d;
            break;

        case fex_ldouble:
            *(double *)ea = (double) r.val.q;
            break;

        default:
            break;
        }
        if (ex != FPE_FLTRES && (op & 8) != 0)
            pop(uap);
        return;

    case 0x710:
    case 0x718:
    case 0x750:
    case 0x758:
    case 0x790:
    case 0x798:
        if (!ea)
            return;
        switch (r.type) {
        case fex_int:
            *(short *)ea = (short) r.val.i;
            break;

        case fex_llong:
            *(short *)ea = (short) r.val.l;
            break;

        case fex_float:
            *(short *)ea = (short) r.val.f;
            break;

        case fex_double:
            *(short *)ea = (short) r.val.d;
            break;

        case fex_ldouble:
            *(short *)ea = (short) r.val.q;
            break;

        default:
            break;
        }
        if (ex != FPE_FLTRES && (op & 8) != 0)
            pop(uap);
        return;

    case 0x730:
    case 0x770:
    case 0x7b0:
        /* fbstp; don't bother */
        if (ea && ex != FPE_FLTRES)
            pop(uap);
        return;

    case 0x738:
    case 0x778:
    case 0x7b8:
        if (!ea)
            return;
        switch (r.type) {
        case fex_int:
            *(long long *)ea = (long long) r.val.i;
            break;

        case fex_llong:
            *(long long *)ea = r.val.l;
            break;

        case fex_float:
            *(long long *)ea = (long long) r.val.f;
            break;

        case fex_double:
            *(long long *)ea = (long long) r.val.d;
            break;

        case fex_ldouble:
            *(long long *)ea = (long long) r.val.q;
            break;

        default:
            break;
        }
        if (ex != FPE_FLTRES)
            pop(uap);
        return;
    }

    /* for all other instructions, the result goes into a register */
    switch (r.type) {
    case fex_int:
        r.val.q = (long double) r.val.i;
        break;

    case fex_llong:
        r.val.q = (long double) r.val.l;
        break;

    case fex_float:
        r.val.q = (long double) r.val.f;
        break;

    case fex_double:
        r.val.q = (long double) r.val.d;
        break;

    default:
        break;
    }

    /* for load instructions, push the result onto the stack */
    switch (op & 0x7f8) {
    case 0x100:
    case 0x140:
    case 0x180:
    case 0x500:
    case 0x540:
    case 0x580:
        if (ea)
            push(r.val.q, uap);
        return;
    }

    /* for all other instructions, if the exception is overflow,
       underflow, or inexact, the stack has already been updated */
    stack = (ex == FPE_FLTOVF || ex == FPE_FLTUND || ex == FPE_FLTRES);
    switch (op & 0x7f8) {
    case 0x1f0: /* oddballs */
        switch (op) {
        case 0x1f1: /* fyl2x */
        case 0x1f3: /* fpatan */
        case 0x1f9: /* fyl2xp1 */
            /* pop the stack, leaving the result in st */
            if (!stack)
                pop(uap);
            fpreg(uap, 0) = r.val.q;
            return;

        case 0x1f2: /* fpatan */
            /* fptan pushes 1.0 afterward */
            if (stack)
                fpreg(uap, 1) = r.val.q;
            else {
                fpreg(uap, 0) = r.val.q;
                push(1.0L, uap);
            }
            return;

        case 0x1f4: /* fxtract */
        case 0x1fb: /* fsincos */
            /* leave the supplied result in st */
            if (stack)
                fpreg(uap, 0) = r.val.q;
            else {
                fpreg(uap, 0) = 0.0; /* punt */
                push(r.val.q, uap);
            }
            return;
        }

        /* all others leave the stack alone and the result in st */
        fpreg(uap, 0) = r.val.q;
        return;

    case 0x4c0:
    case 0x4c8:
    case 0x4e0:
    case 0x4e8:
    case 0x4f0:
    case 0x4f8:
        fpreg(uap, op & 7) = r.val.q;
        return;

    case 0x6c0:
    case 0x6c8:
    case 0x6e0:
    case 0x6e8:
    case 0x6f0:
    case 0x6f8:
        /* stack is popped afterward */
        if (stack)
            fpreg(uap, (op - 1) & 7) = r.val.q;
        else {
            fpreg(uap, op & 7) = r.val.q;
            pop(uap);
        }
        return;

    default:
        fpreg(uap, 0) = r.val.q;
        return;
    }
}