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) \ 37do { \ 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) \ 90do { \ 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) \ 218do { \ 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#define _FP_NEG(fs, wc, R, X) \ 365 do { \ 366 _FP_FRAC_COPY_##wc(R, X); \ 367 R##_c = X##_c; \ 368 R##_e = X##_e; \ 369 R##_s = 1 ^ X##_s; \ 370 } while (0) 371 372 373/* 374 * Main multiplication routine. The input values should be cooked. 375 */ 376 377#define _FP_MUL(fs, wc, R, X, Y) \ 378do { \ 379 R##_s = X##_s ^ Y##_s; \ 380 switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \ 381 { \ 382 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \ 383 R##_c = FP_CLS_NORMAL; \ 384 R##_e = X##_e + Y##_e + 1; \ 385 \ 386 _FP_MUL_MEAT_##fs(R,X,Y); \ 387 \ 388 if (_FP_FRAC_OVERP_##wc(fs, R)) \ 389 _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs); \ 390 else \ 391 R##_e--; \ 392 break; \ 393 \ 394 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \ 395 _FP_CHOOSENAN(fs, wc, R, X, Y, '*'); \ 396 break; \ 397 \ 398 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL): \ 399 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF): \ 400 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO): \ 401 R##_s = X##_s; \ 402 \ 403 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \ 404 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL): \ 405 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL): \ 406 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \ 407 _FP_FRAC_COPY_##wc(R, X); \ 408 R##_c = X##_c; \ 409 break; \ 410 \ 411 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN): \ 412 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN): \ 413 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN): \ 414 R##_s = Y##_s; \ 415 \ 416 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF): \ 417 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO): \ 418 _FP_FRAC_COPY_##wc(R, Y); \ 419 R##_c = Y##_c; \ 420 break; \ 421 \ 422 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \ 423 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \ 424 R##_s = _FP_NANSIGN_##fs; \ 425 R##_c = FP_CLS_NAN; \ 426 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ 427 FP_SET_EXCEPTION(FP_EX_INVALID); \ 428 break; \ 429 \ 430 default: \ 431 abort(); \ 432 } \ 433} while (0) 434 435 436/* 437 * Main division routine. The input values should be cooked. 438 */ 439 440#define _FP_DIV(fs, wc, R, X, Y) \ 441do { \ 442 R##_s = X##_s ^ Y##_s; \ 443 switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \ 444 { \ 445 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \ 446 R##_c = FP_CLS_NORMAL; \ 447 R##_e = X##_e - Y##_e; \ 448 \ 449 _FP_DIV_MEAT_##fs(R,X,Y); \ 450 break; \ 451 \ 452 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \ 453 _FP_CHOOSENAN(fs, wc, R, X, Y, '/'); \ 454 break; \ 455 \ 456 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL): \ 457 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF): \ 458 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO): \ 459 R##_s = X##_s; \ 460 _FP_FRAC_COPY_##wc(R, X); \ 461 R##_c = X##_c; \ 462 break; \ 463 \ 464 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN): \ 465 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN): \ 466 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN): \ 467 R##_s = Y##_s; \ 468 _FP_FRAC_COPY_##wc(R, Y); \ 469 R##_c = Y##_c; \ 470 break; \ 471 \ 472 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF): \ 473 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \ 474 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL): \ 475 R##_c = FP_CLS_ZERO; \ 476 break; \ 477 \ 478 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO): \ 479 FP_SET_EXCEPTION(FP_EX_DIVZERO); \ 480 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \ 481 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL): \ 482 R##_c = FP_CLS_INF; \ 483 break; \ 484 \ 485 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \ 486 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \ 487 R##_s = _FP_NANSIGN_##fs; \ 488 R##_c = FP_CLS_NAN; \ 489 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ 490 FP_SET_EXCEPTION(FP_EX_INVALID); \ 491 break; \ 492 \ 493 default: \ 494 abort(); \ 495 } \ 496} while (0) 497 498 499/* 500 * Main differential comparison routine. The inputs should be raw not 501 * cooked. The return is -1,0,1 for normal values, 2 otherwise. 502 */ 503 504#define _FP_CMP(fs, wc, ret, X, Y, un) \ 505 do { \ 506 /* NANs are unordered */ \ 507 if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X)) \ 508 || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) \ 509 { \ 510 ret = un; \ 511 } \ 512 else \ 513 { \ 514 int __is_zero_x; \ 515 int __is_zero_y; \ 516 \ 517 __is_zero_x = (!X##_e && _FP_FRAC_ZEROP_##wc(X)) ? 1 : 0; \ 518 __is_zero_y = (!Y##_e && _FP_FRAC_ZEROP_##wc(Y)) ? 1 : 0; \ 519 \ 520 if (__is_zero_x && __is_zero_y) \ 521 ret = 0; \ 522 else if (__is_zero_x) \ 523 ret = Y##_s ? 1 : -1; \ 524 else if (__is_zero_y) \ 525 ret = X##_s ? -1 : 1; \ 526 else if (X##_s != Y##_s) \ 527 ret = X##_s ? -1 : 1; \ 528 else if (X##_e > Y##_e) \ 529 ret = X##_s ? -1 : 1; \ 530 else if (X##_e < Y##_e) \ 531 ret = X##_s ? 1 : -1; \ 532 else if (_FP_FRAC_GT_##wc(X, Y)) \ 533 ret = X##_s ? -1 : 1; \ 534 else if (_FP_FRAC_GT_##wc(Y, X)) \ 535 ret = X##_s ? 1 : -1; \ 536 else \ 537 ret = 0; \ 538 } \ 539 } while (0) 540 541 542/* Simplification for strict equality. */ 543 544#define _FP_CMP_EQ(fs, wc, ret, X, Y) \ 545 do { \ 546 /* NANs are unordered */ \ 547 if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X)) \ 548 || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) \ 549 { \ 550 ret = 1; \ 551 } \ 552 else \ 553 { \ 554 ret = !(X##_e == Y##_e \ 555 && _FP_FRAC_EQ_##wc(X, Y) \ 556 && (X##_s == Y##_s || !X##_e && _FP_FRAC_ZEROP_##wc(X))); \ 557 } \ 558 } while (0) 559 560/* 561 * Main square root routine. The input value should be cooked. 562 */ 563 564#define _FP_SQRT(fs, wc, R, X) \ 565do { \ 566 _FP_FRAC_DECL_##wc(T); _FP_FRAC_DECL_##wc(S); \ 567 _FP_W_TYPE q; \ 568 switch (X##_c) \ 569 { \ 570 case FP_CLS_NAN: \ 571 _FP_FRAC_COPY_##wc(R, X); \ 572 R##_s = X##_s; \ 573 R##_c = FP_CLS_NAN; \ 574 break; \ 575 case FP_CLS_INF: \ 576 if (X##_s) \ 577 { \ 578 R##_s = _FP_NANSIGN_##fs; \ 579 R##_c = FP_CLS_NAN; /* NAN */ \ 580 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ 581 FP_SET_EXCEPTION(FP_EX_INVALID); \ 582 } \ 583 else \ 584 { \ 585 R##_s = 0; \ 586 R##_c = FP_CLS_INF; /* sqrt(+inf) = +inf */ \ 587 } \ 588 break; \ 589 case FP_CLS_ZERO: \ 590 R##_s = X##_s; \ 591 R##_c = FP_CLS_ZERO; /* sqrt(+-0) = +-0 */ \ 592 break; \ 593 case FP_CLS_NORMAL: \ 594 R##_s = 0; \ 595 if (X##_s) \ 596 { \ 597 R##_c = FP_CLS_NAN; /* sNAN */ \ 598 R##_s = _FP_NANSIGN_##fs; \ 599 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \ 600 FP_SET_EXCEPTION(FP_EX_INVALID); \ 601 break; \ 602 } \ 603 R##_c = FP_CLS_NORMAL; \ 604 if (X##_e & 1) \ 605 _FP_FRAC_SLL_##wc(X, 1); \ 606 R##_e = X##_e >> 1; \ 607 _FP_FRAC_SET_##wc(S, _FP_ZEROFRAC_##wc); \ 608 _FP_FRAC_SET_##wc(R, _FP_ZEROFRAC_##wc); \ 609 q = _FP_OVERFLOW_##fs >> 1; \ 610 _FP_SQRT_MEAT_##wc(R, S, T, X, q); \ 611 } \ 612 } while (0) 613 614/* 615 * Convert from FP to integer 616 */ 617 618/* RSIGNED can have following values: 619 * 0: the number is required to be 0..(2^rsize)-1, if not, NV is set plus 620 * the result is either 0 or (2^rsize)-1 depending on the sign in such case. 621 * 1: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, NV is 622 * set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 depending 623 * on the sign in such case. 624 * 2: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, NV is 625 * set plus the result is truncated to fit into destination. 626 * -1: the number is required to be -(2^(rsize-1))..(2^rsize)-1, if not, NV is 627 * set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 depending 628 * on the sign in such case. 629 */ 630#define _FP_TO_INT(fs, wc, r, X, rsize, rsigned) \ 631 do { \ 632 switch (X##_c) \ 633 { \ 634 case FP_CLS_NORMAL: \ 635 if (X##_e < 0) \ 636 { \ 637 FP_SET_EXCEPTION(FP_EX_INEXACT); \ 638 case FP_CLS_ZERO: \ 639 r = 0; \ 640 } \ 641 else if (X##_e >= rsize - (rsigned > 0 || X##_s) \ 642 || (!rsigned && X##_s)) \ 643 { /* overflow */ \ 644 case FP_CLS_NAN: \ 645 case FP_CLS_INF: \ 646 if (rsigned == 2) \ 647 { \ 648 if (X##_c != FP_CLS_NORMAL \ 649 || X##_e >= rsize - 1 + _FP_WFRACBITS_##fs) \ 650 r = 0; \ 651 else \ 652 { \ 653 _FP_FRAC_SLL_##wc(X, (X##_e - _FP_WFRACBITS_##fs + 1)); \ 654 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 655 } \ 656 } \ 657 else if (rsigned) \ 658 { \ 659 r = 1; \ 660 r <<= rsize - 1; \ 661 r -= 1 - X##_s; \ 662 } \ 663 else \ 664 { \ 665 r = 0; \ 666 if (X##_s) \ 667 r = ~r; \ 668 } \ 669 FP_SET_EXCEPTION(FP_EX_INVALID); \ 670 } \ 671 else \ 672 { \ 673 if (_FP_W_TYPE_SIZE*wc < rsize) \ 674 { \ 675 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 676 r <<= X##_e - _FP_WFRACBITS_##fs; \ 677 } \ 678 else \ 679 { \ 680 if (X##_e >= _FP_WFRACBITS_##fs) \ 681 _FP_FRAC_SLL_##wc(X, (X##_e - _FP_WFRACBITS_##fs + 1)); \ 682 else if (X##_e < _FP_WFRACBITS_##fs - 1) \ 683 { \ 684 _FP_FRAC_SRS_##wc(X, (_FP_WFRACBITS_##fs - X##_e - 2), \ 685 _FP_WFRACBITS_##fs); \ 686 if (_FP_FRAC_LOW_##wc(X) & 1) \ 687 FP_SET_EXCEPTION(FP_EX_INEXACT); \ 688 _FP_FRAC_SRL_##wc(X, 1); \ 689 } \ 690 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 691 } \ 692 if (rsigned && X##_s) \ 693 r = -r; \ 694 } \ 695 break; \ 696 } \ 697 } while (0) 698 699#define _FP_TO_INT_ROUND(fs, wc, r, X, rsize, rsigned) \ 700 do { \ 701 r = 0; \ 702 switch (X##_c) \ 703 { \ 704 case FP_CLS_NORMAL: \ 705 if (X##_e >= _FP_FRACBITS_##fs - 1) \ 706 { \ 707 if (X##_e < rsize - 1 + _FP_WFRACBITS_##fs) \ 708 { \ 709 if (X##_e >= _FP_WFRACBITS_##fs - 1) \ 710 { \ 711 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 712 r <<= X##_e - _FP_WFRACBITS_##fs + 1; \ 713 } \ 714 else \ 715 { \ 716 _FP_FRAC_SRL_##wc(X, _FP_WORKBITS - X##_e \ 717 + _FP_FRACBITS_##fs - 1); \ 718 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 719 } \ 720 } \ 721 } \ 722 else \ 723 { \ 724 if (X##_e <= -_FP_WORKBITS - 1) \ 725 _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc); \ 726 else \ 727 _FP_FRAC_SRS_##wc(X, _FP_FRACBITS_##fs - 1 - X##_e, \ 728 _FP_WFRACBITS_##fs); \ 729 _FP_ROUND(wc, X); \ 730 _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \ 731 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \ 732 } \ 733 if (rsigned && X##_s) \ 734 r = -r; \ 735 if (X##_e >= rsize - (rsigned > 0 || X##_s) \ 736 || (!rsigned && X##_s)) \ 737 { /* overflow */ \ 738 case FP_CLS_NAN: \ 739 case FP_CLS_INF: \ 740 if (!rsigned) \ 741 { \ 742 r = 0; \ 743 if (X##_s) \ 744 r = ~r; \ 745 } \ 746 else if (rsigned != 2) \ 747 { \ 748 r = 1; \ 749 r <<= rsize - 1; \ 750 r -= 1 - X##_s; \ 751 } \ 752 FP_SET_EXCEPTION(FP_EX_INVALID); \ 753 } \ 754 break; \ 755 case FP_CLS_ZERO: \ 756 break; \ 757 } \ 758 } while (0) 759 760#define _FP_FROM_INT(fs, wc, X, r, rsize, rtype) \ 761 do { \ 762 if (r) \ 763 { \ 764 unsigned rtype ur_; \ 765 X##_c = FP_CLS_NORMAL; \ 766 \ 767 if ((X##_s = (r < 0))) \ 768 ur_ = (unsigned rtype) -r; \ 769 else \ 770 ur_ = (unsigned rtype) r; \ 771 if (rsize <= _FP_W_TYPE_SIZE) \ 772 __FP_CLZ(X##_e, ur_); \ 773 else \ 774 __FP_CLZ_2(X##_e, (_FP_W_TYPE)(ur_ >> _FP_W_TYPE_SIZE), \ 775 (_FP_W_TYPE)ur_); \ 776 if (rsize < _FP_W_TYPE_SIZE) \ 777 X##_e -= (_FP_W_TYPE_SIZE - rsize); \ 778 X##_e = rsize - X##_e - 1; \ 779 \ 780 if (_FP_FRACBITS_##fs < rsize && _FP_WFRACBITS_##fs < X##_e) \ 781 __FP_FRAC_SRS_1(ur_, (X##_e - _FP_WFRACBITS_##fs + 1), rsize);\ 782 _FP_FRAC_DISASSEMBLE_##wc(X, ur_, rsize); \ 783 if ((_FP_WFRACBITS_##fs - X##_e - 1) > 0) \ 784 _FP_FRAC_SLL_##wc(X, (_FP_WFRACBITS_##fs - X##_e - 1)); \ 785 } \ 786 else \ 787 { \ 788 X##_c = FP_CLS_ZERO, X##_s = 0; \ 789 } \ 790 } while (0) 791 792 793#define FP_CONV(dfs,sfs,dwc,swc,D,S) \ 794 do { \ 795 _FP_FRAC_CONV_##dwc##_##swc(dfs, sfs, D, S); \ 796 D##_e = S##_e; \ 797 D##_c = S##_c; \ 798 D##_s = S##_s; \ 799 } while (0) 800 801/* 802 * Helper primitives. 803 */ 804 805/* Count leading zeros in a word. */ 806 807#ifndef __FP_CLZ 808#if _FP_W_TYPE_SIZE < 64 809/* this is just to shut the compiler up about shifts > word length -- PMM 02/1998 */ 810#define __FP_CLZ(r, x) \ 811 do { \ 812 _FP_W_TYPE _t = (x); \ 813 r = _FP_W_TYPE_SIZE - 1; \ 814 if (_t > 0xffff) r -= 16; \ 815 if (_t > 0xffff) _t >>= 16; \ 816 if (_t > 0xff) r -= 8; \ 817 if (_t > 0xff) _t >>= 8; \ 818 if (_t & 0xf0) r -= 4; \ 819 if (_t & 0xf0) _t >>= 4; \ 820 if (_t & 0xc) r -= 2; \ 821 if (_t & 0xc) _t >>= 2; \ 822 if (_t & 0x2) r -= 1; \ 823 } while (0) 824#else /* not _FP_W_TYPE_SIZE < 64 */ 825#define __FP_CLZ(r, x) \ 826 do { \ 827 _FP_W_TYPE _t = (x); \ 828 r = _FP_W_TYPE_SIZE - 1; \ 829 if (_t > 0xffffffff) r -= 32; \ 830 if (_t > 0xffffffff) _t >>= 32; \ 831 if (_t > 0xffff) r -= 16; \ 832 if (_t > 0xffff) _t >>= 16; \ 833 if (_t > 0xff) r -= 8; \ 834 if (_t > 0xff) _t >>= 8; \ 835 if (_t & 0xf0) r -= 4; \ 836 if (_t & 0xf0) _t >>= 4; \ 837 if (_t & 0xc) r -= 2; \ 838 if (_t & 0xc) _t >>= 2; \ 839 if (_t & 0x2) r -= 1; \ 840 } while (0) 841#endif /* not _FP_W_TYPE_SIZE < 64 */ 842#endif /* ndef __FP_CLZ */ 843 844#define _FP_DIV_HELP_imm(q, r, n, d) \ 845 do { \ 846 q = n / d, r = n % d; \ 847 } while (0) 848 849#endif /* __MATH_EMU_OP_COMMON_H__ */ 850