/*
* 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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include "lint.h"
#include "base_conversion.h"
/* translation table from hex values to hex chars */
static const char *hexchar = "0123456789abcdef";
/*
* Convert arg to a hexadecimal string.
*
* If arg is finite and nonzero, buf is filled with ndigits hexadecimal
* digits, representing the significand of arg, followed by a null byte
* (so ndigits must be at least 1 and buf must be large enough to hold
* ndigits + 1 characters). If ndigits is large enough, the representa-
* tion is exact; otherwise, the value is rounded according to the pre-
* vailing rounding mode to fit the requested number of digits. Either
* way, the result is normalized so that the first digit is '1'. The
* corresponding base two exponent is passed back in *exp.
*
* If arg is zero, buf is filled with ndigits zeros followed by a null,
* and *exp is set to zero. If arg is infinite or NaN, __infnanstring
* is called to place an appropriate string in buf, and *exp is set to
* zero.
*
* Regardless of the value of arg, its sign bit is stored in *sign.
*/
#if defined(__sparc)
void
__aconvert(double arg, int ndigits, int *exp, int *sign, char *buf)
{
union {
unsigned int i[2];
long long l;
double d;
} a, c;
int ha, i, s;
unsigned int d;
a.d = arg;
*sign = s = a.i[0] >> 31;
ha = a.i[0] & ~0x80000000;
/* check for infinity or nan */
if (ha >= 0x7ff00000) {
*exp = 0;
__infnanstring((ha == 0x7ff00000 && a.i[1] == 0)?
fp_infinity : fp_quiet, ndigits, buf);
return;
}
/* check for subnormal or zero */
if (ha < 0x00100000) {
if ((ha | a.i[1]) == 0) {
*exp = 0;
for (i = 0; i < ndigits; i++)
buf[i] = '0';
buf[ndigits] = '\0';
return;
}
/*
* Normalize. It would be much simpler if we could just
* multiply by a power of two here, but some SPARC imple-
* mentations would flush the subnormal operand to zero
* when nonstandard mode is enabled.
*/
a.i[0] = ha;
a.d = (double)a.l;
if (s)
a.d = -a.d;
ha = a.i[0] & ~0x80000000;
*exp = (ha >> 20) - 0x3ff - 1074;
} else {
*exp = (ha >> 20) - 0x3ff;
}
if (ndigits < 14) {
/*
* Round the significand at the appropriate bit by adding
* and subtracting a power of two. This will also raise
* the inexact exception if anything is rounded off.
*/
c.i[0] = (0x43700000 | (s << 31)) - (ndigits << 22);
c.i[1] = 0;
a.i[0] = (a.i[0] & 0x800fffff) | 0x3ff00000;
a.d = (a.d + c.d) - c.d;
ha = a.i[0] & ~0x80000000;
if (ha >= 0x40000000)
(*exp)++;
}
/* convert to hex digits */
buf[0] = '1';
d = ha << 12;
for (i = 1; i < ndigits && i < 6; i++) {
buf[i] = hexchar[d >> 28];
d <<= 4;
}
d = a.i[1];
for (; i < ndigits && i < 14; i++) {
buf[i] = hexchar[d >> 28];
d <<= 4;
}
for (; i < ndigits; i++)
buf[i] = '0';
buf[ndigits] = '\0';
}
void
__qaconvert(long double *arg, int ndigits, int *exp, int *sign, char *buf)
{
union {
unsigned int i[4];
long double q;
} a;
enum fp_direction_type rd;
int ha, i, s;
unsigned int b, r, d;
a.q = *arg;
*sign = a.i[0] >> 31;
ha = a.i[0] &= ~0x80000000;
/* check for infinity or nan */
if (ha >= 0x7fff0000) {
*exp = 0;
__infnanstring((ha == 0x7fff0000 && (a.i[1] | a.i[2] | a.i[3])
== 0)? fp_infinity : fp_quiet, ndigits, buf);
return;
}
/* check for subnormal or zero */
if (ha < 0x00010000) {
if ((ha | a.i[1] | a.i[2] | a.i[3]) == 0) {
*exp = 0;
for (i = 0; i < ndigits; i++)
buf[i] = '0';
buf[ndigits] = '\0';
return;
}
/* normalize */
i = 0;
while ((a.i[0] | (a.i[1] & 0xffff0000)) == 0) {
a.i[0] = a.i[1];
a.i[1] = a.i[2];
a.i[2] = a.i[3];
a.i[3] = 0;
i += 32;
}
while ((a.i[0] & 0x7fff0000) == 0) {
a.i[0] = (a.i[0] << 1) | (a.i[1] >> 31);
a.i[1] = (a.i[1] << 1) | (a.i[2] >> 31);
a.i[2] = (a.i[2] << 1) | (a.i[3] >> 31);
a.i[3] <<= 1;
i++;
}
*exp = -0x3ffe - i;
} else {
*exp = (ha >> 16) - 0x3fff;
}
if (ndigits < 29) {
/*
* Round the significand at the appropriate bit using
* integer arithmetic. Explicitly raise the inexact
* exception if anything is rounded off.
*/
a.i[0] = (a.i[0] & 0xffff) | 0x10000;
if (ndigits <= 5) {
/*
* i and b are the index and bit position in a.i[]
* of the last bit to be retained. r holds the bits
* to be rounded off, left-adjusted and sticky.
*/
i = 0;
s = (5 - ndigits) << 2;
b = 1 << s;
r = ((a.i[0] << 1) << (31 - s)) | (a.i[1] >> s);
if ((a.i[1] & (b - 1)) | a.i[2] | a.i[3])
r |= 1;
a.i[0] &= ~(b - 1);
a.i[1] = a.i[2] = a.i[3] = 0;
} else if (ndigits <= 13) {
i = 1;
s = (13 - ndigits) << 2;
b = 1 << s;
r = ((a.i[1] << 1) << (31 - s)) | (a.i[2] >> s);
if ((a.i[2] & (b - 1)) | a.i[3])
r |= 1;
a.i[1] &= ~(b - 1);
a.i[2] = a.i[3] = 0;
} else if (ndigits <= 21) {
i = 2;
s = (21 - ndigits) << 2;
b = 1 << s;
r = ((a.i[2] << 1) << (31 - s)) | (a.i[3] >> s);
if (a.i[3] & (b - 1))
r |= 1;
a.i[2] &= ~(b - 1);
a.i[3] = 0;
} else {
i = 3;
s = (29 - ndigits) << 2;
b = 1 << s;
r = (a.i[3] << 1) << (31 - s);
a.i[3] &= ~(b - 1);
}
/* conversion is inexact if r is not zero */
if (r) {
__base_conversion_set_exception(
(fp_exception_field_type)(1 << fp_inexact));
/* massage the rounding direction based on the sign */
rd = _QgetRD();
if (*sign && (rd == fp_positive || rd == fp_negative))
rd = fp_positive + fp_negative - rd;
/* decide whether to round up */
if (rd == fp_positive || (rd == fp_nearest &&
(r > 0x80000000u || (r == 0x80000000u &&
(a.i[i] & b))))) {
a.i[i] += b;
while (a.i[i] == 0)
a.i[--i]++;
if (a.i[0] >= 0x20000)
(*exp)++;
}
}
}
/* convert to hex digits */
buf[0] = '1';
d = a.i[0] << 16;
for (i = 1; i < ndigits && i < 5; i++) {
buf[i] = hexchar[d >> 28];
d <<= 4;
}
d = a.i[1];
for (; i < ndigits && i < 13; i++) {
buf[i] = hexchar[d >> 28];
d <<= 4;
}
d = a.i[2];
for (; i < ndigits && i < 21; i++) {
buf[i] = hexchar[d >> 28];
d <<= 4;
}
d = a.i[3];
for (; i < ndigits && i < 29; i++) {
buf[i] = hexchar[d >> 28];
d <<= 4;
}
for (; i < ndigits; i++)
buf[i] = '0';
buf[ndigits] = '\0';
}
#elif defined(__i386) || defined(__amd64)
/*
* The following code assumes the rounding precision mode is set
* to the default (round to 64 bits).
*/
void
__qaconvert(long double *arg, int ndigits, int *exp, int *sign, char *buf)
{
union {
unsigned int i[3];
long double x;
} a, c;
int ea, i, s;
unsigned int d;
a.x = *arg;
*sign = s = (a.i[2] >> 15) & 1;
ea = a.i[2] & 0x7fff;
/* check for infinity or nan */
if (ea == 0x7fff) {
*exp = 0;
__infnanstring((((a.i[1] << 1) | a.i[0]) == 0)?
fp_infinity : fp_quiet, ndigits, buf);
return;
}
/* check for subnormal or zero */
if (ea == 0) {
if ((a.i[1] | a.i[0]) == 0) {
*exp = 0;
for (i = 0; i < ndigits; i++)
buf[i] = '0';
buf[ndigits] = '\0';
return;
}
/* normalize */
a.x *= 18446744073709551616.0; /* 2^64 */
ea = a.i[2] & 0x7fff;
*exp = ea - 0x403f;
} else {
*exp = ea - 0x3fff;
}
if (ndigits < 17) {
/*
* Round the significand at the appropriate bit by adding
* and subtracting a power of two. This will also raise
* the inexact exception if anything is rounded off.
*/
c.i[2] = (0x4042 | (s << 15)) - (ndigits << 2);
c.i[1] = 0x80000000;
c.i[0] = 0;
a.i[2] = 0x3fff | (s << 15);
a.x = (a.x + c.x) - c.x;
ea = a.i[2] & 0x7fff;
if (ea >= 0x4000)
(*exp)++;
}
/* convert to hex digits */
buf[0] = '1';
d = (a.i[1] << 1) | (a.i[0] >> 31);
for (i = 1; i < ndigits && i < 9; i++) {
buf[i] = hexchar[d >> 28];
d <<= 4;
}
d = a.i[0] << 1;
for (; i < ndigits && i < 17; i++) {
buf[i] = hexchar[d >> 28];
d <<= 4;
}
for (; i < ndigits; i++)
buf[i] = '0';
buf[ndigits] = '\0';
}
void
__aconvert(double arg, int ndigits, int *exp, int *sign, char *buf)
{
union {
int i[2];
double d;
} a;
long double ldarg;
int ha;
/* avoid raising invalid operation exception for signaling nan */
a.i[0] = *(int *)&arg;
a.i[1] = *(1+(int *)&arg);
ha = a.i[1] & ~0x80000000;
if (ha > 0x7ff00000 || (ha == 0x7ff00000 && a.i[0] != 0))
a.i[1] |= 0x80000; /* make nan quiet */
ldarg = a.d;
__qaconvert(&ldarg, ndigits, exp, sign, buf);
}
#else
#error Unknown architecture
#endif