/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 1988,1995-1996,2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/* Pack procedures for Sparc FPU simulator. */

#include <sys/fpu/fpu_simulator.h>
#include <sys/fpu/globals.h>

/*
 * Returns 1 if overflow should go to infinity, 0 if to max finite.
 */
static int
overflow_to_infinity(
        fp_simd_type    *pfpsd,         /* Pointer to simulator data */
        int             sign)           /* negative or positive */
{
        int             inf;

        switch (pfpsd->fp_direction) {
        case fp_nearest:
                inf = 1;
                break;
        case fp_tozero:
                inf = 0;
                break;
        case fp_positive:
                inf = !sign;
                break;
        case fp_negative:
                inf = sign;
                break;
        }
        return (inf);
}

/*
 * Round according to current rounding mode.
 */
static void
round(
        fp_simd_type    *pfpsd,         /* Pointer to simulator data */
        unpacked        *pu)            /* unpacked result */
{
        int             increment;      /* boolean to indicate round up */
        int             sr;

        sr = pu->sticky|pu->rounded;

        if (sr == 0)
                return;
        fpu_set_exception(pfpsd, fp_inexact);
        switch (pfpsd->fp_direction) {
        case fp_nearest:
                increment = pu->rounded;
                break;
        case fp_tozero:
                increment = 0;
                break;
        case fp_positive:
                increment = (pu->sign == 0) & (sr != 0);
                break;
        case fp_negative:
                increment = (pu->sign != 0) & (sr != 0);
                break;
        }
        if (increment) {
            pu->significand[3]++;
            if (pu->significand[3] == 0) {
                pu->significand[2]++;
                if (pu->significand[2] == 0) {
                    pu->significand[1]++;
                    if (pu->significand[1] == 0) {
                        pu->significand[0]++;   /* rounding carried out */
                        if (pu->significand[0] == 0x20000) {
                            pu->exponent++;
                            pu->significand[0] = 0x10000;
                        }
                    }
                }
            }
        }
        if ((pfpsd->fp_direction == fp_nearest) &&
            (pu->sticky == 0) && increment != 0) {      /* ambiguous case */
                pu->significand[3] &= 0xfffffffe; /* force round to even */
        }
}

static void
packint32(
        fp_simd_type    *pfpsd, /* Pointer to simulator data */
        unpacked        *pu,    /* unpacked result */
        int32_t         *px)    /* packed int32_t */
{
        switch (pu->fpclass) {
        case fp_zero:
                *px = 0;
                break;
        case fp_normal:
                if (pu->exponent >= 32)
                        goto overflow;
                fpu_rightshift(pu, 112 - pu->exponent);
                round(pfpsd, pu);
                if (pu->significand[3] >= 0x80000000)
                        if ((pu->sign == 0)||(pu->significand[3] > 0x80000000))
                                goto overflow;
                *px = pu->significand[3];
                if (pu->sign)
                        *px = -*px;
                break;
        case fp_infinity:
        case fp_quiet:
        case fp_signaling:
overflow:
                if (pu->sign)
                        *px = 0x80000000;
                else
                        *px = 0x7fffffff;
                pfpsd->fp_current_exceptions &= ~(1 << (int)fp_inexact);
                fpu_set_exception(pfpsd, fp_invalid);
                break;
        }
}

static void
packint64(
        fp_simd_type    *pfpsd, /* Pointer to simulator data */
        unpacked        *pu,    /* unpacked result */
        int64_t         *px)    /* packed int64_t */
{
        union {
                uint64_t ll;
                uint32_t i[2];
        } x;

        switch (pu->fpclass) {
        case fp_zero:
                *px = 0;
                break;
        case fp_normal:
                if (pu->exponent >= 64)
                        goto overflow;
                fpu_rightshift(pu, 112 - pu->exponent);
                round(pfpsd, pu);
                if (pu->significand[2] >= 0x80000000)
                        if ((pu->sign == 0) ||
                            (pu->significand[2] > 0x80000000) ||
                            (((pu->significand[2] == 0x80000000) &&
                                (pu->significand[3] > 0))))
                                goto overflow;
                x.i[0] = pu->significand[2];
                x.i[1] = pu->significand[3];
                *px = x.ll;
                if (pu->sign)
                        *px = -*px;
                break;
        case fp_infinity:
        case fp_quiet:
        case fp_signaling:
overflow:
                if (pu->sign)
                        *px = (int64_t)0x8000000000000000;
                else
                        *px = (int64_t)0x7fffffffffffffff;
                pfpsd->fp_current_exceptions &= ~(1 << (int)fp_inexact);
                fpu_set_exception(pfpsd, fp_invalid);
                break;
        }
}

