[thirdparty/gcc.git] / libdecnumber / bid / bid2dpd_dpd2bid.c

/* Copyright (C) 2007-2019 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */

#undef IN_LIBGCC2
#include "bid-dpd.h"

/* get full 64x64bit product */
#define __mul_64x64_to_128(P, CX, CY)             \
{                                                 \
  UINT64 CXH, CXL, CYH,CYL,PL,PH,PM,PM2;  \
  CXH = (CX) >> 32;                               \
  CXL = (UINT32)(CX);                             \
  CYH = (CY) >> 32;                               \
  CYL = (UINT32)(CY);                             \
                                                  \
  PM = CXH*CYL;                                   \
  PH = CXH*CYH;                                   \
  PL = CXL*CYL;                                   \
  PM2 = CXL*CYH;                                  \
  PH += (PM>>32);                                 \
  PM = (UINT64)((UINT32)PM)+PM2+(PL>>32);         \
                                                  \
  (P).w[1] = PH + (PM>>32);                       \
  (P).w[0] = (PM<<32)+(UINT32)PL;                 \
}

/* add 64-bit value to 128-bit */
#define __add_128_64(R128, A128, B64)             \
{                                                 \
  UINT64 R64H;                                    \
  R64H = (A128).w[1];                             \
  (R128).w[0] = (B64) + (A128).w[0];              \
  if((R128).w[0] < (B64)) R64H ++;                \
  (R128).w[1] = R64H;                             \
}

/* add 128-bit value to 128-bit (assume no carry-out) */
#define __add_128_128(R128, A128, B128)           \
{                                                 \
  UINT128 Q128;                                   \
  Q128.w[1] = (A128).w[1]+(B128).w[1];            \
  Q128.w[0] = (B128).w[0] + (A128).w[0];          \
  if(Q128.w[0] < (B128).w[0]) Q128.w[1] ++;       \
  (R128).w[1] = Q128.w[1];                        \
  (R128).w[0] = Q128.w[0];                        \
}

#define __mul_128x128_high(Q, A, B)               \
{                                                 \
  UINT128 ALBL, ALBH, AHBL, AHBH, QM, QM2;        \
                                                  \
  __mul_64x64_to_128(ALBH, (A).w[0], (B).w[1]);   \
  __mul_64x64_to_128(AHBL, (B).w[0], (A).w[1]);   \
  __mul_64x64_to_128(ALBL, (A).w[0], (B).w[0]);   \
  __mul_64x64_to_128(AHBH, (A).w[1],(B).w[1]);    \
                                                  \
  __add_128_128(QM, ALBH, AHBL);                  \
  __add_128_64(QM2, QM, ALBL.w[1]);               \
  __add_128_64((Q), AHBH, QM2.w[1]);              \
}

#include "bid2dpd_dpd2bid.h"

static const unsigned int dm103[] =
  { 0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000 };

void _bid_to_dpd32 (_Decimal32 *, _Decimal32 *);

void
_bid_to_dpd32 (_Decimal32 *pres, _Decimal32 *px) {
  unsigned int sign, coefficient_x, exp, dcoeff;
  unsigned int b2, b1, b0, b01, res;
  _Decimal32 x = *px;

  sign = (x & 0x80000000);
  if ((x & 0x60000000ul) == 0x60000000ul) {
    /* special encodings */
    if ((x & 0x78000000ul) == 0x78000000ul) {
      *pres = x; /* NaN or Infinity */
      return;
    }
    /* coefficient */
    coefficient_x = (x & 0x001ffffful) | 0x00800000ul;
    if (coefficient_x >= 10000000) coefficient_x = 0;
    /* get exponent */
    exp = (x >> 21) & 0xff;
  } else {
    exp = (x >> 23) & 0xff;
    coefficient_x = (x & 0x007ffffful);
  }
  b01 = coefficient_x / 1000;
  b2 = coefficient_x - 1000 * b01;
  b0 = b01 / 1000;
  b1 = b01 - 1000 * b0;
  dcoeff = b2d[b2] | b2d2[b1];
  if (b0 >= 8) { /* is b0 8 or 9? */
    res = sign | ((0x600 | ((exp >> 6) << 7) |
        ((b0 & 1) << 6) | (exp & 0x3f)) << 20) | dcoeff;
  } else { /* else b0 is 0..7 */
    res = sign | ((((exp >> 6) << 9) | (b0 << 6) |
        (exp & 0x3f)) << 20) | dcoeff;
  }
  *pres = res;
}

void _dpd_to_bid32 (_Decimal32 *, _Decimal32 *);

