_Qfpack.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* 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
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Copyright (c) 1988 by Sun Microsystems, Inc.
*/
/* Pack procedures for Sparc FPU simulator. */
#include "_Qquad.h"
#include "_Qglobals.h"
PRIVATE int
overflow_to_infinity(sign)
int sign;
/* Returns 1 if overflow should go to infinity, 0 if to max finite. */
{
int inf;
switch (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);
}
PRIVATE void
round(pu)
unpacked *pu;
/* Round according to current rounding mode. */
{
int increment; /* boolean to indicate round up */
int sr;
sr = pu->sticky|pu->rounded;
if (sr == 0)
return;
fpu_set_exception(fp_inexact);
switch (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 ((fp_direction == fp_nearest) &&
(pu->sticky == 0) && increment!=0) { /* ambiguous case */
pu->significand[3] &= 0xfffffffe; /* force round to even */
}
}
PRIVATE void
packinteger(pu, px)
unpacked *pu; /* unpacked result */
int *px; /* packed integer */
{
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(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;
_fp_current_exceptions &= ~(1 << (int) fp_inexact);
fpu_set_exception(fp_invalid);
break;
}
}
PRIVATE void
packsingle(pu, px)
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(pu);
if (pu->significand[3] == 0x800000) { /* rounded
* back up to
* normal */
px->exponent = 1;
px->significand = 0;
return;
}
if (_fp_current_exceptions & (1 << fp_inexact))
fpu_set_exception(fp_underflow);
px->significand = 0x7fffff & pu->significand[3];
return;
}
round(pu);
if (pu->significand[3] == 0x1000000) { /* rounding overflow */
pu->significand[3] = 0x800000;
pu->exponent += 1;
}
if (pu->exponent >= 0xff) {
fpu_set_exception(fp_overflow);
fpu_set_exception(fp_inexact);
if (overflow_to_infinity(pu->sign))
goto infinity;
px->exponent = 0xfe;
px->significand = 0x7fffff;
return;
}
px->exponent = pu->exponent;
px->significand = 0x7fffff & pu->significand[3];
}
}
PRIVATE void
packdouble(pu, px, py)
unpacked *pu; /* unpacked result */
double_type *px; /* packed double */
unsigned *py;
{
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(pu);
if (pu->significand[2] == 0x100000) { /* rounded
* back up to
* normal */
px->exponent = 1;
px->significand = 0;
*py = 0;
return;
}
if (_fp_current_exceptions & (1 << fp_inexact))
fpu_set_exception(fp_underflow);
px->exponent = 0;
px->significand = 0xfffff & pu->significand[2];
*py = pu->significand[3];
return;
}
round(pu);
if (pu->significand[2] == 0x200000) { /* rounding overflow */
pu->significand[2] = 0x100000;
pu->exponent += 1;
}
if (pu->exponent >= 0x7ff) { /* overflow */
fpu_set_exception(fp_overflow);
fpu_set_exception(fp_inexact);
if (overflow_to_infinity(pu->sign))
goto infinity;
px->exponent = 0x7fe;
px->significand = 0xfffff;
*py = 0xffffffff;
return;
}
px->exponent = pu->exponent;
px->significand = 0xfffff & pu->significand[2];
*py = pu->significand[3];
break;
}
}
PRIVATE void
packextended(pu, px, py, pz, pw)
unpacked *pu; /* unpacked result */
extended_type *px; /* packed extended */
unsigned *py, *pz, *pw;
{
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(pu);
if (pu->significand[0] < 0x00010000) { /* not rounded
* back up
* to normal */
if (_fp_current_exceptions & (1 << fp_inexact))
fpu_set_exception(fp_underflow);
px->exponent = 0;
} else
px->exponent = 1;
px->significand = pu->significand[0];
*py = pu->significand[1];
*pz = pu->significand[2];
*pw = pu->significand[3];
return;
}
round(pu); /* rounding overflow handled in round() */
if (pu->exponent >= 0x7fff) { /* overflow */
fpu_set_exception(fp_overflow);
fpu_set_exception(fp_inexact);
if (overflow_to_infinity(pu->sign))
goto infinity;
px->exponent = 0x7ffe; /* overflow to max norm */
px->significand = 0xffff;
*py = 0xffffffff;
*pz = 0xffffffff;
*pw = 0xffffffff;
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(pu, n, type)
unpacked *pu; /* unpacked operand */
int *n; /* output result's address */
enum fp_op_type type; /* type of datum */
{
switch (type) {
case fp_op_integer:
{
packinteger(pu, n);
break;
}
case fp_op_single:
{
single_type x;
packsingle(pu, &x);
n[0] = *(int*)&x;
break;
}
case fp_op_double:
{
double_type x;
double t=1.0;
int i0,i1;
if((*(int*)&t)!=0) {i0=0;i1=1;} else {i0=1;i1=0;}
packdouble(pu, &x,&n[i1]);
n[i0] = *(int*)&x;
break;
}
case fp_op_extended:
{
extended_type x;
unsigned y, z, w;
unpacked u;
int k;
switch (fp_precision) { /* Implement extended
* rounding precision mode. */
case fp_single:
{
single_type tx;
packsingle(pu, &tx);
pu = &u;
unpacksingle(pu, tx);
break;
}
case fp_double:
{
double_type tx;
unsigned ty;
packdouble(pu, &tx, &ty);
pu = &u;
unpackdouble(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(pu);
pu->sticky=pu->rounded=0;
pu->exponent += k;
fpu_normalize(pu);
break;
}
}
{
int i0,i1,i2,i3;
double t = 1.0;
if((*(int*)&t)!=0) {i0=0;i1=1;i2=2;i3=3;}
else {i0=3;i1=2;i2=1;i3=0;}
packextended(pu, &x, &n[i1], &n[i2], &n[i3]);
n[i0] = *(int*)&x;
}
break;
}
}
}