static void
packsingle(
        fp_simd_type    *pfpsd, /* Pointer to simulator data */
        unpacked        *pu,    /* unpacked result */
        single_type     *px)    /* packed single */
{
        px->sign = pu->sign;
        switch (pu->fpclass) {
        case fp_zero:
                px->exponent = 0;
                px->significand = 0;
                break;
        case fp_infinity:
infinity:
                px->exponent = 0xff;
                px->significand = 0;
                break;
        case fp_quiet:
        case fp_signaling:
                fpu_rightshift(pu, 113-24);
                px->exponent = 0xff;
                px->significand = 0x400000|(0x3fffff&pu->significand[3]);
                break;
        case fp_normal:
                fpu_rightshift(pu, 113-24);
                pu->exponent += SINGLE_BIAS;
                if (pu->exponent <= 0) {
                        px->exponent = 0;
                        fpu_rightshift(pu, 1 - pu->exponent);
                        round(pfpsd, pu);
                        if (pu->significand[3] == 0x800000) {
                                                                /*
                                                                 * rounded
                                                                 * back up to
                                                                 * normal
                                                                 */
                                px->exponent = 1;
                                px->significand = 0;
                                fpu_set_exception(pfpsd, fp_inexact);
                        } else
                                px->significand = 0x7fffff & pu->significand[3];

                        if (pfpsd->fp_current_exceptions & (1 << fp_inexact))
                                fpu_set_exception(pfpsd, fp_underflow);
                        if (pfpsd->fp_fsrtem & (1<<fp_underflow)) {
                                fpu_set_exception(pfpsd, fp_underflow);
                                pfpsd->fp_current_exceptions &=
                                                ~(1 << (int)fp_inexact);
                        }
                        return;
                }
                round(pfpsd, pu);
                if (pu->significand[3] == 0x1000000) {  /* rounding overflow */
                        pu->significand[3] = 0x800000;
                        pu->exponent += 1;
                }
                if (pu->exponent >= 0xff) {
                        fpu_set_exception(pfpsd, fp_overflow);
                        fpu_set_exception(pfpsd, fp_inexact);
                        if (pfpsd->fp_fsrtem & (1<<fp_overflow)) {
                                pfpsd->fp_current_exceptions &=
                                                ~(1 << (int)fp_inexact);
                        }
                        if (overflow_to_infinity(pfpsd, pu->sign))
                                goto infinity;
                        px->exponent = 0xfe;
                        px->significand = 0x7fffff;
                        return;
                }
                px->exponent = pu->exponent;
                px->significand = 0x7fffff & pu->significand[3];
        }
}

static void
packdouble(
        fp_simd_type    *pfpsd, /* Pointer to simulator data */
        unpacked        *pu,    /* unpacked result */
        double_type     *px,    /* packed double, sign/exponent/upper 20 bits */
        uint_t          *py)    /* and the lower 32 bits of the significand */
{
        px->sign = pu->sign;
        switch (pu->fpclass) {
        case fp_zero:
                px->exponent = 0;
                px->significand = 0;
                *py = 0;
                break;
        case fp_infinity:
infinity:
                px->exponent = 0x7ff;
                px->significand = 0;
                *py = 0;
                break;
        case fp_quiet:
        case fp_signaling:
                fpu_rightshift(pu, 113-53);
                px->exponent = 0x7ff;
                px->significand = 0x80000 | (0x7ffff & pu->significand[2]);
                *py = pu->significand[3];
                break;
        case fp_normal:
                fpu_rightshift(pu, 113-53);
                pu->exponent += DOUBLE_BIAS;
                if (pu->exponent <= 0) {        /* underflow */
                        px->exponent = 0;
                        fpu_rightshift(pu, 1 - pu->exponent);
                        round(pfpsd, pu);
                        if (pu->significand[2] == 0x100000) {
                                                                /*
                                                                 * rounded
                                                                 * back up to
                                                                 * normal
                                                                 */
                                px->exponent = 1;
                                px->significand = 0;
                                *py = 0;
                                fpu_set_exception(pfpsd, fp_inexact);
                        } else {
                                px->exponent = 0;
                                px->significand = 0xfffff & pu->significand[2];
                                *py = pu->significand[3];
                        }
                        if (pfpsd->fp_current_exceptions & (1 << fp_inexact))
                                fpu_set_exception(pfpsd, fp_underflow);
                        if (pfpsd->fp_fsrtem & (1<<fp_underflow)) {
                                fpu_set_exception(pfpsd, fp_underflow);
                                pfpsd->fp_current_exceptions &=
                                                ~(1 << (int)fp_inexact);
                        }
                        return;
                }
                round(pfpsd, pu);
                if (pu->significand[2] == 0x200000) {   /* rounding overflow */
                        pu->significand[2] = 0x100000;
                        pu->exponent += 1;
                }
                if (pu->exponent >= 0x7ff) {    /* overflow */
                        fpu_set_exception(pfpsd, fp_overflow);
                        fpu_set_exception(pfpsd, fp_inexact);
                        if (pfpsd->fp_fsrtem & (1<<fp_overflow)) {
                                pfpsd->fp_current_exceptions &=
                                                ~(1 << (int)fp_inexact);
                        }
                        if (overflow_to_infinity(pfpsd, pu->sign))
                                goto infinity;
                        px->exponent = 0x7fe;
                        px->significand = 0xfffff;
                        *py = 0xffffffffU;
                        return;
                }
                px->exponent = pu->exponent;
                px->significand = 0xfffff & pu->significand[2];
                *py = pu->significand[3];
                break;
        }
}