void
_dpd_to_bid32 (_Decimal32 *pres, _Decimal32 *px) {
  unsigned int r;
  unsigned int sign, exp, bcoeff;
  UINT64 trailing;
  unsigned int d0, d1, d2;
  _Decimal32 x = *px;

  sign = (x & 0x80000000);
  trailing = (x & 0x000fffff);
  if ((x & 0x78000000) == 0x78000000) {
    *pres = x;
    return;
  }
  /* normal number */
  if ((x & 0x60000000) == 0x60000000) { /* G0..G1 = 11 -> d0 = 8 + G4 */
    d0 = d2b3[((x >> 26) & 1) | 8]; /* d0 = (comb & 0x0100 ? 9 : 8); */
    exp = (x >> 27) & 3; /* exp leading bits are G2..G3 */
  } else {
    d0 = d2b3[(x >> 26) & 0x7];
    exp = (x >> 29) & 3; /* exp loading bits are G0..G1 */
  }
  d1 = d2b2[(trailing >> 10) & 0x3ff];
  d2 = d2b[(trailing) & 0x3ff];
  bcoeff = d2 + d1 + d0;
  exp = (exp << 6) + ((x >> 20) & 0x3f);
  if (bcoeff < (1 << 23)) {
    r = exp;
    r <<= 23;
    r |= (bcoeff | sign);
  } else {
    r = exp;
    r <<= 21;
    r |= (sign | 0x60000000ul);
    /* add coeff, without leading bits */
    r |= (((unsigned int) bcoeff) & 0x1fffff);
  }
  *pres = r;
}

void _bid_to_dpd64 (_Decimal64 *, _Decimal64 *);

void
_bid_to_dpd64 (_Decimal64 *pres, _Decimal64 *px) {
  UINT64 res;
  UINT64 sign, comb, exp, B34, B01;
  UINT64 d103, D61;
  UINT64 b0, b2, b3, b5;
  unsigned int b1, b4;
  UINT64 bcoeff;
  UINT64 dcoeff;
  unsigned int yhi, ylo;
  _Decimal64 x = *px;

  sign = (x & 0x8000000000000000ull);
  comb = (x & 0x7ffc000000000000ull) >> 51;
  if ((comb & 0xf00) == 0xf00) {
    *pres = x;
    return;
  }
  /* Normal number */
  if ((comb & 0xc00) == 0xc00) { /* G0..G1 = 11 -> exp is G2..G11 */
    exp = (comb) & 0x3ff;
    bcoeff = (x & 0x0007ffffffffffffull) | 0x0020000000000000ull;
  } else {
    exp = (comb >> 2) & 0x3ff;
    bcoeff = (x & 0x001fffffffffffffull);
  }
  D61 = 2305843009ull; /* Floor(2^61 / 10^9) */
  /* Multiply the binary coefficient by ceil(2^64 / 1000), and take the upper
     64-bits in order to compute a division by 1000. */
  yhi = (D61 * (UINT64)(bcoeff >> (UINT64)27)) >> (UINT64)34;
  ylo = bcoeff - 1000000000ull * yhi;
  if (ylo >= 1000000000) {
    ylo = ylo - 1000000000;
    yhi = yhi + 1;
  }
  d103 = 0x4189374c;
  B34 = ((UINT64) ylo * d103) >> (32 + 8);
  B01 = ((UINT64) yhi * d103) >> (32 + 8);
  b5 = ylo - B34 * 1000;
  b2 = yhi - B01 * 1000;
  b3 = ((UINT64) B34 * d103) >> (32 + 8);
  b0 = ((UINT64) B01 * d103) >> (32 + 8);
  b4 = (unsigned int) B34 - (unsigned int) b3 *1000;
  b1 = (unsigned int) B01 - (unsigned int) dm103[b0];
  dcoeff = b2d[b5] | b2d2[b4] | b2d3[b3] | b2d4[b2] | b2d5[b1];
  if (b0 >= 8) /* is b0 8 or 9? */
    res = sign | ((0x1800 | ((exp >> 8) << 9) | ((b0 & 1) << 8) |
                   (exp & 0xff)) << 50) | dcoeff;
  else /* else b0 is 0..7 */
    res = sign | ((((exp >> 8) << 11) | (b0 << 8) |
                     (exp & 0xff)) << 50) | dcoeff;
  *pres = res;
}

void _dpd_to_bid64 (_Decimal64 *, _Decimal64 *);

