Mercurial > hg > CbC > CbC_gcc
annotate libiberty/floatformat.c @ 158:494b0b89df80 default tip
...
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 25 May 2020 18:13:55 +0900 |
| parents | 1830386684a0 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* IEEE floating point support routines, for GDB, the GNU Debugger. |
| 145 | 2 Copyright (C) 1991-2020 Free Software Foundation, Inc. |
| 0 | 3 |
| 4 This file is part of GDB. | |
| 5 | |
| 6 This program is free software; you can redistribute it and/or modify | |
| 7 it under the terms of the GNU General Public License as published by | |
| 8 the Free Software Foundation; either version 2 of the License, or | |
| 9 (at your option) any later version. | |
| 10 | |
| 11 This program is distributed in the hope that it will be useful, | |
| 12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 14 GNU General Public License for more details. | |
| 15 | |
| 16 You should have received a copy of the GNU General Public License | |
| 17 along with this program; if not, write to the Free Software | |
| 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ | |
| 19 | |
| 20 /* This is needed to pick up the NAN macro on some systems. */ | |
| 111 | 21 #ifndef _GNU_SOURCE |
| 0 | 22 #define _GNU_SOURCE |
| 111 | 23 #endif |
| 0 | 24 |
| 25 #ifdef HAVE_CONFIG_H | |
| 26 #include "config.h" | |
| 27 #endif | |
| 28 | |
| 29 #include <math.h> | |
| 30 | |
| 31 #ifdef HAVE_STRING_H | |
| 32 #include <string.h> | |
| 33 #endif | |
| 34 | |
| 35 /* On some platforms, <float.h> provides DBL_QNAN. */ | |
| 36 #ifdef STDC_HEADERS | |
| 37 #include <float.h> | |
| 38 #endif | |
| 39 | |
| 40 #include "ansidecl.h" | |
| 41 #include "libiberty.h" | |
| 42 #include "floatformat.h" | |
| 43 | |
| 44 #ifndef INFINITY | |
| 45 #ifdef HUGE_VAL | |
| 46 #define INFINITY HUGE_VAL | |
| 47 #else | |
| 48 #define INFINITY (1.0 / 0.0) | |
| 49 #endif | |
| 50 #endif | |
| 51 | |
| 52 #ifndef NAN | |
| 53 #ifdef DBL_QNAN | |
| 54 #define NAN DBL_QNAN | |
| 55 #else | |
| 56 #define NAN (0.0 / 0.0) | |
| 57 #endif | |
| 58 #endif | |
| 59 | |
| 60 static int mant_bits_set (const struct floatformat *, const unsigned char *); | |
| 61 static unsigned long get_field (const unsigned char *, | |
| 62 enum floatformat_byteorders, | |
| 63 unsigned int, | |
| 64 unsigned int, | |
| 65 unsigned int); | |
| 66 static int floatformat_always_valid (const struct floatformat *fmt, | |
| 67 const void *from); | |
| 68 | |
| 69 static int | |
| 70 floatformat_always_valid (const struct floatformat *fmt ATTRIBUTE_UNUSED, | |
| 71 const void *from ATTRIBUTE_UNUSED) | |
| 72 { | |
| 73 return 1; | |
| 74 } | |
| 75 | |
| 76 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not | |
| 77 going to bother with trying to muck around with whether it is defined in | |
| 78 a system header, what we do if not, etc. */ | |
| 79 #define FLOATFORMAT_CHAR_BIT 8 | |
| 80 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
81 /* floatformats for IEEE half, single and double, big and little endian. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
82 const struct floatformat floatformat_ieee_half_big = |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
83 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
84 floatformat_big, 16, 0, 1, 5, 15, 31, 6, 10, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
85 floatformat_intbit_no, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
86 "floatformat_ieee_half_big", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
87 floatformat_always_valid, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
88 NULL |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
89 }; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
90 const struct floatformat floatformat_ieee_half_little = |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
91 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
92 floatformat_little, 16, 0, 1, 5, 15, 31, 6, 10, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
93 floatformat_intbit_no, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
94 "floatformat_ieee_half_little", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
95 floatformat_always_valid, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
96 NULL |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
97 }; |
| 0 | 98 const struct floatformat floatformat_ieee_single_big = |
| 99 { | |
| 100 floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23, | |
| 101 floatformat_intbit_no, | |
| 102 "floatformat_ieee_single_big", | |
| 103 floatformat_always_valid, | |
| 104 NULL | |
| 105 }; | |
| 106 const struct floatformat floatformat_ieee_single_little = | |
| 107 { | |
| 108 floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23, | |
| 109 floatformat_intbit_no, | |
| 110 "floatformat_ieee_single_little", | |
| 111 floatformat_always_valid, | |
| 112 NULL | |
| 113 }; | |
| 114 const struct floatformat floatformat_ieee_double_big = | |
| 115 { | |
| 116 floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52, | |
| 117 floatformat_intbit_no, | |
| 118 "floatformat_ieee_double_big", | |
| 119 floatformat_always_valid, | |
| 120 NULL | |
| 121 }; | |
| 122 const struct floatformat floatformat_ieee_double_little = | |
| 123 { | |
| 124 floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52, | |
| 125 floatformat_intbit_no, | |
| 126 "floatformat_ieee_double_little", | |
| 127 floatformat_always_valid, | |
| 128 NULL | |
| 129 }; | |
| 130 | |
| 131 /* floatformat for IEEE double, little endian byte order, with big endian word | |
| 132 ordering, as on the ARM. */ | |
| 133 | |
| 134 const struct floatformat floatformat_ieee_double_littlebyte_bigword = | |
| 135 { | |
| 136 floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52, | |
| 137 floatformat_intbit_no, | |
| 138 "floatformat_ieee_double_littlebyte_bigword", | |
| 139 floatformat_always_valid, | |
| 140 NULL | |
| 141 }; | |
| 142 | |
| 143 /* floatformat for VAX. Not quite IEEE, but close enough. */ | |
| 144 | |
| 145 const struct floatformat floatformat_vax_f = | |
| 146 { | |
| 147 floatformat_vax, 32, 0, 1, 8, 129, 0, 9, 23, | |
| 148 floatformat_intbit_no, | |
| 149 "floatformat_vax_f", | |
| 150 floatformat_always_valid, | |
| 151 NULL | |
| 152 }; | |
| 153 const struct floatformat floatformat_vax_d = | |
| 154 { | |
| 155 floatformat_vax, 64, 0, 1, 8, 129, 0, 9, 55, | |
| 156 floatformat_intbit_no, | |
| 157 "floatformat_vax_d", | |
| 158 floatformat_always_valid, | |
| 159 NULL | |
| 160 }; | |
| 161 const struct floatformat floatformat_vax_g = | |
| 162 { | |
| 163 floatformat_vax, 64, 0, 1, 11, 1025, 0, 12, 52, | |
| 164 floatformat_intbit_no, | |
| 165 "floatformat_vax_g", | |
| 166 floatformat_always_valid, | |
| 167 NULL | |
| 168 }; | |
| 169 | |
| 170 static int floatformat_i387_ext_is_valid (const struct floatformat *fmt, | |
| 171 const void *from); | |
| 172 | |
| 173 static int | |
| 174 floatformat_i387_ext_is_valid (const struct floatformat *fmt, const void *from) | |
| 175 { | |
| 176 /* In the i387 double-extended format, if the exponent is all ones, | |
| 177 then the integer bit must be set. If the exponent is neither 0 | |
| 178 nor ~0, the intbit must also be set. Only if the exponent is | |
| 179 zero can it be zero, and then it must be zero. */ | |
| 180 unsigned long exponent, int_bit; | |
| 181 const unsigned char *ufrom = (const unsigned char *) from; | |
| 182 | |
| 183 exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize, | |
| 184 fmt->exp_start, fmt->exp_len); | |
| 185 int_bit = get_field (ufrom, fmt->byteorder, fmt->totalsize, | |
| 186 fmt->man_start, 1); | |
| 187 | |
| 188 if ((exponent == 0) != (int_bit == 0)) | |
| 189 return 0; | |
| 190 else | |
| 191 return 1; | |
| 192 } | |
| 193 | |
| 194 const struct floatformat floatformat_i387_ext = | |
| 195 { | |
| 196 floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64, | |
| 197 floatformat_intbit_yes, | |
| 198 "floatformat_i387_ext", | |
| 199 floatformat_i387_ext_is_valid, | |
| 200 NULL | |
| 201 }; | |
| 202 const struct floatformat floatformat_m68881_ext = | |
| 203 { | |
| 204 /* Note that the bits from 16 to 31 are unused. */ | |
| 205 floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64, | |
| 206 floatformat_intbit_yes, | |
| 207 "floatformat_m68881_ext", | |
| 208 floatformat_always_valid, | |
| 209 NULL | |
| 210 }; | |
| 211 const struct floatformat floatformat_i960_ext = | |
| 212 { | |
| 213 /* Note that the bits from 0 to 15 are unused. */ | |
| 214 floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64, | |
| 215 floatformat_intbit_yes, | |
| 216 "floatformat_i960_ext", | |
| 217 floatformat_always_valid, | |
| 218 NULL | |
| 219 }; | |
| 220 const struct floatformat floatformat_m88110_ext = | |
| 221 { | |
| 222 floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64, | |
| 223 floatformat_intbit_yes, | |
| 224 "floatformat_m88110_ext", | |
| 225 floatformat_always_valid, | |
| 226 NULL | |
| 227 }; | |
| 228 const struct floatformat floatformat_m88110_harris_ext = | |
| 229 { | |
| 230 /* Harris uses raw format 128 bytes long, but the number is just an ieee | |
| 231 double, and the last 64 bits are wasted. */ | |
| 232 floatformat_big,128, 0, 1, 11, 0x3ff, 0x7ff, 12, 52, | |
| 233 floatformat_intbit_no, | |
| 234 "floatformat_m88110_ext_harris", | |
| 235 floatformat_always_valid, | |
| 236 NULL | |
| 237 }; | |
| 238 const struct floatformat floatformat_arm_ext_big = | |
| 239 { | |
| 240 /* Bits 1 to 16 are unused. */ | |
| 241 floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64, | |
| 242 floatformat_intbit_yes, | |
| 243 "floatformat_arm_ext_big", | |
| 244 floatformat_always_valid, | |
| 245 NULL | |
| 246 }; | |
| 247 const struct floatformat floatformat_arm_ext_littlebyte_bigword = | |
| 248 { | |
| 249 /* Bits 1 to 16 are unused. */ | |
| 250 floatformat_littlebyte_bigword, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64, | |
| 251 floatformat_intbit_yes, | |
| 252 "floatformat_arm_ext_littlebyte_bigword", | |
| 253 floatformat_always_valid, | |
| 254 NULL | |
| 255 }; | |
| 256 const struct floatformat floatformat_ia64_spill_big = | |
| 257 { | |
| 258 floatformat_big, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64, | |
| 259 floatformat_intbit_yes, | |
| 260 "floatformat_ia64_spill_big", | |
| 261 floatformat_always_valid, | |
| 262 NULL | |
| 263 }; | |
| 264 const struct floatformat floatformat_ia64_spill_little = | |
| 265 { | |
| 266 floatformat_little, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64, | |
| 267 floatformat_intbit_yes, | |
| 268 "floatformat_ia64_spill_little", | |
| 269 floatformat_always_valid, | |
| 270 NULL | |
| 271 }; | |
| 272 const struct floatformat floatformat_ia64_quad_big = | |
| 273 { | |
| 274 floatformat_big, 128, 0, 1, 15, 16383, 0x7fff, 16, 112, | |
| 275 floatformat_intbit_no, | |
| 276 "floatformat_ia64_quad_big", | |
| 277 floatformat_always_valid, | |
| 278 NULL | |
| 279 }; | |
| 280 const struct floatformat floatformat_ia64_quad_little = | |
| 281 { | |
| 282 floatformat_little, 128, 0, 1, 15, 16383, 0x7fff, 16, 112, | |
| 283 floatformat_intbit_no, | |
| 284 "floatformat_ia64_quad_little", | |
| 285 floatformat_always_valid, | |
| 286 NULL | |
| 287 }; | |
| 288 | |
| 289 static int | |
| 290 floatformat_ibm_long_double_is_valid (const struct floatformat *fmt, | |
| 291 const void *from) | |
| 292 { | |
| 293 const unsigned char *ufrom = (const unsigned char *) from; | |
| 294 const struct floatformat *hfmt = fmt->split_half; | |
| 295 long top_exp, bot_exp; | |
| 296 int top_nan = 0; | |
| 297 | |
| 298 top_exp = get_field (ufrom, hfmt->byteorder, hfmt->totalsize, | |
| 299 hfmt->exp_start, hfmt->exp_len); | |
| 300 bot_exp = get_field (ufrom + 8, hfmt->byteorder, hfmt->totalsize, | |
| 301 hfmt->exp_start, hfmt->exp_len); | |
| 302 | |
| 303 if ((unsigned long) top_exp == hfmt->exp_nan) | |
| 304 top_nan = mant_bits_set (hfmt, ufrom); | |
| 305 | |
| 306 /* A NaN is valid with any low part. */ | |
| 307 if (top_nan) | |
| 308 return 1; | |
| 309 | |
| 310 /* An infinity, zero or denormal requires low part 0 (positive or | |
| 311 negative). */ | |
| 312 if ((unsigned long) top_exp == hfmt->exp_nan || top_exp == 0) | |
| 313 { | |
| 314 if (bot_exp != 0) | |
| 315 return 0; | |
| 316 | |
| 317 return !mant_bits_set (hfmt, ufrom + 8); | |
| 318 } | |
| 319 | |
| 320 /* The top part is now a finite normal value. The long double value | |
| 321 is the sum of the two parts, and the top part must equal the | |
| 322 result of rounding the long double value to nearest double. Thus | |
| 323 the bottom part must be <= 0.5ulp of the top part in absolute | |
| 324 value, and if it is < 0.5ulp then the long double is definitely | |
| 325 valid. */ | |
| 326 if (bot_exp < top_exp - 53) | |
| 327 return 1; | |
| 328 if (bot_exp > top_exp - 53 && bot_exp != 0) | |
| 329 return 0; | |
| 330 if (bot_exp == 0) | |
| 331 { | |
| 332 /* The bottom part is 0 or denormal. Determine which, and if | |
| 333 denormal the first two set bits. */ | |
| 334 int first_bit = -1, second_bit = -1, cur_bit; | |
| 335 for (cur_bit = 0; (unsigned int) cur_bit < hfmt->man_len; cur_bit++) | |
| 336 if (get_field (ufrom + 8, hfmt->byteorder, hfmt->totalsize, | |
| 337 hfmt->man_start + cur_bit, 1)) | |
| 338 { | |
| 339 if (first_bit == -1) | |
| 340 first_bit = cur_bit; | |
| 341 else | |
| 342 { | |
| 343 second_bit = cur_bit; | |
| 344 break; | |
| 345 } | |
| 346 } | |
| 347 /* Bottom part 0 is OK. */ | |
| 348 if (first_bit == -1) | |
| 349 return 1; | |
| 350 /* The real exponent of the bottom part is -first_bit. */ | |
| 351 if (-first_bit < top_exp - 53) | |
| 352 return 1; | |
| 353 if (-first_bit > top_exp - 53) | |
| 354 return 0; | |
| 355 /* The bottom part is at least 0.5ulp of the top part. For this | |
| 356 to be OK, the bottom part must be exactly 0.5ulp (i.e. no | |
| 357 more bits set) and the top part must have last bit 0. */ | |
| 358 if (second_bit != -1) | |
| 359 return 0; | |
| 360 return !get_field (ufrom, hfmt->byteorder, hfmt->totalsize, | |
| 361 hfmt->man_start + hfmt->man_len - 1, 1); | |
| 362 } | |
| 363 else | |
| 364 { | |
| 365 /* The bottom part is at least 0.5ulp of the top part. For this | |
| 366 to be OK, it must be exactly 0.5ulp (i.e. no explicit bits | |
| 367 set) and the top part must have last bit 0. */ | |
| 368 if (get_field (ufrom, hfmt->byteorder, hfmt->totalsize, | |
| 369 hfmt->man_start + hfmt->man_len - 1, 1)) | |
| 370 return 0; | |
| 371 return !mant_bits_set (hfmt, ufrom + 8); | |
| 372 } | |
| 373 } | |
| 374 | |
| 111 | 375 const struct floatformat floatformat_ibm_long_double_big = |
| 0 | 376 { |
| 377 floatformat_big, 128, 0, 1, 11, 1023, 2047, 12, 52, | |
| 378 floatformat_intbit_no, | |
| 111 | 379 "floatformat_ibm_long_double_big", |
| 0 | 380 floatformat_ibm_long_double_is_valid, |
| 381 &floatformat_ieee_double_big | |
| 382 }; | |
| 111 | 383 |
| 384 const struct floatformat floatformat_ibm_long_double_little = | |
| 385 { | |
| 386 floatformat_little, 128, 0, 1, 11, 1023, 2047, 12, 52, | |
| 387 floatformat_intbit_no, | |
| 388 "floatformat_ibm_long_double_little", | |
| 389 floatformat_ibm_long_double_is_valid, | |
| 390 &floatformat_ieee_double_little | |
| 391 }; | |
| 0 | 392 |
| 393 | |
| 394 #ifndef min | |
| 395 #define min(a, b) ((a) < (b) ? (a) : (b)) | |
| 396 #endif | |
| 397 | |
| 398 /* Return 1 if any bits are explicitly set in the mantissa of UFROM, | |
| 399 format FMT, 0 otherwise. */ | |
| 400 static int | |
| 401 mant_bits_set (const struct floatformat *fmt, const unsigned char *ufrom) | |
| 402 { | |
| 403 unsigned int mant_bits, mant_off; | |
| 404 int mant_bits_left; | |
| 405 | |
| 406 mant_off = fmt->man_start; | |
| 407 mant_bits_left = fmt->man_len; | |
| 408 while (mant_bits_left > 0) | |
| 409 { | |
| 410 mant_bits = min (mant_bits_left, 32); | |
| 411 | |
| 412 if (get_field (ufrom, fmt->byteorder, fmt->totalsize, | |
| 413 mant_off, mant_bits) != 0) | |
| 414 return 1; | |
| 415 | |
| 416 mant_off += mant_bits; | |
| 417 mant_bits_left -= mant_bits; | |
| 418 } | |
| 419 return 0; | |
| 420 } | |
| 421 | |
| 422 /* Extract a field which starts at START and is LEN bits long. DATA and | |
| 423 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ | |
| 424 static unsigned long | |
| 425 get_field (const unsigned char *data, enum floatformat_byteorders order, | |
| 426 unsigned int total_len, unsigned int start, unsigned int len) | |
| 427 { | |
| 428 unsigned long result = 0; | |
| 429 unsigned int cur_byte; | |
| 430 int lo_bit, hi_bit, cur_bitshift = 0; | |
| 431 int nextbyte = (order == floatformat_little) ? 1 : -1; | |
| 432 | |
| 433 /* Start is in big-endian bit order! Fix that first. */ | |
| 434 start = total_len - (start + len); | |
| 435 | |
| 436 /* Start at the least significant part of the field. */ | |
| 437 if (order == floatformat_little) | |
| 438 cur_byte = start / FLOATFORMAT_CHAR_BIT; | |
| 439 else | |
| 440 cur_byte = (total_len - start - 1) / FLOATFORMAT_CHAR_BIT; | |
| 441 | |
| 442 lo_bit = start % FLOATFORMAT_CHAR_BIT; | |
| 443 hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT); | |
| 444 | |
| 445 do | |
| 446 { | |
| 447 unsigned int shifted = *(data + cur_byte) >> lo_bit; | |
| 448 unsigned int bits = hi_bit - lo_bit; | |
| 449 unsigned int mask = (1 << bits) - 1; | |
| 450 result |= (shifted & mask) << cur_bitshift; | |
| 451 len -= bits; | |
| 452 cur_bitshift += bits; | |
| 453 cur_byte += nextbyte; | |
| 454 lo_bit = 0; | |
| 455 hi_bit = min (len, FLOATFORMAT_CHAR_BIT); | |
| 456 } | |
| 457 while (len != 0); | |
| 458 | |
| 459 return result; | |
| 460 } | |
| 461 | |
| 462 /* Convert from FMT to a double. | |
| 463 FROM is the address of the extended float. | |
| 464 Store the double in *TO. */ | |
| 465 | |
| 466 void | |
| 467 floatformat_to_double (const struct floatformat *fmt, | |
| 468 const void *from, double *to) | |
| 469 { | |
| 470 const unsigned char *ufrom = (const unsigned char *) from; | |
| 471 double dto; | |
| 472 long exponent; | |
| 473 unsigned long mant; | |
| 474 unsigned int mant_bits, mant_off; | |
| 475 int mant_bits_left; | |
| 476 | |
| 477 /* Split values are not handled specially, since the top half has | |
| 478 the correctly rounded double value (in the only supported case of | |
| 479 split values). */ | |
| 480 | |
| 481 exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize, | |
| 482 fmt->exp_start, fmt->exp_len); | |
| 483 | |
| 484 /* If the exponent indicates a NaN, we don't have information to | |
| 485 decide what to do. So we handle it like IEEE, except that we | |
| 486 don't try to preserve the type of NaN. FIXME. */ | |
| 487 if ((unsigned long) exponent == fmt->exp_nan) | |
| 488 { | |
| 489 int nan = mant_bits_set (fmt, ufrom); | |
| 490 | |
| 491 /* On certain systems (such as GNU/Linux), the use of the | |
| 145 | 492 INFINITY macro below may generate a warning that cannot be |
| 0 | 493 silenced due to a bug in GCC (PR preprocessor/11931). The |
| 494 preprocessor fails to recognise the __extension__ keyword in | |
| 495 conjunction with the GNU/C99 extension for hexadecimal | |
| 496 floating point constants and will issue a warning when | |
| 497 compiling with -pedantic. */ | |
| 498 if (nan) | |
| 499 dto = NAN; | |
| 500 else | |
| 501 dto = INFINITY; | |
| 502 | |
| 503 if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1)) | |
| 504 dto = -dto; | |
| 505 | |
| 506 *to = dto; | |
| 507 | |
| 508 return; | |
| 509 } | |
| 510 | |
| 511 mant_bits_left = fmt->man_len; | |
| 512 mant_off = fmt->man_start; | |
| 513 dto = 0.0; | |
| 514 | |
| 515 /* Build the result algebraically. Might go infinite, underflow, etc; | |
| 516 who cares. */ | |
| 517 | |
| 111 | 518 /* For denorms use minimum exponent. */ |
| 519 if (exponent == 0) | |
| 520 exponent = 1 - fmt->exp_bias; | |
| 521 else | |
| 522 { | |
| 523 exponent -= fmt->exp_bias; | |
| 0 | 524 |
| 111 | 525 /* If this format uses a hidden bit, explicitly add it in now. |
| 526 Otherwise, increment the exponent by one to account for the | |
| 527 integer bit. */ | |
| 528 | |
| 0 | 529 if (fmt->intbit == floatformat_intbit_no) |
| 530 dto = ldexp (1.0, exponent); | |
| 531 else | |
| 532 exponent++; | |
| 533 } | |
| 534 | |
| 535 while (mant_bits_left > 0) | |
| 536 { | |
| 537 mant_bits = min (mant_bits_left, 32); | |
| 538 | |
| 539 mant = get_field (ufrom, fmt->byteorder, fmt->totalsize, | |
| 540 mant_off, mant_bits); | |
| 541 | |
| 111 | 542 dto += ldexp ((double) mant, exponent - mant_bits); |
| 543 exponent -= mant_bits; | |
| 0 | 544 mant_off += mant_bits; |
| 545 mant_bits_left -= mant_bits; | |
| 546 } | |
| 547 | |
| 548 /* Negate it if negative. */ | |
| 549 if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1)) | |
| 550 dto = -dto; | |
| 551 *to = dto; | |
| 552 } | |
| 553 | |
| 554 static void put_field (unsigned char *, enum floatformat_byteorders, | |
| 555 unsigned int, | |
| 556 unsigned int, | |
| 557 unsigned int, | |
| 558 unsigned long); | |
| 559 | |
| 560 /* Set a field which starts at START and is LEN bits long. DATA and | |
| 561 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ | |
| 562 static void | |
| 563 put_field (unsigned char *data, enum floatformat_byteorders order, | |
| 564 unsigned int total_len, unsigned int start, unsigned int len, | |
| 565 unsigned long stuff_to_put) | |
| 566 { | |
| 567 unsigned int cur_byte; | |
| 568 int lo_bit, hi_bit; | |
| 569 int nextbyte = (order == floatformat_little) ? 1 : -1; | |
| 570 | |
| 571 /* Start is in big-endian bit order! Fix that first. */ | |
| 572 start = total_len - (start + len); | |
| 573 | |
| 574 /* Start at the least significant part of the field. */ | |
| 575 if (order == floatformat_little) | |
| 576 cur_byte = start / FLOATFORMAT_CHAR_BIT; | |
| 577 else | |
| 578 cur_byte = (total_len - start - 1) / FLOATFORMAT_CHAR_BIT; | |
| 579 | |
| 580 lo_bit = start % FLOATFORMAT_CHAR_BIT; | |
| 581 hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT); | |
| 582 | |
| 583 do | |
| 584 { | |
| 585 unsigned char *byte_ptr = data + cur_byte; | |
| 586 unsigned int bits = hi_bit - lo_bit; | |
| 587 unsigned int mask = ((1 << bits) - 1) << lo_bit; | |
| 588 *byte_ptr = (*byte_ptr & ~mask) | ((stuff_to_put << lo_bit) & mask); | |
| 589 stuff_to_put >>= bits; | |
| 590 len -= bits; | |
| 591 cur_byte += nextbyte; | |
| 592 lo_bit = 0; | |
| 593 hi_bit = min (len, FLOATFORMAT_CHAR_BIT); | |
| 594 } | |
| 595 while (len != 0); | |
| 596 } | |
| 597 | |
| 598 /* The converse: convert the double *FROM to an extended float | |
| 599 and store where TO points. Neither FROM nor TO have any alignment | |
| 600 restrictions. */ | |
| 601 | |
| 602 void | |
| 603 floatformat_from_double (const struct floatformat *fmt, | |
| 604 const double *from, void *to) | |
| 605 { | |
| 606 double dfrom; | |
| 607 int exponent; | |
| 608 double mant; | |
| 609 unsigned int mant_bits, mant_off; | |
| 610 int mant_bits_left; | |
| 611 unsigned char *uto = (unsigned char *) to; | |
| 612 | |
| 613 dfrom = *from; | |
| 614 memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT); | |
| 615 | |
| 616 /* Split values are not handled specially, since a bottom half of | |
| 617 zero is correct for any value representable as double (in the | |
| 618 only supported case of split values). */ | |
| 619 | |
| 620 /* If negative, set the sign bit. */ | |
| 621 if (dfrom < 0) | |
| 622 { | |
| 623 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1); | |
| 624 dfrom = -dfrom; | |
| 625 } | |
| 626 | |
| 627 if (dfrom == 0) | |
| 628 { | |
| 629 /* 0.0. */ | |
| 630 return; | |
| 631 } | |
| 632 | |
| 633 if (dfrom != dfrom) | |
| 634 { | |
| 635 /* NaN. */ | |
| 636 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, | |
| 637 fmt->exp_len, fmt->exp_nan); | |
| 638 /* Be sure it's not infinity, but NaN value is irrelevant. */ | |
| 639 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start, | |
| 640 32, 1); | |
| 641 return; | |
| 642 } | |
| 643 | |
| 644 if (dfrom + dfrom == dfrom) | |
| 645 { | |
| 646 /* This can only happen for an infinite value (or zero, which we | |
| 647 already handled above). */ | |
| 648 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, | |
| 649 fmt->exp_len, fmt->exp_nan); | |
| 650 return; | |
| 651 } | |
| 652 | |
| 653 mant = frexp (dfrom, &exponent); | |
| 654 if (exponent + fmt->exp_bias - 1 > 0) | |
| 655 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, | |
| 656 fmt->exp_len, exponent + fmt->exp_bias - 1); | |
| 657 else | |
| 658 { | |
| 659 /* Handle a denormalized number. FIXME: What should we do for | |
| 660 non-IEEE formats? */ | |
| 661 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, | |
| 662 fmt->exp_len, 0); | |
| 663 mant = ldexp (mant, exponent + fmt->exp_bias - 1); | |
| 664 } | |
| 665 | |
| 666 mant_bits_left = fmt->man_len; | |
| 667 mant_off = fmt->man_start; | |
| 668 while (mant_bits_left > 0) | |
| 669 { | |
| 670 unsigned long mant_long; | |
| 671 mant_bits = mant_bits_left < 32 ? mant_bits_left : 32; | |
| 672 | |
| 673 mant *= 4294967296.0; | |
| 674 mant_long = (unsigned long)mant; | |
| 675 mant -= mant_long; | |
| 676 | |
| 677 /* If the integer bit is implicit, and we are not creating a | |
| 678 denormalized number, then we need to discard it. */ | |
| 679 if ((unsigned int) mant_bits_left == fmt->man_len | |
| 680 && fmt->intbit == floatformat_intbit_no | |
| 681 && exponent + fmt->exp_bias - 1 > 0) | |
| 682 { | |
| 683 mant_long &= 0x7fffffff; | |
| 684 mant_bits -= 1; | |
| 685 } | |
| 686 else if (mant_bits < 32) | |
| 687 { | |
| 688 /* The bits we want are in the most significant MANT_BITS bits of | |
| 689 mant_long. Move them to the least significant. */ | |
| 690 mant_long >>= 32 - mant_bits; | |
| 691 } | |
| 692 | |
| 693 put_field (uto, fmt->byteorder, fmt->totalsize, | |
| 694 mant_off, mant_bits, mant_long); | |
| 695 mant_off += mant_bits; | |
| 696 mant_bits_left -= mant_bits; | |
| 697 } | |
| 698 } | |
| 699 | |
| 700 /* Return non-zero iff the data at FROM is a valid number in format FMT. */ | |
| 701 | |
| 702 int | |
| 703 floatformat_is_valid (const struct floatformat *fmt, const void *from) | |
| 704 { | |
| 705 return fmt->is_valid (fmt, from); | |
| 706 } | |
| 707 | |
| 708 | |
| 709 #ifdef IEEE_DEBUG | |
| 710 | |
| 711 #include <stdio.h> | |
| 712 | |
| 713 /* This is to be run on a host which uses IEEE floating point. */ | |
| 714 | |
| 715 void | |
| 716 ieee_test (double n) | |
| 717 { | |
| 718 double result; | |
| 719 | |
| 720 floatformat_to_double (&floatformat_ieee_double_little, &n, &result); | |
| 721 if ((n != result && (! isnan (n) || ! isnan (result))) | |
| 722 || (n < 0 && result >= 0) | |
| 723 || (n >= 0 && result < 0)) | |
| 724 printf ("Differ(to): %.20g -> %.20g\n", n, result); | |
| 725 | |
| 726 floatformat_from_double (&floatformat_ieee_double_little, &n, &result); | |
| 727 if ((n != result && (! isnan (n) || ! isnan (result))) | |
| 728 || (n < 0 && result >= 0) | |
| 729 || (n >= 0 && result < 0)) | |
| 730 printf ("Differ(from): %.20g -> %.20g\n", n, result); | |
| 731 | |
| 732 #if 0 | |
| 733 { | |
| 734 char exten[16]; | |
| 735 | |
| 736 floatformat_from_double (&floatformat_m68881_ext, &n, exten); | |
| 737 floatformat_to_double (&floatformat_m68881_ext, exten, &result); | |
| 738 if (n != result) | |
| 739 printf ("Differ(to+from): %.20g -> %.20g\n", n, result); | |
| 740 } | |
| 741 #endif | |
| 742 | |
| 743 #if IEEE_DEBUG > 1 | |
| 744 /* This is to be run on a host which uses 68881 format. */ | |
| 745 { | |
| 746 long double ex = *(long double *)exten; | |
| 747 if (ex != n) | |
| 748 printf ("Differ(from vs. extended): %.20g\n", n); | |
| 749 } | |
| 750 #endif | |
| 751 } | |
| 752 | |
| 753 int | |
| 754 main (void) | |
| 755 { | |
| 756 ieee_test (0.0); | |
| 757 ieee_test (0.5); | |
| 111 | 758 ieee_test (1.1); |
| 0 | 759 ieee_test (256.0); |
| 760 ieee_test (0.12345); | |
| 761 ieee_test (234235.78907234); | |
| 762 ieee_test (-512.0); | |
| 763 ieee_test (-0.004321); | |
| 764 ieee_test (1.2E-70); | |
| 765 ieee_test (1.2E-316); | |
| 766 ieee_test (4.9406564584124654E-324); | |
| 767 ieee_test (- 4.9406564584124654E-324); | |
| 768 ieee_test (- 0.0); | |
| 769 ieee_test (- INFINITY); | |
| 770 ieee_test (- NAN); | |
| 771 ieee_test (INFINITY); | |
| 772 ieee_test (NAN); | |
| 773 return 0; | |
| 774 } | |
| 775 #endif |