static void
packextended(
        fp_simd_type    *pfpsd, /* Pointer to simulator data */
        unpacked        *pu,    /* unpacked result */
        extended_type   *px,    /* packed extended, sign/exponent/16 bits */
        uint_t          *py,    /* 2nd word of extended significand */
        uint_t          *pz,    /* 3rd word of extended significand */
        uint_t          *pw)    /* 4th word of extended significand */
{
        px->sign = pu->sign;
        switch (pu->fpclass) {
        case fp_zero:
                px->exponent = 0;
                px->significand = 0;
                *pz = 0;
                *py = 0;
                *pw = 0;
                break;
        case fp_infinity:
infinity:
                px->exponent = 0x7fff;
                px->significand = 0;
                *pz = 0;
                *py = 0;
                *pw = 0;
                break;
        case fp_quiet:
        case fp_signaling:
                px->exponent = 0x7fff;
                px->significand = 0x8000 | pu->significand[0];
                                                                /*
                                                                 * Insure quiet
                                                                 * nan.
                                                                 */
                *py = pu->significand[1];
                *pz = pu->significand[2];
                *pw = pu->significand[3];
                break;
        case fp_normal:
                pu->exponent += EXTENDED_BIAS;
                if (pu->exponent <= 0) {        /* underflow */
                        fpu_rightshift(pu, 1-pu->exponent);
                        round(pfpsd, pu);
                        if (pu->significand[0] < 0x00010000) {
                                                                /*
                                                                 * not rounded
                                                                 * back up
                                                                 * to normal
                                                                 */
                                px->exponent = 0;
                        } else {
                                px->exponent = 1;
                                fpu_set_exception(pfpsd, fp_inexact);
                        }
                        if (pfpsd->fp_current_exceptions & (1 << fp_inexact))
                                fpu_set_exception(pfpsd, fp_underflow);
                        if (pfpsd->fp_fsrtem & (1<<fp_underflow)) {
                                fpu_set_exception(pfpsd, fp_underflow);
                                pfpsd->fp_current_exceptions &=
                                                ~(1 << (int)fp_inexact);
                        }
                        px->significand = pu->significand[0];
                        *py = pu->significand[1];
                        *pz = pu->significand[2];
                        *pw = pu->significand[3];
                        return;
                }
                round(pfpsd, pu); /* rounding overflow handled in round() */
                if (pu->exponent >= 0x7fff) {   /* overflow */
                        fpu_set_exception(pfpsd, fp_overflow);
                        fpu_set_exception(pfpsd, fp_inexact);
                        if (pfpsd->fp_fsrtem & (1<<fp_overflow)) {
                                pfpsd->fp_current_exceptions &=
                                                ~(1 << (int)fp_inexact);
                        }
                        if (overflow_to_infinity(pfpsd, pu->sign))
                                goto infinity;
                        px->exponent = 0x7ffe;  /* overflow to max norm */
                        px->significand = 0xffff;
                        *py = 0xffffffffU;
                        *pz = 0xffffffffU;
                        *pw = 0xffffffffU;
                        return;
                }
                px->exponent = pu->exponent;
                px->significand = pu->significand[0];
                *py = pu->significand[1];
                *pz = pu->significand[2];
                *pw = pu->significand[3];
                break;
        }
}

