1 /* Software floating-point emulation. Common operations. 2 Copyright (C) 1997,1998,1999 Free Software Foundation, Inc. 3 This file is part of the GNU C Library. 4 Contributed by Richard Henderson (rth@cygnus.com), 5 Jakub Jelinek (jj@ultra.linux.cz), 6 David S. Miller (davem@redhat.com) and 7 Peter Maydell (pmaydell@chiark.greenend.org.uk). 8 9 The GNU C Library is free software; you can redistribute it and/or 10 modify it under the terms of the GNU Library General Public License as 11 published by the Free Software Foundation; either version 2 of the 12 License, or (at your option) any later version. 13 14 The GNU C Library is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 Library General Public License for more details. 18 19 You should have received a copy of the GNU Library General Public 20 License along with the GNU C Library; see the file COPYING.LIB. If 21 not, write to the Free Software Foundation, Inc., 22 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 23 24 #ifndef __MATH_EMU_OP_COMMON_H__ 25 #define __MATH_EMU_OP_COMMON_H__ 26 27 #define _FP_DECL(wc, X) \ 28 _FP_I_TYPE X##_c=0, X##_s=0, X##_e=0; \ 29 _FP_FRAC_DECL_##wc(X) 30 31 /* 32 * Finish truely unpacking a native fp value by classifying the kind 33 * of fp value and normalizing both the exponent and the fraction. 34 */ 35 36 #define _FP_UNPACK_CANONICAL(fs, wc, X) \ 37 do { \ 38 switch (X##_e) \ 39 { \ 40 default: \ 41 _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_IMPLBIT_##fs; \ 42 _FP_FRAC_SLL_##wc(X, _FP_WORKBITS); \ 43 X##_e -= _FP_EXPBIAS_##fs; \ 44 X##_c = FP_CLS_NORMAL; \ 45 break; \ 46 \ 47 case 0: \ 48 if (_FP_FRAC_ZEROP_##wc(X)) \ 49 X##_c = FP_CLS_ZERO; \ 50 else \ 51 { \ 52 /* a denormalized number */ \ 53 _FP_I_TYPE _shift; \ 54 _FP_FRAC_CLZ_##wc(_shift, X); \ 55 _shift -= _FP_FRACXBITS_##fs; \ 56 _FP_FRAC_SLL_##wc(X, (_shift+_FP_WORKBITS)); \ 57 X##_e -= _FP_EXPBIAS_##fs - 1 + _shift; \ 58 X##_c = FP_CLS_NORMAL; \ 59 FP_SET_EXCEPTION(FP_EX_DENORM); \ 60 if (FP_DENORM_ZERO) \ 61 { \ 62 FP_SET_EXCEPTION(FP_EX_INEXACT); \ 63 X##_c = FP_CLS_ZERO; \ 64 } \ 65 } \ 66 break; \ 67 \ 68 case _FP_EXPMAX_##fs: \ 69 if (_FP_FRAC_ZEROP_##wc(X)) \ 70 X##_c = FP_CLS_INF; \ 71 else \ 72 { \ 73 X##_c = FP_CLS_NAN; \ 74 /* Check for signaling NaN */ \ 75 if (!(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs)) \ 76 FP_SET_EXCEPTION(FP_EX_INVALID); \ 77 } \ 78 break; \ 79 } \ 80 } while (0) 81 82 /* 83 * Before packing the bits back into the native fp result, take care 84 * of such mundane things as rounding and overflow. Also, for some 85 * kinds of fp values, the original parts may not have been fully 86 * extracted -- but that is ok, we can regenerate them now. 87 */ 88 89 #define _FP_PACK_CANONICAL(fs, wc, X) \ 90 do { \ 91 switch (X##_c) \ 92 { \ 93 case FP_CLS_NORMAL: \ 94 X##_e += _FP_EXPBIAS_##fs; \ 95 if (X##_e > 0) \ 96 { \ 97 _FP_ROUND(wc, X); \ 98 if (_FP_FRAC_OVERP_##wc(fs, X)) \ 99 { \ 100 _FP_FRAC_CLEAR_OVERP_##wc(fs, X); \ 101 X##_e++; \ 102 } \ 103 _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \ 104 if (X##_e >= _FP_EXPMAX_##fs) \ 105 { \ 106 /* overflow */ \ 107 switch (FP_ROUNDMODE) \ 108 { \ 109 case FP_RND_NEAREST: \ 110 X##_c = FP_CLS_INF; \ 111 break; \ 112 case FP_RND_PINF: \ 113 if (!X##_s) X##_c = FP_CLS_INF; \ 114 break; \ 115 case FP_RND_MINF: \ 116 if (X##_s) X##_c = FP_CLS_INF; \ 117 break; \ 118 } \ 119 if (X##_c == FP_CLS_INF) \ 120 { \ 121 /* Overflow to infinity */ \ 122 X##_e = _FP_EXPMAX_##fs; \ 123 _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \ 124 } \ 125 else \ 126 { \ 127 /* Overflow to maximum normal */ \ 128 X##_e = _FP_EXPMAX_##fs - 1; \ 129 _FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc); \ 130 } \ 131 FP_SET_EXCEPTION(FP_EX_OVERFLOW); \ 132 FP_SET_EXCEPTION(FP_EX_INEXACT); \ 133 } \ 134 } \ 135 else \ 136 { \ 137 /* we've got a denormalized number */ \ 138 X##_e = -X##_e + 1; \ 139 if (X##_e <= _FP_WFRACBITS_##fs) \ 140 { \ 141 _FP_FRAC_SRS_##wc(X, X##_e, _FP_WFRACBITS_##fs); \ 142 _FP_ROUND(wc, X); \ 143 if (_FP_FRAC_HIGH_##fs(X) \ 144 & (_FP_OVERFLOW_##fs >> 1)) \ 145 { \ 146 X##_e = 1; \ 147 _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \ 148 } \ 149 else \ 150 { \ 151 X##_e = 0; \ 152 _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \ 153 FP_SET_EXCEPTION(FP_EX_UNDERFLOW); \ 154 } \ 155 } \ 156 else \ 157 { \ 158 /* underflow to zero */ \ 159 X##_e = 0; \ 160 if (!_FP_FRAC_ZEROP_##wc(X)) \ 161 { \ 162 _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc); \ 163 _FP_ROUND(wc, X); \ 164 _FP_FRAC_LOW_##wc(X) >>= (_FP_WORKBITS); \ 165 } \ 166 FP_SET_EXCEPTION(FP_EX_UNDERFLOW); \ 167 } \ 168 } \ 169 break; \ 170 \ 171 case FP_CLS_ZERO: \ 172 X##_e = 0; \ 173 _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \ 174 break; \ 175 \ 176 case FP_CLS_INF: \ 177 X##_e = _FP_EXPMAX_##fs; \ 178 _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \ 179 break; \ 180 \ 181 case FP_CLS_NAN: \ 182 X##_e = _FP_EXPMAX_##fs; \ 183 if (!_FP_KEEPNANFRACP) \ 184 { \ 185 _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs); \ 186 X##_s = _FP_NANSIGN_##fs; \ 187 } \ 188 else \ 189 _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_QNANBIT_##fs; \ 190 break; \ 191 } \ 192 } while (0) 193 194 /* This one accepts raw argument and not cooked, returns 195 * 1 if X is a signaling NaN. 196 */ 197 #define _FP_ISSIGNAN(fs, wc, X) \ 198 ({ \ 199 int __ret = 0; \ 200 if (X##_e == _FP_EXPMAX_##fs) \ 201 { \ 202 if (!_FP_FRAC_ZEROP_##wc(X) \ 203 && !(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs)) \ 204 __ret = 1; \ 205 } \ 206 __ret; \ 207 }) 208 209 210 211 212 213 /* 214 * Main addition routine. The input values should be cooked. 215 */ 216 217 #define _FP_ADD_INTERNAL(fs, wc, R, X, Y, OP) \ 218 do { \ 219 switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \ 220 { \ 221 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \ 222 { \ 223 /* shift the smaller number so that its exponent matches the larger */ \ 224 _FP_I_TYPE diff = X##_e - Y##_e; \ 225 \ 226 if (diff < 0) \ 227 { \ 228 diff = -diff; \ 229 if (diff <= _FP_WFRACBITS_##fs) \ 230 _FP_FRAC_SRS_##wc(X, diff, _FP_WFRACBITS_##fs); \ 231 else if (!_FP_FRAC_ZEROP_##wc(X)) \ 232 _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc); \ 233 R##_e = Y##_e; \ 234 } \ 235 else \ 236 { \ 237 if (diff > 0) \ 238 { \ 239 if (diff <= _FP_WFRACBITS_##fs) \ 240 _FP_FRAC_SRS_##wc(Y, diff, _FP_WFRACBITS_##fs); \ 241 else if (!_FP_FRAC_ZEROP_##wc(Y)) \ 242 _FP_FRAC_SET_##wc(Y, _FP_MINFRAC_##wc); \ 243 } \ 244 R##_e = X##_e; \ 245 } \ 246 \ 247 R##_c = FP_CLS_NORMAL; \ 248 \ 249 if (X##_s == Y##_s) \ 250 { \ 251 R##_s = X##_s; \ 252 _FP_FRAC_ADD_##wc(R, X, Y); \ 253 if (_FP_FRAC_OVERP_##wc(fs, R)) \ 254 { \ 255 _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs); \ 256 R##_e++; \ 257 } \ 258 } \ 259 else \ 260 { \ 261 R##_s = X##_s; \ 262 _FP_FRAC_SUB_##wc(R, X, Y); \ 263 if (_FP_FRAC_ZEROP_##wc(R)) \ 264 { \ 265 /* return an exact zero */ \ 266 if (FP_ROUNDMODE == FP_RND_MINF) \ 267 R##_s |= Y##_s; \ 268 else \ 269 R##_s &= Y##_s; \ 270 R##_c = FP_CLS_ZERO; \ 271 } \ 272 else \ 273 { \ 274 if (_FP_FRAC_NEGP_##wc(R)) \ 275 { \ 276 _FP_FRAC_SUB_##wc(R, Y, X); \ 277 R##_s = Y##_s; \ 278 } \ 279 \ 280 /* renormalize after subtraction */ \ 281 _FP_FRAC_CLZ_##wc(diff, R); \ 282 diff -= _FP_WFRACXBITS_##fs; \ 283 if (diff) \ 284 { \ 285 R##_e -= diff; \ 286 _FP_FRAC_SLL_##wc(R, diff); \ 287 } \ 288 } \ 289 } \ 290 break; \ 291 } \ 292 \ 293 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \ 294 _FP_CHOOSENAN(fs, wc, R, X, Y, OP); \ 295 break; \ 296 \ 297 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO): \ 298 R##_e = X##_e; \ 299 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL): \ 300 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF): \ 301 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO): \ 302 _FP_FRAC_COPY_##wc(R, X); \ 303 R##_s = X##_s; \ 304 R##_c = X##_c; \ 305 break; \ 306 \ 307 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL): \ 308 R##_e = Y##_e; \ 309 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN): \ 310 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN): \ 311 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN): \ 312 _FP_FRAC_COPY_##wc(R, Y); \ 313 R##_s = Y##_s; \ 314 R##_c = Y##_c; \ 315 break; \ 316 \ 317 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \ 318 if (X##_s != Y##_s) \ 319 { \ 320 /* +INF + -INF => NAN */ \ 321 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ 322 R##_s = _FP_NANSIGN_##fs; \ 323 R##_c = FP_CLS_NAN; \ 324 FP_SET_EXCEPTION(FP_EX_INVALID); \ 325 break; \ 326 } \ 327 /* FALLTHRU */ \ 328 \ 329 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL): \ 330 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \ 331 R##_s = X##_s; \ 332 R##_c = FP_CLS_INF; \ 333 break; \ 334 \ 335 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF): \ 336 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \ 337 R##_s = Y##_s; \ 338 R##_c = FP_CLS_INF; \ 339 break; \ 340 \ 341 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \ 342 /* make sure the sign is correct */ \ 343 if (FP_ROUNDMODE == FP_RND_MINF) \ 344 R##_s = X##_s | Y##_s; \ 345 else \ 346 R##_s = X##_s & Y##_s; \ 347 R##_c = FP_CLS_ZERO; \ 348 break; \ 349 \ 350 default: \ 351 abort(); \ 352 } \ 353 } while (0) 354 355 #define _FP_ADD(fs, wc, R, X, Y) _FP_ADD_INTERNAL(fs, wc, R, X, Y, '+') 356 #define _FP_SUB(fs, wc, R, X, Y) \ 357 do { \ 358 if (Y##_c != FP_CLS_NAN) Y##_s ^= 1; \ 359 _FP_ADD_INTERNAL(fs, wc, R, X, Y, '-'); \ 360 } while (0) 361 362 363 /* 364 * Main negation routine. FIXME -- when we care about setting exception 365 * bits reliably, this will not do. We should examine all of the fp classes. 366 */ 367 368 #define _FP_NEG(fs, wc, R, X) \ 369 do { \ 370 _FP_FRAC_COPY_##wc(R, X); \ 371 R##_c = X##_c; \ 372 R##_e = X##_e; \ 373 R##_s = 1 ^ X##_s; \ 374 } while (0) 375 376 377 /* 378 * Main multiplication routine. The input values should be cooked. 379 */ 380 381 #define _FP_MUL(fs, wc, R, X, Y) \ 382 do { \ 383 R##_s = X##_s ^ Y##_s; \ 384 switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \ 385 { \ 386 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \ 387 R##_c = FP_CLS_NORMAL; \ 388 R##_e = X##_e + Y##_e + 1; \ 389 \ 390 _FP_MUL_MEAT_##fs(R,X,Y); \ 391 \ 392 if (_FP_FRAC_OVERP_##wc(fs, R)) \ 393 _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs); \ 394 else \ 395 R##_e--; \ 396 break; \ 397 \ 398 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \ 399 _FP_CHOOSENAN(fs, wc, R, X, Y, '*'); \ 400 break; \ 401 \ 402 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL): \ 403 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF): \ 404 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO): \ 405 R##_s = X##_s; \ 406 \ 407 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \ 408 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL): \ 409 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL): \ 410 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \ 411 _FP_FRAC_COPY_##wc(R, X); \ 412 R##_c = X##_c; \ 413 break; \ 414 \ 415 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN): \ 416 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN): \ 417 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN): \ 418 R##_s = Y##_s; \ 419 \ 420 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF): \ 421 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO): \ 422 _FP_FRAC_COPY_##wc(R, Y); \ 423 R##_c = Y##_c; \ 424 break; \ 425 \ 426 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \ 427 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \ 428 R##_s = _FP_NANSIGN_##fs; \ 429 R##_c = FP_CLS_NAN; \ 430 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ 431 FP_SET_EXCEPTION(FP_EX_INVALID); \ 432 break; \ 433 \ 434 default: \ 435 abort(); \ 436 } \ 437 } while (0) 438 439 440 /* 441 * Main division routine. The input values should be cooked. 442 */ 443 444 #define _FP_DIV(fs, wc, R, X, Y) \ 445 do { \ 446 R##_s = X##_s ^ Y##_s; \ 447 switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \ 448 { \ 449 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \ 450 R##_c = FP_CLS_NORMAL; \ 451 R##_e = X##_e - Y##_e; \ 452 \ 453 _FP_DIV_MEAT_##fs(R,X,Y); \ 454 break; \ 455 \ 456 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \ 457 _FP_CHOOSENAN(fs, wc, R, X, Y, '/'); \ 458 break; \ 459 \ 460 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL): \ 461 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF): \ 462 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO): \ 463 R##_s = X##_s; \ 464 _FP_FRAC_COPY_##wc(R, X); \ 465 R##_c = X##_c; \ 466 break; \ 467 \ 468 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN): \ 469 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN): \ 470 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN): \ 471 R##_s = Y##_s; \ 472 _FP_FRAC_COPY_##wc(R, Y); \ 473 R##_c = Y##_c; \ 474 break; \ 475 \ 476 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF): \ 477 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \ 478 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL): \ 479 R##_c = FP_CLS_ZERO; \ 480 break; \ 481 \ 482 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO): \ 483 FP_SET_EXCEPTION(FP_EX_DIVZERO); \ 484 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \ 485 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL): \ 486 R##_c = FP_CLS_INF; \ 487 break; \ 488 \ 489 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \ 490 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \ 491 R##_s = _FP_NANSIGN_##fs; \ 492 R##_c = FP_CLS_NAN; \ 493 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ 494 FP_SET_EXCEPTION(FP_EX_INVALID); \ 495 break; \ 496 \ 497 default: \ 498 abort(); \ 499 } \ 500 } while (0) 501 502 503 /* 504 * Main differential comparison routine. The inputs should be raw not 505 * cooked. The return is -1,0,1 for normal values, 2 otherwise. 506 */ 507 508 #define _FP_CMP(fs, wc, ret, X, Y, un) \ 509 do { \ 510 /* NANs are unordered */ \ 511 if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X)) \ 512 || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) \ 513 { \ 514 ret = un; \ 515 } \ 516 else \ 517 { \ 518 int __is_zero_x; \ 519 int __is_zero_y; \ 520 \ 521 __is_zero_x = (!X##_e && _FP_FRAC_ZEROP_##wc(X)) ? 1 : 0; \ 522 __is_zero_y = (!Y##_e && _FP_FRAC_ZEROP_##wc(Y)) ? 1 : 0; \ 523 \ 524 if (__is_zero_x && __is_zero_y) \ 525 ret = 0; \ 526 else if (__is_zero_x) \ 527 ret = Y##_s ? 1 : -1; \ 528 else if (__is_zero_y) \ 529 ret = X##_s ? -1 : 1; \ 530 else if (X##_s != Y##_s) \ 531 ret = X##_s ? -1 : 1; \ 532 else if (X##_e > Y##_e) \ 533 ret = X##_s ? -1 : 1; \ 534 else if (X##_e < Y##_e) \ 535 ret = X##_s ? 1 : -1; \ 536 else if (_FP_FRAC_GT_##wc(X, Y)) \ 537 ret = X##_s ? -1 : 1; \ 538 else if (_FP_FRAC_GT_##wc(Y, X)) \ 539 ret = X##_s ? 1 : -1; \ 540 else \ 541 ret = 0; \ 542 } \ 543 } while (0) 544 545 546 /* Simplification for strict equality. */ 547 548 #define _FP_CMP_EQ(fs, wc, ret, X, Y) \ 549 do { \ 550 /* NANs are unordered */ \ 551 if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X)) \ 552 || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) \ 553 { \ 554 ret = 1; \ 555 } \ 556 else \ 557 { \ 558 ret = !(X##_e == Y##_e \ 559 && _FP_FRAC_EQ_##wc(X, Y) \ 560 && (X##_s == Y##_s || !X##_e && _FP_FRAC_ZEROP_##wc(X))); \ 561 } \ 562 } while (0) 563 564 /* 565 * Main square root routine. The input value should be cooked. 566 */ 567 568 #define _FP_SQRT(fs, wc, R, X) \ 569 do { \ 570 _FP_FRAC_DECL_##wc(T); _FP_FRAC_DECL_##wc(S); \ 571 _FP_W_TYPE q; \ 572 switch (X##_c) \ 573 { \ 574 case FP_CLS_NAN: \ 575 _FP_FRAC_COPY_##wc(R, X); \ 576 R##_s = X##_s; \ 577 R##_c = FP_CLS_NAN; \ 578 break; \ 579 case FP_CLS_INF: \ 580 if (X##_s) \ 581 { \ 582 R##_s = _FP_NANSIGN_##fs; \ 583 R##_c = FP_CLS_NAN; /* NAN */ \ 584 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ 585 FP_SET_EXCEPTION(FP_EX_INVALID); \ 586 } \ 587 else \ 588 { \ 589 R##_s = 0; \ 590 R##_c = FP_CLS_INF; /* sqrt(+inf) = +inf */ \ 591 } \ 592 break; \ 593 case FP_CLS_ZERO: \ 594 R##_s = X##_s; \ 595 R##_c = FP_CLS_ZERO; /* sqrt(+-0) = +-0 */ \ 596 break; \ 597 case FP_CLS_NORMAL: \ 598 R##_s = 0; \ 599 if (X##_s) \ 600 { \ 601 R##_c = FP_CLS_NAN; /* sNAN */ \ 602 R##_s = _FP_NANSIGN_##fs; \ 603 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ 604 FP_SET_EXCEPTION(FP_EX_INVALID); \ 605 break; \ 606 } \ 607 R##_c = FP_CLS_NORMAL; \ 608 if (X##_e & 1) \ 609 _FP_FRAC_SLL_##wc(X, 1); \ 610 R##_e = X##_e >> 1; \ 611 _FP_FRAC_SET_##wc(S, _FP_ZEROFRAC_##wc); \ 612 _FP_FRAC_SET_##wc(R, _FP_ZEROFRAC_##wc); \ 613 q = _FP_OVERFLOW_##fs >> 1; \ 614 _FP_SQRT_MEAT_##wc(R, S, T, X, q); \ 615 } \ 616 } while (0) 617 618 /* 619 * Convert from FP to integer 620 */ 621 622 /* RSIGNED can have following values: 623 * 0: the number is required to be 0..(2^rsize)-1, if not, NV is set plus 624 * the result is either 0 or (2^rsize)-1 depending on the sign in such case. 625 * 1: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, NV is 626 * set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 depending 627 * on the sign in such case. 628 * 2: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, NV is 629 * set plus the result is truncated to fit into destination. 630 * -1: the number is required to be -(2^(rsize-1))..(2^rsize)-1, if not, NV is 631 * set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 depending 632 * on the sign in such case. 633 */ 634 #define _FP_TO_INT(fs, wc, r, X, rsize, rsigned) \ 635 do { \ 636 switch (X##_c) \ 637 { \ 638 case FP_CLS_NORMAL: \ 639 if (X##_e < 0) \ 640 { \ 641 FP_SET_EXCEPTION(FP_EX_INEXACT); \ 642 case FP_CLS_ZERO: \ 643 r = 0; \ 644 } \ 645 else if (X##_e >= rsize - (rsigned > 0 || X##_s) \ 646 || (!rsigned && X##_s)) \ 647 { /* overflow */ \ 648 case FP_CLS_NAN: \ 649 case FP_CLS_INF: \ 650 if (rsigned == 2) \ 651 { \ 652 if (X##_c != FP_CLS_NORMAL \ 653 || X##_e >= rsize - 1 + _FP_WFRACBITS_##fs) \ 654 r = 0; \ 655 else \ 656 { \ 657 _FP_FRAC_SLL_##wc(X, (X##_e - _FP_WFRACBITS_##fs + 1)); \ 658 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 659 } \ 660 } \ 661 else if (rsigned) \ 662 { \ 663 r = 1; \ 664 r <<= rsize - 1; \ 665 r -= 1 - X##_s; \ 666 } \ 667 else \ 668 { \ 669 r = 0; \ 670 if (X##_s) \ 671 r = ~r; \ 672 } \ 673 FP_SET_EXCEPTION(FP_EX_INVALID); \ 674 } \ 675 else \ 676 { \ 677 if (_FP_W_TYPE_SIZE*wc < rsize) \ 678 { \ 679 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 680 r <<= X##_e - _FP_WFRACBITS_##fs; \ 681 } \ 682 else \ 683 { \ 684 if (X##_e >= _FP_WFRACBITS_##fs) \ 685 _FP_FRAC_SLL_##wc(X, (X##_e - _FP_WFRACBITS_##fs + 1)); \ 686 else if (X##_e < _FP_WFRACBITS_##fs - 1) \ 687 { \ 688 _FP_FRAC_SRS_##wc(X, (_FP_WFRACBITS_##fs - X##_e - 2), \ 689 _FP_WFRACBITS_##fs); \ 690 if (_FP_FRAC_LOW_##wc(X) & 1) \ 691 FP_SET_EXCEPTION(FP_EX_INEXACT); \ 692 _FP_FRAC_SRL_##wc(X, 1); \ 693 } \ 694 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 695 } \ 696 if (rsigned && X##_s) \ 697 r = -r; \ 698 } \ 699 break; \ 700 } \ 701 } while (0) 702 703 #define _FP_TO_INT_ROUND(fs, wc, r, X, rsize, rsigned) \ 704 do { \ 705 r = 0; \ 706 switch (X##_c) \ 707 { \ 708 case FP_CLS_NORMAL: \ 709 if (X##_e >= _FP_FRACBITS_##fs - 1) \ 710 { \ 711 if (X##_e < rsize - 1 + _FP_WFRACBITS_##fs) \ 712 { \ 713 if (X##_e >= _FP_WFRACBITS_##fs - 1) \ 714 { \ 715 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 716 r <<= X##_e - _FP_WFRACBITS_##fs + 1; \ 717 } \ 718 else \ 719 { \ 720 _FP_FRAC_SRL_##wc(X, _FP_WORKBITS - X##_e \ 721 + _FP_FRACBITS_##fs - 1); \ 722 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 723 } \ 724 } \ 725 } \ 726 else \ 727 { \ 728 if (X##_e <= -_FP_WORKBITS - 1) \ 729 _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc); \ 730 else \ 731 _FP_FRAC_SRS_##wc(X, _FP_FRACBITS_##fs - 1 - X##_e, \ 732 _FP_WFRACBITS_##fs); \ 733 _FP_ROUND(wc, X); \ 734 _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \ 735 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 736 } \ 737 if (rsigned && X##_s) \ 738 r = -r; \ 739 if (X##_e >= rsize - (rsigned > 0 || X##_s) \ 740 || (!rsigned && X##_s)) \ 741 { /* overflow */ \ 742 case FP_CLS_NAN: \ 743 case FP_CLS_INF: \ 744 if (!rsigned) \ 745 { \ 746 r = 0; \ 747 if (X##_s) \ 748 r = ~r; \ 749 } \ 750 else if (rsigned != 2) \ 751 { \ 752 r = 1; \ 753 r <<= rsize - 1; \ 754 r -= 1 - X##_s; \ 755 } \ 756 FP_SET_EXCEPTION(FP_EX_INVALID); \ 757 } \ 758 break; \ 759 case FP_CLS_ZERO: \ 760 break; \ 761 } \ 762 } while (0) 763 764 #define _FP_FROM_INT(fs, wc, X, r, rsize, rtype) \ 765 do { \ 766 if (r) \ 767 { \ 768 unsigned rtype ur_; \ 769 X##_c = FP_CLS_NORMAL; \ 770 \ 771 if ((X##_s = (r < 0))) \ 772 ur_ = (unsigned rtype) -r; \ 773 else \ 774 ur_ = (unsigned rtype) r; \ 775 if (rsize <= _FP_W_TYPE_SIZE) \ 776 __FP_CLZ(X##_e, ur_); \ 777 else \ 778 __FP_CLZ_2(X##_e, (_FP_W_TYPE)(ur_ >> _FP_W_TYPE_SIZE), \ 779 (_FP_W_TYPE)ur_); \ 780 if (rsize < _FP_W_TYPE_SIZE) \ 781 X##_e -= (_FP_W_TYPE_SIZE - rsize); \ 782 X##_e = rsize - X##_e - 1; \ 783 \ 784 if (_FP_FRACBITS_##fs < rsize && _FP_WFRACBITS_##fs < X##_e) \ 785 __FP_FRAC_SRS_1(ur_, (X##_e - _FP_WFRACBITS_##fs + 1), rsize);\ 786 _FP_FRAC_DISASSEMBLE_##wc(X, ur_, rsize); \ 787 if ((_FP_WFRACBITS_##fs - X##_e - 1) > 0) \ 788 _FP_FRAC_SLL_##wc(X, (_FP_WFRACBITS_##fs - X##_e - 1)); \ 789 } \ 790 else \ 791 { \ 792 X##_c = FP_CLS_ZERO, X##_s = 0; \ 793 } \ 794 } while (0) 795 796 797 #define FP_CONV(dfs,sfs,dwc,swc,D,S) \ 798 do { \ 799 _FP_FRAC_CONV_##dwc##_##swc(dfs, sfs, D, S); \ 800 D##_e = S##_e; \ 801 D##_c = S##_c; \ 802 D##_s = S##_s; \ 803 } while (0) 804 805 /* 806 * Helper primitives. 807 */ 808 809 /* Count leading zeros in a word. */ 810 811 #ifndef __FP_CLZ 812 #if _FP_W_TYPE_SIZE < 64 813 /* this is just to shut the compiler up about shifts > word length -- PMM 02/1998 */ 814 #define __FP_CLZ(r, x) \ 815 do { \ 816 _FP_W_TYPE _t = (x); \ 817 r = _FP_W_TYPE_SIZE - 1; \ 818 if (_t > 0xffff) r -= 16; \ 819 if (_t > 0xffff) _t >>= 16; \ 820 if (_t > 0xff) r -= 8; \ 821 if (_t > 0xff) _t >>= 8; \ 822 if (_t & 0xf0) r -= 4; \ 823 if (_t & 0xf0) _t >>= 4; \ 824 if (_t & 0xc) r -= 2; \ 825 if (_t & 0xc) _t >>= 2; \ 826 if (_t & 0x2) r -= 1; \ 827 } while (0) 828 #else /* not _FP_W_TYPE_SIZE < 64 */ 829 #define __FP_CLZ(r, x) \ 830 do { \ 831 _FP_W_TYPE _t = (x); \ 832 r = _FP_W_TYPE_SIZE - 1; \ 833 if (_t > 0xffffffff) r -= 32; \ 834 if (_t > 0xffffffff) _t >>= 32; \ 835 if (_t > 0xffff) r -= 16; \ 836 if (_t > 0xffff) _t >>= 16; \ 837 if (_t > 0xff) r -= 8; \ 838 if (_t > 0xff) _t >>= 8; \ 839 if (_t & 0xf0) r -= 4; \ 840 if (_t & 0xf0) _t >>= 4; \ 841 if (_t & 0xc) r -= 2; \ 842 if (_t & 0xc) _t >>= 2; \ 843 if (_t & 0x2) r -= 1; \ 844 } while (0) 845 #endif /* not _FP_W_TYPE_SIZE < 64 */ 846 #endif /* ndef __FP_CLZ */ 847 848 #define _FP_DIV_HELP_imm(q, r, n, d) \ 849 do { \ 850 q = n / d, r = n % d; \ 851 } while (0) 852 853 #endif /* __MATH_EMU_OP_COMMON_H__ */ 854