void
_dpd_to_bid64 (_Decimal64 *pres, _Decimal64 *px) {
  UINT64 res;
  UINT64 sign, comb, exp;
  UINT64 trailing;
  UINT64 d0, d1, d2;
  unsigned int d3, d4, d5;
  UINT64 bcoeff, mask;
  _Decimal64 x = *px;

  sign = (x & 0x8000000000000000ull);
  comb = (x & 0x7ffc000000000000ull) >> 50;
  trailing = (x & 0x0003ffffffffffffull);
  if ((comb & 0x1e00) == 0x1e00) {
    *pres = x;
    return;
  }
  /* normal number */
  if ((comb & 0x1800) == 0x1800) { /* G0..G1 = 11 -> d0 = 8 + G4 */
    d0 = d2b6[((comb >> 8) & 1) | 8]; /* d0 = (comb & 0x0100 ? 9 : 8); */
    exp = (comb & 0x600) >> 1; /* exp = (comb & 0x0400 ? 1 : 0) * 0x200 +
        (comb & 0x0200 ? 1 : 0) * 0x100; exp leading bits are G2..G3 */
  } else {
    d0 = d2b6[(comb >> 8) & 0x7];
    exp = (comb & 0x1800) >> 3; /* exp = (comb & 0x1000 ? 1 : 0) * 0x200 +
        (comb & 0x0800 ? 1 : 0) * 0x100; exp loading bits are G0..G1 */
  }
  d1 = d2b5[(trailing >> 40) & 0x3ff];
  d2 = d2b4[(trailing >> 30) & 0x3ff];
  d3 = d2b3[(trailing >> 20) & 0x3ff];
  d4 = d2b2[(trailing >> 10) & 0x3ff];
  d5 = d2b[(trailing) & 0x3ff];
  bcoeff = (d5 + d4 + d3) + d2 + d1 + d0;
  exp += (comb & 0xff);
  mask = 1;
  mask <<= 53;
  if (bcoeff < mask) { /* check whether coefficient fits in 10*5+3 bits */
    res = exp;
    res <<= 53;
    res |= (bcoeff | sign);
    *pres = res;
    return;
  }
  /* special format */
  res = (exp << 51) | (sign | 0x6000000000000000ull);
  /* add coeff, without leading bits */
  mask = (mask >> 2) - 1;
  bcoeff &= mask;
  res |= bcoeff;
  *pres = res;
}

void _bid_to_dpd128 (_Decimal128 *, _Decimal128 *);

void
_bid_to_dpd128 (_Decimal128 *pres, _Decimal128 *px) {
  UINT128 res;
  UINT128 sign;
  unsigned int comb;
  UINT128 bcoeff;
  UINT128 dcoeff;
  UINT128 BH, d1018, BT2, BT1;
  UINT64 exp, BL, d109;
  UINT64 d106, d103;
  UINT64 k1, k2, k4, k5, k7, k8, k10, k11;
  unsigned int BHH32, BLL32, BHL32, BLH32, k0, k3, k6, k9, amount;
  _Decimal128 x = *px;

  sign.w[1] = (x.w[1] & 0x8000000000000000ull);
  sign.w[0] = 0;
  comb = (x.w[1] /*& 0x7fffc00000000000ull */ ) >> 46;
  exp = 0;
  if ((comb & 0x1e000) == 0x1e000) {
    res = x;
  } else { /* normal number */
    exp = ((x.w[1] & 0x7fff000000000000ull) >> 49) & 0x3fff;
    bcoeff.w[1] = (x.w[1] & 0x0001ffffffffffffull);
    bcoeff.w[0] = x.w[0];
    d1018 = reciprocals10_128[18];
    __mul_128x128_high (BH, bcoeff, d1018);
    amount = recip_scale[18];
    BH.w[0] = (BH.w[0] >> amount) | (BH.w[1] << (64 - amount));
    BL = bcoeff.w[0] - BH.w[0] * 1000000000000000000ull;
    d109 = reciprocals10_64[9];
    __mul_64x64_to_128 (BT1, BH.w[0], d109);
    BHH32 = (unsigned int) (BT1.w[1] >> short_recip_scale[9]);
    BHL32 = (unsigned int) BH.w[0] - BHH32 * 1000000000;
    __mul_64x64_to_128 (BT2, BL, d109);
    BLH32 = (unsigned int) (BT2.w[1] >> short_recip_scale[9]);
    BLL32 = (unsigned int) BL - BLH32 * 1000000000;
    d106 = 0x431BDE83;
    d103 = 0x4189374c;
    k0 = ((UINT64) BHH32 * d106) >> (32 + 18);
    BHH32 -= (unsigned int) k0 *1000000;
    k1 = ((UINT64) BHH32 * d103) >> (32 + 8);
    k2 = BHH32 - (unsigned int) k1 *1000;
    k3 = ((UINT64) BHL32 * d106) >> (32 + 18);
    BHL32 -= (unsigned int) k3 *1000000;
    k4 = ((UINT64) BHL32 * d103) >> (32 + 8);
    k5 = BHL32 - (unsigned int) k4 *1000;
    k6 = ((UINT64) BLH32 * d106) >> (32 + 18);
    BLH32 -= (unsigned int) k6 *1000000;
    k7 = ((UINT64) BLH32 * d103) >> (32 + 8);
    k8 = BLH32 - (unsigned int) k7 *1000;
    k9 = ((UINT64) BLL32 * d106) >> (32 + 18);
    BLL32 -= (unsigned int) k9 *1000000;
    k10 = ((UINT64) BLL32 * d103) >> (32 + 8);
    k11 = BLL32 - (unsigned int) k10 *1000;
    dcoeff.w[1] = (b2d[k5] >> 4) | (b2d[k4] << 6) | (b2d[k3] << 16) |
      (b2d[k2] << 26) | (b2d[k1] << 36);
    dcoeff.w[0] = b2d[k11] | (b2d[k10] << 10) | (b2d[k9] << 20) |
      (b2d[k8] << 30) | (b2d[k7] << 40) | (b2d[k6] << 50) | (b2d[k5] << 60);
    res.w[0] = dcoeff.w[0];
    if (k0 >= 8) {
      res.w[1] = sign.w[1] | ((0x18000 | ((exp >> 12) << 13) |
          ((k0 & 1) << 12) | (exp & 0xfff)) << 46) | dcoeff.w[1];
    } else {
      res.w[1] = sign.w[1] | ((((exp >> 12) << 15) | (k0 << 12) |
          (exp & 0xfff)) << 46) | dcoeff.w[1];
    }
  }
  *pres = res;
}