void
_fp_pack(
        fp_simd_type    *pfpsd, /* Pointer to simulator data */
        unpacked        *pu,    /* unpacked operand */
        uint_t          n,      /* register where datum starts */
        enum fp_op_type type)   /* type of datum */

{
        switch (type) {
        case fp_op_int32:
                {
                        int32_t         x;

                        packint32(pfpsd, pu, &x);
                        if (!(pfpsd->fp_current_exceptions & pfpsd->fp_fsrtem))
                                pfpsd->fp_current_write_freg(&x, n, pfpsd);
                        break;
                }
        case fp_op_int64:
                {
                        int64_t         x;

                        packint64(pfpsd, pu, &x);
                        if ((n & 0x1) == 1)     /* fix register encoding */
                                n = (n & 0x1e) | 0x20;
                        if (!(pfpsd->fp_current_exceptions & pfpsd->fp_fsrtem))
                            pfpsd->fp_current_write_dreg(&x, DOUBLE(n), pfpsd);
                        break;
                }
        case fp_op_single:
                {
                        single_type     x;

                        packsingle(pfpsd, pu, &x);
                        if (!(pfpsd->fp_current_exceptions & pfpsd->fp_fsrtem))
                                pfpsd->fp_current_write_freg(&x, n, pfpsd);
                        break;
                }
        case fp_op_double:
                {
                        union {
                                double_type     x[2];
                                uint32_t        y[2];
                                uint64_t        ll;
                        } db;

                        packdouble(pfpsd, pu, &db.x[0], &db.y[1]);
                        if (!(pfpsd->fp_current_exceptions &
                            pfpsd->fp_fsrtem)) {
                                if ((n & 0x1) == 1) /* fix register encoding */
                                        n = (n & 0x1e) | 0x20;
                                pfpsd->fp_current_write_dreg(&db.ll, DOUBLE(n),
                                        pfpsd);
                        }
                        break;
                }
        case fp_op_extended:
                {
                        union {
                                extended_type   x;
                                uint32_t        y[4];
                                uint64_t        ll[2];
                        } ex;
                        unpacked        U;
                        int             k;
                        switch (pfpsd->fp_precision) {
                                                        /*
                                                         * Implement extended
                                                         * rounding precision
                                                         * mode.
                                                         */
                        case fp_single:
                                {
                                        single_type     tx;

                                        packsingle(pfpsd, pu, &tx);
                                        pu = &U;
                                        unpacksingle(pfpsd, pu, tx);
                                        break;
                                }
                        case fp_double:
                                {
                                        double_type     tx;
                                        uint_t          ty;

                                        packdouble(pfpsd, pu, &tx, &ty);
                                        pu = &U;
                                        unpackdouble(pfpsd, pu, tx, ty);
                                        break;
                                }
                        case fp_precision_3:    /* rounded to 64 bits */
                                {
                                        k = pu->exponent + EXTENDED_BIAS;
                                        if (k >= 0) k = 113-64;
                                        else    k = 113-64-k;
                                        fpu_rightshift(pu, 113-64);
                                        round(pfpsd, pu);
                                        pu->sticky = pu->rounded = 0;
                                        pu->exponent += k;
                                        fpu_normalize(pu);
                                        break;
                                }
                        }
                        packextended(pfpsd, pu, &ex.x, &ex.y[1],
                                                &ex.y[2], &ex.y[3]);
                        if (!(pfpsd->fp_current_exceptions &
                            pfpsd->fp_fsrtem)) {
                                if ((n & 0x1) == 1) /* fix register encoding */
                                        n = (n & 0x1e) | 0x20;
                                pfpsd->fp_current_write_dreg(&ex.ll[0],
                                                        QUAD_E(n), pfpsd);
                                pfpsd->fp_current_write_dreg(&ex.ll[1],
                                                        QUAD_F(n), pfpsd);
                        }

                        break;
                }
        }
}

void
_fp_pack_word(
        fp_simd_type    *pfpsd, /* Pointer to simulator data */
        uint32_t        *pu,    /* unpacked operand */
        uint_t          n)      /* register where datum starts */
{
        pfpsd->fp_current_write_freg(pu, n, pfpsd);
}

void
_fp_pack_extword(
        fp_simd_type    *pfpsd, /* Pointer to simulator data */
        uint64_t        *pu,    /* unpacked operand */
        uint_t          n)      /* register where datum starts */
{
        if ((n & 1) == 1)       /* fix register encoding */
                n = (n & 0x1e) | 0x20;
        pfpsd->fp_current_write_dreg(pu, DOUBLE(n), pfpsd);
}