/* Software floating-point emulation. Convert a _BitInt to _Decimal32. Copyright (C) 2023 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 . */ #include "soft-fp.h" #include "bitint.h" #ifdef __BITINT_MAXWIDTH__ extern _Decimal32 __bid_floatbitintsd (const UBILtype *, SItype); _Decimal32 __bid_floatbitintsd (const UBILtype *i, SItype iprec) { iprec = bitint_reduce_prec (&i, iprec); USItype aiprec = iprec < 0 ? -iprec : iprec; USItype in = (aiprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE; USItype idx = BITINT_END (0, in - 1); UBILtype msb = i[idx]; USItype mantissa; SItype exponent = 0; UBILtype inexact = 0; union { _Decimal32 d; USItype u; } u, ui; if (aiprec % BIL_TYPE_SIZE) { if (iprec > 0) msb &= ((UBILtype) 1 << (aiprec % BIL_TYPE_SIZE)) - 1; else msb |= (UBILtype) -1 << (aiprec % BIL_TYPE_SIZE); } if (iprec < 0) { SItype n = sizeof (0ULL) * __CHAR_BIT__ + 1 - __builtin_clzll (~msb); aiprec = (in - 1) * BIL_TYPE_SIZE + n; } else if (msb == 0) aiprec = 1; else { SItype n = sizeof (0ULL) * __CHAR_BIT__ - __builtin_clzll (msb); aiprec = (in - 1) * BIL_TYPE_SIZE + n; } /* Number of bits in (_BitInt(2048)) 9999999e+90DF. */ if (aiprec > 323 + (iprec < 0)) { ovf: if (iprec < 0) u.d = -9000000e+90DF; else u.d = 9000000e+90DF; __asm ("" : "+g" (u.d)); u.d += u.d; __asm ("" : "+g" (u.d)); goto done; } /* Bit precision of 9999999uwb. */ if (aiprec >= 24) { USItype pow10_limbs, q_limbs, q2_limbs, j; USItype exp_bits = 0, e; UDItype m; UBILtype *buf; /* First do a possibly large divide smaller enough such that we only need to check remainder for 0 or non-0 and then we'll do further division. */ if (aiprec >= 24 + 4 + 10) { exp_bits = (aiprec - 24 - 4) / 10; exponent = exp_bits * 3; /* Upper estimate for pow10 (exponent) bits. */ exp_bits = exp_bits * 10 - exp_bits / 30; } pow10_limbs = (exp_bits + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE; /* 38 is the highest number of quotient bits needed on aiprec range of [38, 323]. E.g. if aiprec is 317, exponent will be 84 and exp_bits 280. 317 - 280 + 1 is 38. */ q_limbs = (38 + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE; q2_limbs = (32 + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE; buf = __builtin_alloca ((q_limbs + pow10_limbs * 2 + q2_limbs + 2) * sizeof (UBILtype)); if (exponent) { __bid_pow10bitint (buf + q_limbs, exp_bits, exponent); __divmodbitint4 (buf, q_limbs * BIL_TYPE_SIZE, buf + q_limbs + pow10_limbs, pow10_limbs * BIL_TYPE_SIZE, i, iprec < 0 ? -aiprec : aiprec, buf + q_limbs, exp_bits); if (iprec < 0) bitint_negate (buf + BITINT_END (q_limbs - 1, 0), buf + BITINT_END (q_limbs - 1, 0), q_limbs); inexact = buf[q_limbs + pow10_limbs]; for (j = 1; j < pow10_limbs; ++j) inexact |= buf[q_limbs + pow10_limbs + j]; } else { __builtin_memcpy (buf + BITINT_END (q_limbs - in + 1, 0), i, (in - 1) * sizeof (UBILtype)); buf[BITINT_END (q_limbs - in, in - 1)] = msb; if (iprec < 0) bitint_negate (buf + BITINT_END (q_limbs - 1, 0), buf + BITINT_END (q_limbs - 1, 0), in); if (q_limbs > in) __builtin_memset (buf + BITINT_END (0, in), '\0', (q_limbs - in) * sizeof (UBILtype)); } e = 0; #if BIL_TYPE_SIZE == 64 m = buf[0]; #elif BIL_TYPE_SIZE == 32 m = ((UDItype) buf[BITINT_END (0, 1)] << 32) | buf[BITINT_END (1, 0)]; #else # error Unsupported BIL_TYPE_SIZE #endif if (m >= (UDItype) 10000000000) { if (m >= (UDItype) 100000000000) e = 5; else e = 4; } else if (m >= (UDItype) 100000000) { if (m >= (UDItype) 1000000000) e = 3; else e = 2; } else if (m >= (UDItype) 10000000) e = 1; exponent += e; if (exponent > 90) goto ovf; if (e) { UBILtype rem, half; __bid_pow10bitint (buf + q_limbs + pow10_limbs * 2, BIL_TYPE_SIZE, e); __divmodbitint4 (buf + q_limbs + pow10_limbs * 2 + 1, q2_limbs * BIL_TYPE_SIZE, buf + q_limbs + pow10_limbs * 2 + 1 + q2_limbs, BIL_TYPE_SIZE, buf, q_limbs * BIL_TYPE_SIZE, buf + q_limbs + pow10_limbs * 2, BIL_TYPE_SIZE); half = buf[q_limbs + pow10_limbs * 2] / 2; rem = buf[q_limbs + pow10_limbs * 2 + 1 + q2_limbs]; if (inexact) { /* If first division discovered some non-0 digits and this second division is by 10, e.g. for XXXXXX5499999999999 or XXXXXX5000000000001 if first division is by 10^12 and second by 10^1, doing rem |= 1 wouldn't change the 5. Similarly for rem 4 doing rem |= 1 would change it to 5, but we don't want to change it in that case. */ if (e == 1) { if (rem == 5) rem = 6; else if (rem != 4) rem |= 1; } else rem |= 1; } /* Set inexact to 0, 1, 2, 3 depending on if remainder of the divisions is exact 0, smaller than 10^exponent / 2, exactly 10^exponent / 2 or greater than that. */ if (rem >= half) inexact = 2 + (rem > half); else inexact = (rem != 0); mantissa = buf[q_limbs + pow10_limbs * 2 + 1]; } else #if BIL_TYPE_SIZE == 64 mantissa = buf[0]; #else mantissa = buf[BITINT_END (1, 0)]; #endif } else { mantissa = msb; if (iprec < 0) mantissa = -mantissa; } exponent += 101; if (mantissa >= (USItype) 0x800000) u.u = (((((iprec < 0) << 2) | (USItype) 3) << 29) | (((USItype) exponent) << 21) | (mantissa ^ (USItype) 0x800000)); else u.u = ((((USItype) (iprec < 0)) << 31) | (((USItype) exponent) << 23) | mantissa); if (inexact) { ui.u = ((((USItype) (iprec < 0)) << 31) | (((USItype) (exponent - 1)) << 23) | (inexact + 3)); __asm ("" : "+g" (u.d)); __asm ("" : "+g" (ui.d)); u.d += ui.d; __asm ("" : "+g" (u.d)); } done: return u.d; } #endif