void _dpd_to_bid128 (_Decimal128 *, _Decimal128 *);

void
_dpd_to_bid128 (_Decimal128 *pres, _Decimal128 *px) {
  UINT128 res;
  UINT128 sign;
  UINT64 exp, comb;
  UINT128 trailing;
  UINT64 d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11;
  UINT128 bcoeff;
  UINT64 tl, th;
  _Decimal128 x = *px;

  sign.w[1] = (x.w[1] & 0x8000000000000000ull);
  sign.w[0] = 0;
  comb = (x.w[1] & 0x7fffc00000000000ull) >> 46;
  trailing.w[1] = x.w[1];
  trailing.w[0] = x.w[0];
  if ((comb & 0x1e000) == 0x1e000) {
      *pres = x;
      return;
  }
  if ((comb & 0x18000) == 0x18000) { /* G0..G1 = 11 -> d0 = 8 + G4 */
    d0 = d2b6[8 + ((comb & 0x01000) >> 12)];
    exp = (comb & 0x06000) >> 1;  /* exp leading bits are G2..G3 */
  } else {
    d0 = d2b6[((comb & 0x07000) >> 12)];
    exp = (comb & 0x18000) >> 3;  /* exp loading bits are G0..G1 */
  }
  d11 = d2b[(trailing.w[0]) & 0x3ff];
  d10 = d2b2[(trailing.w[0] >> 10) & 0x3ff];
  d9 = d2b3[(trailing.w[0] >> 20) & 0x3ff];
  d8 = d2b4[(trailing.w[0] >> 30) & 0x3ff];
  d7 = d2b5[(trailing.w[0] >> 40) & 0x3ff];
  d6 = d2b6[(trailing.w[0] >> 50) & 0x3ff];
  d5 = d2b[(trailing.w[0] >> 60) | ((trailing.w[1] & 0x3f) << 4)];
  d4 = d2b2[(trailing.w[1] >> 6) & 0x3ff];
  d3 = d2b3[(trailing.w[1] >> 16) & 0x3ff];
  d2 = d2b4[(trailing.w[1] >> 26) & 0x3ff];
  d1 = d2b5[(trailing.w[1] >> 36) & 0x3ff];
  tl = d11 + d10 + d9 + d8 + d7 + d6;
  th = d5 + d4 + d3 + d2 + d1 + d0;
  __mul_64x64_to_128 (bcoeff, th, 1000000000000000000ull);
  __add_128_64 (bcoeff, bcoeff, tl);
  exp += (comb & 0xfff);
  res.w[0] = bcoeff.w[0];
  res.w[1] = (exp << 49) | sign.w[1] | bcoeff.w[1];
  *pres = res;
}
Commit	Line	Data
a5544970	1	/* Copyright (C) 2007-2019 Free Software Foundation, Inc.
79b87c74 MM	2
	3	This file is part of GCC.
	4
	5	GCC is free software; you can redistribute it and/or modify it under
	6	the terms of the GNU General Public License as published by the Free
748086b7	7	Software Foundation; either version 3, or (at your option) any later
79b87c74 MM	8	version.
79b87c74 MM	9
79b87c74 MM	10	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	11	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	13	for more details.
	14
748086b7 JJ	15	Under Section 7 of GPL version 3, you are granted additional
	16	permissions described in the GCC Runtime Library Exception, version
	17	3.1, as published by the Free Software Foundation.
	18
	19	You should have received a copy of the GNU General Public License and
	20	a copy of the GCC Runtime Library Exception along with this program;
	21	see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
	22	<http://www.gnu.org/licenses/>. */
