1 /* Half-float conversion routines. 2 3 Copyright (C) 2008-2019 Free Software Foundation, Inc. 4 Contributed by CodeSourcery. 5 6 This file is free software; you can redistribute it and/or modify it 7 under the terms of the GNU General Public License as published by the 8 Free Software Foundation; either version 3, or (at your option) any 9 later version. 10 11 This file is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 General Public License for more details. 15 16 Under Section 7 of GPL version 3, you are granted additional 17 permissions described in the GCC Runtime Library Exception, version 18 3.1, as published by the Free Software Foundation. 19 20 You should have received a copy of the GNU General Public License and 21 a copy of the GCC Runtime Library Exception along with this program; 22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 <http://www.gnu.org/licenses/>. */ 24 25 struct format 26 { 27 /* Number of bits. */ 28 unsigned long long size; 29 /* Exponent bias. */ 30 unsigned long long bias; 31 /* Exponent width in bits. */ 32 unsigned long long exponent; 33 /* Significand precision in explicitly stored bits. */ 34 unsigned long long significand; 35 }; 36 37 static const struct format 38 binary32 = 39 { 40 32, /* size. */ 41 127, /* bias. */ 42 8, /* exponent. */ 43 23 /* significand. */ 44 }; 45 46 static const struct format 47 binary64 = 48 { 49 64, /* size. */ 50 1023, /* bias. */ 51 11, /* exponent. */ 52 52 /* significand. */ 53 }; 54 55 static inline unsigned short 56 __gnu_float2h_internal (const struct format* fmt, 57 unsigned long long a, int ieee) 58 { 59 unsigned long long point = 1ULL << fmt->significand; 60 unsigned short sign = (a >> (fmt->size - 16)) & 0x8000; 61 int aexp; 62 unsigned long long mantissa; 63 unsigned long long mask; 64 unsigned long long increment; 65 66 /* Get the exponent and mantissa encodings. */ 67 mantissa = a & (point - 1); 68 69 mask = (1 << fmt->exponent) - 1; 70 aexp = (a >> fmt->significand) & mask; 71 72 /* Infinity, NaN and alternative format special case. */ 73 if (((unsigned int) aexp) == mask) 74 { 75 if (!ieee) 76 return sign; 77 if (mantissa == 0) 78 return sign | 0x7c00; /* Infinity. */ 79 /* Remaining cases are NaNs. Convert SNaN to QNaN. */ 80 return sign | 0x7e00 | (mantissa >> (fmt->significand - 10)); 81 } 82 83 /* Zero. */ 84 if (aexp == 0 && mantissa == 0) 85 return sign; 86 87 /* Construct the exponent and mantissa. */ 88 aexp -= fmt->bias; 89 90 /* Decimal point is immediately after the significand. */ 91 mantissa |= point; 92 93 if (aexp < -14) 94 { 95 mask = point | (point - 1); 96 /* Minimum exponent for half-precision is 2^-24. */ 97 if (aexp >= -25) 98 mask >>= 25 + aexp; 99 } 100 else 101 mask = (point - 1) >> 10; 102 103 /* Round. */ 104 if (mantissa & mask) 105 { 106 increment = (mask + 1) >> 1; 107 if ((mantissa & mask) == increment) 108 increment = mantissa & (increment << 1); 109 mantissa += increment; 110 if (mantissa >= (point << 1)) 111 { 112 mantissa >>= 1; 113 aexp++; 114 } 115 } 116 117 if (ieee) 118 { 119 if (aexp > 15) 120 return sign | 0x7c00; 121 } 122 else 123 { 124 if (aexp > 16) 125 return sign | 0x7fff; 126 } 127 128 if (aexp < -24) 129 return sign; 130 131 if (aexp < -14) 132 { 133 mantissa >>= -14 - aexp; 134 aexp = -14; 135 } 136 137 /* Encode the final 16-bit floating-point value. 138 139 This is formed of the sign bit, the bias-adjusted exponent, and the 140 calculated mantissa, with the following caveats: 141 142 1. The mantissa calculated after rounding could have a leading 1. 143 To compensate for this, subtract one from the exponent bias (15) 144 before adding it to the calculated exponent. 145 2. When we were calculating rounding, we left the mantissa with the 146 number of bits of the source operand, it needs reduced to ten 147 bits (+1 for the afforementioned leading 1) by shifting right by 148 the number of bits in the source mantissa - 10. 149 3. To ensure the leading 1 in the mantissa is applied to the exponent 150 we need to add the mantissa rather than apply an arithmetic "or" 151 to it. */ 152 153 return sign | (((aexp + 14) << 10) + (mantissa >> (fmt->significand - 10))); 154 } 155 156 static inline unsigned short 157 __gnu_f2h_internal (unsigned int a, int ieee) 158 { 159 return __gnu_float2h_internal (&binary32, (unsigned long long) a, ieee); 160 } 161 162 static inline unsigned short 163 __gnu_d2h_internal (unsigned long long a, int ieee) 164 { 165 return __gnu_float2h_internal (&binary64, a, ieee); 166 } 167 168 unsigned int 169 __gnu_h2f_internal(unsigned short a, int ieee) 170 { 171 unsigned int sign = (unsigned int)(a & 0x8000) << 16; 172 int aexp = (a >> 10) & 0x1f; 173 unsigned int mantissa = a & 0x3ff; 174 175 if (aexp == 0x1f && ieee) 176 return sign | 0x7f800000 | (mantissa << 13); 177 178 if (aexp == 0) 179 { 180 int shift; 181 182 if (mantissa == 0) 183 return sign; 184 185 shift = __builtin_clz(mantissa) - 21; 186 mantissa <<= shift; 187 aexp = -shift; 188 } 189 190 return sign | (((aexp + 0x70) << 23) + (mantissa << 13)); 191 } 192 193 unsigned short 194 __gnu_f2h_ieee(unsigned int a) 195 { 196 return __gnu_f2h_internal(a, 1); 197 } 198 199 unsigned int 200 __gnu_h2f_ieee(unsigned short a) 201 { 202 return __gnu_h2f_internal(a, 1); 203 } 204 205 unsigned short 206 __gnu_f2h_alternative(unsigned int x) 207 { 208 return __gnu_f2h_internal(x, 0); 209 } 210 211 unsigned int 212 __gnu_h2f_alternative(unsigned short a) 213 { 214 return __gnu_h2f_internal(a, 0); 215 } 216 217 unsigned short 218 __gnu_d2h_ieee (unsigned long long a) 219 { 220 return __gnu_d2h_internal (a, 1); 221 } 222 223 unsigned short 224 __gnu_d2h_alternative (unsigned long long x) 225 { 226 return __gnu_d2h_internal (x, 0); 227 } 228