79b87c74 MM	23
	24	#undef IN_LIBGCC2
	25	#include "bid-dpd.h"
	26
	27	/* get full 64x64bit product */
	28	#define __mul_64x64_to_128(P, CX, CY) \
	29	{ \
	30	UINT64 CXH, CXL, CYH,CYL,PL,PH,PM,PM2; \
	31	CXH = (CX) >> 32; \
	32	CXL = (UINT32)(CX); \
	33	CYH = (CY) >> 32; \
	34	CYL = (UINT32)(CY); \
	35	\
	36	PM = CXH*CYL; \
	37	PH = CXH*CYH; \
	38	PL = CXL*CYL; \
	39	PM2 = CXL*CYH; \
	40	PH += (PM>>32); \
	41	PM = (UINT64)((UINT32)PM)+PM2+(PL>>32); \
	42	\
	43	(P).w[1] = PH + (PM>>32); \
	44	(P).w[0] = (PM<<32)+(UINT32)PL; \
	45	}
	46
	47	/* add 64-bit value to 128-bit */
	48	#define __add_128_64(R128, A128, B64) \
	49	{ \
	50	UINT64 R64H; \
	51	R64H = (A128).w[1]; \
	52	(R128).w[0] = (B64) + (A128).w[0]; \
	53	if((R128).w[0] < (B64)) R64H ++; \
	54	(R128).w[1] = R64H; \
	55	}
	56
	57	/* add 128-bit value to 128-bit (assume no carry-out) */
	58	#define __add_128_128(R128, A128, B128) \
	59	{ \
	60	UINT128 Q128; \
	61	Q128.w[1] = (A128).w[1]+(B128).w[1]; \
	62	Q128.w[0] = (B128).w[0] + (A128).w[0]; \
	63	if(Q128.w[0] < (B128).w[0]) Q128.w[1] ++; \
	64	(R128).w[1] = Q128.w[1]; \
	65	(R128).w[0] = Q128.w[0]; \
	66	}
	67
	68	#define __mul_128x128_high(Q, A, B) \
	69	{ \
	70	UINT128 ALBL, ALBH, AHBL, AHBH, QM, QM2; \
	71	\
	72	__mul_64x64_to_128(ALBH, (A).w[0], (B).w[1]); \
	73	__mul_64x64_to_128(AHBL, (B).w[0], (A).w[1]); \
	74	__mul_64x64_to_128(ALBL, (A).w[0], (B).w[0]); \
	75	__mul_64x64_to_128(AHBH, (A).w[1],(B).w[1]); \
	76	\
	77	__add_128_128(QM, ALBH, AHBL); \
	78	__add_128_64(QM2, QM, ALBL.w[1]); \
	79	__add_128_64((Q), AHBH, QM2.w[1]); \
	80	}
	81
	82	#include "bid2dpd_dpd2bid.h"
	83
	84	static const unsigned int dm103[] =
	85	{ 0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000 };
	86
87	void _bid_to_dpd32 (_Decimal32 , _Decimal32 );
88
89	void
90	_bid_to_dpd32 (_Decimal32 pres, _Decimal32 px) {
91	unsigned int sign, coefficient_x, exp, dcoeff;
92	unsigned int b2, b1, b0, b01, res;
93	_Decimal32 x = *px;
94
95	sign = (x & 0x80000000);
96	if ((x & 0x60000000ul) == 0x60000000ul) {
97	/* special encodings */
98	if ((x & 0x78000000ul) == 0x78000000ul) {
99	pres = x; / NaN or Infinity */
100	return;
101	}
102	/* coefficient */
103	coefficient_x = (x & 0x001ffffful) \| 0x00800000ul;
104	if (coefficient_x >= 10000000) coefficient_x = 0;
105	/* get exponent */
106	exp = (x >> 21) & 0xff;
107	} else {
108	exp = (x >> 23) & 0xff;
109	coefficient_x = (x & 0x007ffffful);
110	}
111	b01 = coefficient_x / 1000;
112	b2 = coefficient_x - 1000 * b01;
113	b0 = b01 / 1000;
114	b1 = b01 - 1000 * b0;
115	dcoeff = b2d[b2] \| b2d2[b1];
116	if (b0 >= 8) { /* is b0 8 or 9? */
6044f5e3	117	res = sign \| ((0x600 \| ((exp >> 6) << 7) \|
79b87c74 MM	118	((b0 & 1) << 6) \| (exp & 0x3f)) << 20) \| dcoeff;
79b87c74 MM	119	} else { /* else b0 is 0..7 */
6044f5e3	120	res = sign \| ((((exp >> 6) << 9) \| (b0 << 6) \|
79b87c74 MM	121	(exp & 0x3f)) << 20) \| dcoeff;
	122	}
	123	*pres = res;
	124	}
	125
	126	void _dpd_to_bid32 (_Decimal32 , _Decimal32 );
	127
	128	void
	129	_dpd_to_bid32 (_Decimal32 pres, _Decimal32 px) {
	130	unsigned int r;
	131	unsigned int sign, exp, bcoeff;
	132	UINT64 trailing;
	133	unsigned int d0, d1, d2;
	134	_Decimal32 x = *px;
	135
	136	sign = (x & 0x80000000);
	137	trailing = (x & 0x000fffff);
	138	if ((x & 0x78000000) == 0x78000000) {
	139	*pres = x;
	140	return;
6044f5e3 SL	141	}
	142	/* normal number */
	143	if ((x & 0x60000000) == 0x60000000) { /* G0..G1 = 11 -> d0 = 8 + G4 */
	144	d0 = d2b3[((x >> 26) & 1) \| 8]; /* d0 = (comb & 0x0100 ? 9 : 8); */
	145	exp = (x >> 27) & 3; /* exp leading bits are G2..G3 */
	146	} else {
	147	d0 = d2b3[(x >> 26) & 0x7];
	148	exp = (x >> 29) & 3; /* exp loading bits are G0..G1 */
	149	}
	150	d1 = d2b2[(trailing >> 10) & 0x3ff];
	151	d2 = d2b[(trailing) & 0x3ff];
	152	bcoeff = d2 + d1 + d0;
	153	exp = (exp << 6) + ((x >> 20) & 0x3f);
	154	if (bcoeff < (1 << 23)) {
	155	r = exp;
	156	r <<= 23;
	157	r \|= (bcoeff \| sign);
	158	} else {
	159	r = exp;
	160	r <<= 21;
	161	r \|= (sign \| 0x60000000ul);
	162	/* add coeff, without leading bits */
	163	r \|= (((unsigned int) bcoeff) & 0x1fffff);
79b87c74 MM	164	}
	165	*pres = r;
	166	}
	167
	168	void _bid_to_dpd64 (_Decimal64 , _Decimal64 );
	169
	170	void
	171	_bid_to_dpd64 (_Decimal64 pres, _Decimal64 px) {
	172	UINT64 res;
	173	UINT64 sign, comb, exp, B34, B01;
	174	UINT64 d103, D61;
	175	UINT64 b0, b2, b3, b5;
	176	unsigned int b1, b4;
	177	UINT64 bcoeff;
	178	UINT64 dcoeff;
	179	unsigned int yhi, ylo;
	180	_Decimal64 x = *px;
	181
	182	sign = (x & 0x8000000000000000ull);
	183	comb = (x & 0x7ffc000000000000ull) >> 51;
	184	if ((comb & 0xf00) == 0xf00) {
	185	*pres = x;
	186	return;
79b87c74	187	}
6044f5e3 SL	188	/* Normal number */
	189	if ((comb & 0xc00) == 0xc00) { /* G0..G1 = 11 -> exp is G2..G11 */
	190	exp = (comb) & 0x3ff;
	191	bcoeff = (x & 0x0007ffffffffffffull) \| 0x0020000000000000ull;
	192	} else {
	193	exp = (comb >> 2) & 0x3ff;
	194	bcoeff = (x & 0x001fffffffffffffull);
	195	}
	196	D61 = 2305843009ull; /* Floor(2^61 / 10^9) */
	197	/* Multiply the binary coefficient by ceil(2^64 / 1000), and take the upper
	198	64-bits in order to compute a division by 1000. */
	199	yhi = (D61 * (UINT64)(bcoeff >> (UINT64)27)) >> (UINT64)34;
	200	ylo = bcoeff - 1000000000ull * yhi;
	201	if (ylo >= 1000000000) {
	202	ylo = ylo - 1000000000;
	203	yhi = yhi + 1;
	204	}
	205	d103 = 0x4189374c;
	206	B34 = ((UINT64) ylo * d103) >> (32 + 8);
	207	B01 = ((UINT64) yhi * d103) >> (32 + 8);
	208	b5 = ylo - B34 * 1000;
	209	b2 = yhi - B01 * 1000;
	210	b3 = ((UINT64) B34 * d103) >> (32 + 8);
	211	b0 = ((UINT64) B01 * d103) >> (32 + 8);
	212	b4 = (unsigned int) B34 - (unsigned int) b3 *1000;
	213	b1 = (unsigned int) B01 - (unsigned int) dm103[b0];
	214	dcoeff = b2d[b5] \| b2d2[b4] \| b2d3[b3] \| b2d4[b2] \| b2d5[b1];
	215	if (b0 >= 8) /* is b0 8 or 9? */
	216	res = sign \| ((0x1800 \| ((exp >> 8) << 9) \| ((b0 & 1) << 8) \|
	217	(exp & 0xff)) << 50) \| dcoeff;
	218	else /* else b0 is 0..7 */
	219	res = sign \| ((((exp >> 8) << 11) \| (b0 << 8) \|
	220	(exp & 0xff)) << 50) \| dcoeff;
79b87c74 MM	221	*pres = res;
	222	}
	223
	224	void _dpd_to_bid64 (_Decimal64 , _Decimal64 );
	225
	226	void
	227	_dpd_to_bid64 (_Decimal64 pres, _Decimal64 px) {
	228	UINT64 res;
	229	UINT64 sign, comb, exp;
	230	UINT64 trailing;
	231	UINT64 d0, d1, d2;
	232	unsigned int d3, d4, d5;
	233	UINT64 bcoeff, mask;
	234	_Decimal64 x = *px;
	235
	236	sign = (x & 0x8000000000000000ull);
	237	comb = (x & 0x7ffc000000000000ull) >> 50;
	238	trailing = (x & 0x0003ffffffffffffull);
	239	if ((comb & 0x1e00) == 0x1e00) {
6044f5e3	240	*pres = x;
79b87c74	241	return;
79b87c74	242	}
6044f5e3 SL	243	/* normal number */
	244	if ((comb & 0x1800) == 0x1800) { /* G0..G1 = 11 -> d0 = 8 + G4 */
	245	d0 = d2b6[((comb >> 8) & 1) \| 8]; /* d0 = (comb & 0x0100 ? 9 : 8); */
	246	exp = (comb & 0x600) >> 1; /* exp = (comb & 0x0400 ? 1 : 0) * 0x200 +
	247	(comb & 0x0200 ? 1 : 0) * 0x100; exp leading bits are G2..G3 */
	248	} else {
	249	d0 = d2b6[(comb >> 8) & 0x7];
	250	exp = (comb & 0x1800) >> 3; /* exp = (comb & 0x1000 ? 1 : 0) * 0x200 +
	251	(comb & 0x0800 ? 1 : 0) * 0x100; exp loading bits are G0..G1 */
	252	}
	253	d1 = d2b5[(trailing >> 40) & 0x3ff];
	254	d2 = d2b4[(trailing >> 30) & 0x3ff];
	255	d3 = d2b3[(trailing >> 20) & 0x3ff];
	256	d4 = d2b2[(trailing >> 10) & 0x3ff];
	257	d5 = d2b[(trailing) & 0x3ff];
	258	bcoeff = (d5 + d4 + d3) + d2 + d1 + d0;
	259	exp += (comb & 0xff);
	260	mask = 1;
	261	mask <<= 53;
	262	if (bcoeff < mask) { /* check whether coefficient fits in 105+3 bits /
	263	res = exp;
	264	res <<= 53;
	265	res \|= (bcoeff \| sign);
	266	*pres = res;
	267	return;
	268	}
	269	/* special format */
	270	res = (exp << 51) \| (sign \| 0x6000000000000000ull);
	271	/* add coeff, without leading bits */
	272	mask = (mask >> 2) - 1;
	273	bcoeff &= mask;
	274	res \|= bcoeff;
79b87c74 MM	275	*pres = res;
	276	}
	277
	278	void _bid_to_dpd128 (_Decimal128 , _Decimal128 );
	279
	280	void
	281	_bid_to_dpd128 (_Decimal128 pres, _Decimal128 px) {
	282	UINT128 res;
	283	UINT128 sign;
	284	unsigned int comb;
	285	UINT128 bcoeff;
	286	UINT128 dcoeff;
	287	UINT128 BH, d1018, BT2, BT1;
	288	UINT64 exp, BL, d109;
	289	UINT64 d106, d103;
	290	UINT64 k1, k2, k4, k5, k7, k8, k10, k11;
	291	unsigned int BHH32, BLL32, BHL32, BLH32, k0, k3, k6, k9, amount;
	292	_Decimal128 x = *px;
	293
	294	sign.w[1] = (x.w[1] & 0x8000000000000000ull);
	295	sign.w[0] = 0;
	296	comb = (x.w[1] /& 0x7fffc00000000000ull / ) >> 46;
	297	exp = 0;
	298	if ((comb & 0x1e000) == 0x1e000) {
6044f5e3	299	res = x;
79b87c74 MM	300	} else { /* normal number */
	301	exp = ((x.w[1] & 0x7fff000000000000ull) >> 49) & 0x3fff;
	302	bcoeff.w[1] = (x.w[1] & 0x0001ffffffffffffull);
	303	bcoeff.w[0] = x.w[0];
	304	d1018 = reciprocals10_128[18];
	305	__mul_128x128_high (BH, bcoeff, d1018);
	306	amount = recip_scale[18];
	307	BH.w[0] = (BH.w[0] >> amount) \| (BH.w[1] << (64 - amount));
	308	BL = bcoeff.w[0] - BH.w[0] * 1000000000000000000ull;
	309	d109 = reciprocals10_64[9];
	310	__mul_64x64_to_128 (BT1, BH.w[0], d109);
	311	BHH32 = (unsigned int) (BT1.w[1] >> short_recip_scale[9]);
	312	BHL32 = (unsigned int) BH.w[0] - BHH32 * 1000000000;
	313	__mul_64x64_to_128 (BT2, BL, d109);
	314	BLH32 = (unsigned int) (BT2.w[1] >> short_recip_scale[9]);
	315	BLL32 = (unsigned int) BL - BLH32 * 1000000000;
	316	d106 = 0x431BDE83;
	317	d103 = 0x4189374c;
	318	k0 = ((UINT64) BHH32 * d106) >> (32 + 18);
	319	BHH32 -= (unsigned int) k0 *1000000;
	320	k1 = ((UINT64) BHH32 * d103) >> (32 + 8);
	321	k2 = BHH32 - (unsigned int) k1 *1000;
	322	k3 = ((UINT64) BHL32 * d106) >> (32 + 18);
	323	BHL32 -= (unsigned int) k3 *1000000;
	324	k4 = ((UINT64) BHL32 * d103) >> (32 + 8);
	325	k5 = BHL32 - (unsigned int) k4 *1000;
	326	k6 = ((UINT64) BLH32 * d106) >> (32 + 18);
	327	BLH32 -= (unsigned int) k6 *1000000;
	328	k7 = ((UINT64) BLH32 * d103) >> (32 + 8);
	329	k8 = BLH32 - (unsigned int) k7 *1000;
	330	k9 = ((UINT64) BLL32 * d106) >> (32 + 18);
	331	BLL32 -= (unsigned int) k9 *1000000;
	332	k10 = ((UINT64) BLL32 * d103) >> (32 + 8);
	333	k11 = BLL32 - (unsigned int) k10 *1000;
6044f5e3 SL	334	dcoeff.w[1] = (b2d[k5] >> 4) \| (b2d[k4] << 6) \| (b2d[k3] << 16) \|
	335	(b2d[k2] << 26) \| (b2d[k1] << 36);
	336	dcoeff.w[0] = b2d[k11] \| (b2d[k10] << 10) \| (b2d[k9] << 20) \|
	337	(b2d[k8] << 30) \| (b2d[k7] << 40) \| (b2d[k6] << 50) \| (b2d[k5] << 60);
79b87c74 MM	338	res.w[0] = dcoeff.w[0];
79b87c74 MM	339	if (k0 >= 8) {
6044f5e3	340	res.w[1] = sign.w[1] \| ((0x18000 \| ((exp >> 12) << 13) \|
79b87c74 MM	341	((k0 & 1) << 12) \| (exp & 0xfff)) << 46) \| dcoeff.w[1];
79b87c74 MM	342	} else {
6044f5e3	343	res.w[1] = sign.w[1] \| ((((exp >> 12) << 15) \| (k0 << 12) \|
79b87c74 MM	344	(exp & 0xfff)) << 46) \| dcoeff.w[1];
	345	}
	346	}
	347	*pres = res;
	348	}
	349
	350	void _dpd_to_bid128 (_Decimal128 , _Decimal128 );
	351
	352	void
	353	_dpd_to_bid128 (_Decimal128 pres, _Decimal128 px) {
	354	UINT128 res;
	355	UINT128 sign;
	356	UINT64 exp, comb;
	357	UINT128 trailing;
	358	UINT64 d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11;
	359	UINT128 bcoeff;
	360	UINT64 tl, th;
	361	_Decimal128 x = *px;
	362
	363	sign.w[1] = (x.w[1] & 0x8000000000000000ull);
	364	sign.w[0] = 0;
	365	comb = (x.w[1] & 0x7fffc00000000000ull) >> 46;
	366	trailing.w[1] = x.w[1];
	367	trailing.w[0] = x.w[0];
	368	if ((comb & 0x1e000) == 0x1e000) {
79b87c74	369	*pres = x;
6044f5e3 SL	370	return;
	371	}
	372	if ((comb & 0x18000) == 0x18000) { /* G0..G1 = 11 -> d0 = 8 + G4 */
	373	d0 = d2b6[8 + ((comb & 0x01000) >> 12)];
	374	exp = (comb & 0x06000) >> 1; /* exp leading bits are G2..G3 */
	375	} else {
	376	d0 = d2b6[((comb & 0x07000) >> 12)];
	377	exp = (comb & 0x18000) >> 3; /* exp loading bits are G0..G1 */
79b87c74	378	}
6044f5e3 SL	379	d11 = d2b[(trailing.w[0]) & 0x3ff];
	380	d10 = d2b2[(trailing.w[0] >> 10) & 0x3ff];
	381	d9 = d2b3[(trailing.w[0] >> 20) & 0x3ff];
	382	d8 = d2b4[(trailing.w[0] >> 30) & 0x3ff];
	383	d7 = d2b5[(trailing.w[0] >> 40) & 0x3ff];
	384	d6 = d2b6[(trailing.w[0] >> 50) & 0x3ff];
	385	d5 = d2b[(trailing.w[0] >> 60) \| ((trailing.w[1] & 0x3f) << 4)];
	386	d4 = d2b2[(trailing.w[1] >> 6) & 0x3ff];
	387	d3 = d2b3[(trailing.w[1] >> 16) & 0x3ff];
	388	d2 = d2b4[(trailing.w[1] >> 26) & 0x3ff];
	389	d1 = d2b5[(trailing.w[1] >> 36) & 0x3ff];
	390	tl = d11 + d10 + d9 + d8 + d7 + d6;
	391	th = d5 + d4 + d3 + d2 + d1 + d0;
	392	__mul_64x64_to_128 (bcoeff, th, 1000000000000000000ull);
	393	__add_128_64 (bcoeff, bcoeff, tl);
	394	exp += (comb & 0xfff);
	395	res.w[0] = bcoeff.w[0];
	396	res.w[1] = (exp << 49) \| sign.w[1] \| bcoeff.w[1];
79b87c74 MM	397	*pres = res;
79b87c74 MM	398	}