![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fpu_helper.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / target-alpha|
Return to fpu_helper.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-alpha |
1.1 ! root 1: /* ! 2: * Helpers for floating point instructions. ! 3: * ! 4: * Copyright (c) 2007 Jocelyn Mayer ! 5: * ! 6: * This library is free software; you can redistribute it and/or ! 7: * modify it under the terms of the GNU Lesser General Public ! 8: * License as published by the Free Software Foundation; either ! 9: * version 2 of the License, or (at your option) any later version. ! 10: * ! 11: * This library 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 GNU ! 14: * Lesser General Public License for more details. ! 15: * ! 16: * You should have received a copy of the GNU Lesser General Public ! 17: * License along with this library; if not, see <http://www.gnu.org/licenses/>. ! 18: */ ! 19: ! 20: #include "cpu.h" ! 21: #include "helper.h" ! 22: #include "softfloat.h" ! 23: ! 24: #define FP_STATUS (env->fp_status) ! 25: ! 26: ! 27: void helper_setroundmode(CPUAlphaState *env, uint32_t val) ! 28: { ! 29: set_float_rounding_mode(val, &FP_STATUS); ! 30: } ! 31: ! 32: void helper_setflushzero(CPUAlphaState *env, uint32_t val) ! 33: { ! 34: set_flush_to_zero(val, &FP_STATUS); ! 35: } ! 36: ! 37: void helper_fp_exc_clear(CPUAlphaState *env) ! 38: { ! 39: set_float_exception_flags(0, &FP_STATUS); ! 40: } ! 41: ! 42: uint32_t helper_fp_exc_get(CPUAlphaState *env) ! 43: { ! 44: return get_float_exception_flags(&FP_STATUS); ! 45: } ! 46: ! 47: static inline void inline_fp_exc_raise(CPUAlphaState *env, uintptr_t retaddr, ! 48: uint32_t exc, uint32_t regno) ! 49: { ! 50: if (exc) { ! 51: uint32_t hw_exc = 0; ! 52: ! 53: if (exc & float_flag_invalid) { ! 54: hw_exc |= EXC_M_INV; ! 55: } ! 56: if (exc & float_flag_divbyzero) { ! 57: hw_exc |= EXC_M_DZE; ! 58: } ! 59: if (exc & float_flag_overflow) { ! 60: hw_exc |= EXC_M_FOV; ! 61: } ! 62: if (exc & float_flag_underflow) { ! 63: hw_exc |= EXC_M_UNF; ! 64: } ! 65: if (exc & float_flag_inexact) { ! 66: hw_exc |= EXC_M_INE; ! 67: } ! 68: ! 69: arith_excp(env, retaddr, hw_exc, 1ull << regno); ! 70: } ! 71: } ! 72: ! 73: /* Raise exceptions for ieee fp insns without software completion. ! 74: In that case there are no exceptions that don't trap; the mask ! 75: doesn't apply. */ ! 76: void helper_fp_exc_raise(CPUAlphaState *env, uint32_t exc, uint32_t regno) ! 77: { ! 78: inline_fp_exc_raise(env, GETPC(), exc, regno); ! 79: } ! 80: ! 81: /* Raise exceptions for ieee fp insns with software completion. */ ! 82: void helper_fp_exc_raise_s(CPUAlphaState *env, uint32_t exc, uint32_t regno) ! 83: { ! 84: if (exc) { ! 85: env->fpcr_exc_status |= exc; ! 86: exc &= ~env->fpcr_exc_mask; ! 87: inline_fp_exc_raise(env, GETPC(), exc, regno); ! 88: } ! 89: } ! 90: ! 91: /* Input handing without software completion. Trap for all ! 92: non-finite numbers. */ ! 93: void helper_ieee_input(CPUAlphaState *env, uint64_t val) ! 94: { ! 95: uint32_t exp = (uint32_t)(val >> 52) & 0x7ff; ! 96: uint64_t frac = val & 0xfffffffffffffull; ! 97: ! 98: if (exp == 0) { ! 99: /* Denormals without DNZ set raise an exception. */ ! 100: if (frac != 0 && !env->fp_status.flush_inputs_to_zero) { ! 101: arith_excp(env, GETPC(), EXC_M_UNF, 0); ! 102: } ! 103: } else if (exp == 0x7ff) { ! 104: /* Infinity or NaN. */ ! 105: /* ??? I'm not sure these exception bit flags are correct. I do ! 106: know that the Linux kernel, at least, doesn't rely on them and ! 107: just emulates the insn to figure out what exception to use. */ ! 108: arith_excp(env, GETPC(), frac ? EXC_M_INV : EXC_M_FOV, 0); ! 109: } ! 110: } ! 111: ! 112: /* Similar, but does not trap for infinities. Used for comparisons. */ ! 113: void helper_ieee_input_cmp(CPUAlphaState *env, uint64_t val) ! 114: { ! 115: uint32_t exp = (uint32_t)(val >> 52) & 0x7ff; ! 116: uint64_t frac = val & 0xfffffffffffffull; ! 117: ! 118: if (exp == 0) { ! 119: /* Denormals without DNZ set raise an exception. */ ! 120: if (frac != 0 && !env->fp_status.flush_inputs_to_zero) { ! 121: arith_excp(env, GETPC(), EXC_M_UNF, 0); ! 122: } ! 123: } else if (exp == 0x7ff && frac) { ! 124: /* NaN. */ ! 125: arith_excp(env, GETPC(), EXC_M_INV, 0); ! 126: } ! 127: } ! 128: ! 129: /* F floating (VAX) */ ! 130: static uint64_t float32_to_f(float32 fa) ! 131: { ! 132: uint64_t r, exp, mant, sig; ! 133: CPU_FloatU a; ! 134: ! 135: a.f = fa; ! 136: sig = ((uint64_t)a.l & 0x80000000) << 32; ! 137: exp = (a.l >> 23) & 0xff; ! 138: mant = ((uint64_t)a.l & 0x007fffff) << 29; ! 139: ! 140: if (exp == 255) { ! 141: /* NaN or infinity */ ! 142: r = 1; /* VAX dirty zero */ ! 143: } else if (exp == 0) { ! 144: if (mant == 0) { ! 145: /* Zero */ ! 146: r = 0; ! 147: } else { ! 148: /* Denormalized */ ! 149: r = sig | ((exp + 1) << 52) | mant; ! 150: } ! 151: } else { ! 152: if (exp >= 253) { ! 153: /* Overflow */ ! 154: r = 1; /* VAX dirty zero */ ! 155: } else { ! 156: r = sig | ((exp + 2) << 52); ! 157: } ! 158: } ! 159: ! 160: return r; ! 161: } ! 162: ! 163: static float32 f_to_float32(CPUAlphaState *env, uintptr_t retaddr, uint64_t a) ! 164: { ! 165: uint32_t exp, mant_sig; ! 166: CPU_FloatU r; ! 167: ! 168: exp = ((a >> 55) & 0x80) | ((a >> 52) & 0x7f); ! 169: mant_sig = ((a >> 32) & 0x80000000) | ((a >> 29) & 0x007fffff); ! 170: ! 171: if (unlikely(!exp && mant_sig)) { ! 172: /* Reserved operands / Dirty zero */ ! 173: dynamic_excp(env, retaddr, EXCP_OPCDEC, 0); ! 174: } ! 175: ! 176: if (exp < 3) { ! 177: /* Underflow */ ! 178: r.l = 0; ! 179: } else { ! 180: r.l = ((exp - 2) << 23) | mant_sig; ! 181: } ! 182: ! 183: return r.f; ! 184: } ! 185: ! 186: uint32_t helper_f_to_memory(uint64_t a) ! 187: { ! 188: uint32_t r; ! 189: r = (a & 0x00001fffe0000000ull) >> 13; ! 190: r |= (a & 0x07ffe00000000000ull) >> 45; ! 191: r |= (a & 0xc000000000000000ull) >> 48; ! 192: return r; ! 193: } ! 194: ! 195: uint64_t helper_memory_to_f(uint32_t a) ! 196: { ! 197: uint64_t r; ! 198: r = ((uint64_t)(a & 0x0000c000)) << 48; ! 199: r |= ((uint64_t)(a & 0x003fffff)) << 45; ! 200: r |= ((uint64_t)(a & 0xffff0000)) << 13; ! 201: if (!(a & 0x00004000)) { ! 202: r |= 0x7ll << 59; ! 203: } ! 204: return r; ! 205: } ! 206: ! 207: /* ??? Emulating VAX arithmetic with IEEE arithmetic is wrong. We should ! 208: either implement VAX arithmetic properly or just signal invalid opcode. */ ! 209: ! 210: uint64_t helper_addf(CPUAlphaState *env, uint64_t a, uint64_t b) ! 211: { ! 212: float32 fa, fb, fr; ! 213: ! 214: fa = f_to_float32(env, GETPC(), a); ! 215: fb = f_to_float32(env, GETPC(), b); ! 216: fr = float32_add(fa, fb, &FP_STATUS); ! 217: return float32_to_f(fr); ! 218: } ! 219: ! 220: uint64_t helper_subf(CPUAlphaState *env, uint64_t a, uint64_t b) ! 221: { ! 222: float32 fa, fb, fr; ! 223: ! 224: fa = f_to_float32(env, GETPC(), a); ! 225: fb = f_to_float32(env, GETPC(), b); ! 226: fr = float32_sub(fa, fb, &FP_STATUS); ! 227: return float32_to_f(fr); ! 228: } ! 229: ! 230: uint64_t helper_mulf(CPUAlphaState *env, uint64_t a, uint64_t b) ! 231: { ! 232: float32 fa, fb, fr; ! 233: ! 234: fa = f_to_float32(env, GETPC(), a); ! 235: fb = f_to_float32(env, GETPC(), b); ! 236: fr = float32_mul(fa, fb, &FP_STATUS); ! 237: return float32_to_f(fr); ! 238: } ! 239: ! 240: uint64_t helper_divf(CPUAlphaState *env, uint64_t a, uint64_t b) ! 241: { ! 242: float32 fa, fb, fr; ! 243: ! 244: fa = f_to_float32(env, GETPC(), a); ! 245: fb = f_to_float32(env, GETPC(), b); ! 246: fr = float32_div(fa, fb, &FP_STATUS); ! 247: return float32_to_f(fr); ! 248: } ! 249: ! 250: uint64_t helper_sqrtf(CPUAlphaState *env, uint64_t t) ! 251: { ! 252: float32 ft, fr; ! 253: ! 254: ft = f_to_float32(env, GETPC(), t); ! 255: fr = float32_sqrt(ft, &FP_STATUS); ! 256: return float32_to_f(fr); ! 257: } ! 258: ! 259: ! 260: /* G floating (VAX) */ ! 261: static uint64_t float64_to_g(float64 fa) ! 262: { ! 263: uint64_t r, exp, mant, sig; ! 264: CPU_DoubleU a; ! 265: ! 266: a.d = fa; ! 267: sig = a.ll & 0x8000000000000000ull; ! 268: exp = (a.ll >> 52) & 0x7ff; ! 269: mant = a.ll & 0x000fffffffffffffull; ! 270: ! 271: if (exp == 2047) { ! 272: /* NaN or infinity */ ! 273: r = 1; /* VAX dirty zero */ ! 274: } else if (exp == 0) { ! 275: if (mant == 0) { ! 276: /* Zero */ ! 277: r = 0; ! 278: } else { ! 279: /* Denormalized */ ! 280: r = sig | ((exp + 1) << 52) | mant; ! 281: } ! 282: } else { ! 283: if (exp >= 2045) { ! 284: /* Overflow */ ! 285: r = 1; /* VAX dirty zero */ ! 286: } else { ! 287: r = sig | ((exp + 2) << 52); ! 288: } ! 289: } ! 290: ! 291: return r; ! 292: } ! 293: ! 294: static float64 g_to_float64(CPUAlphaState *env, uintptr_t retaddr, uint64_t a) ! 295: { ! 296: uint64_t exp, mant_sig; ! 297: CPU_DoubleU r; ! 298: ! 299: exp = (a >> 52) & 0x7ff; ! 300: mant_sig = a & 0x800fffffffffffffull; ! 301: ! 302: if (!exp && mant_sig) { ! 303: /* Reserved operands / Dirty zero */ ! 304: dynamic_excp(env, retaddr, EXCP_OPCDEC, 0); ! 305: } ! 306: ! 307: if (exp < 3) { ! 308: /* Underflow */ ! 309: r.ll = 0; ! 310: } else { ! 311: r.ll = ((exp - 2) << 52) | mant_sig; ! 312: } ! 313: ! 314: return r.d; ! 315: } ! 316: ! 317: uint64_t helper_g_to_memory(uint64_t a) ! 318: { ! 319: uint64_t r; ! 320: r = (a & 0x000000000000ffffull) << 48; ! 321: r |= (a & 0x00000000ffff0000ull) << 16; ! 322: r |= (a & 0x0000ffff00000000ull) >> 16; ! 323: r |= (a & 0xffff000000000000ull) >> 48; ! 324: return r; ! 325: } ! 326: ! 327: uint64_t helper_memory_to_g(uint64_t a) ! 328: { ! 329: uint64_t r; ! 330: r = (a & 0x000000000000ffffull) << 48; ! 331: r |= (a & 0x00000000ffff0000ull) << 16; ! 332: r |= (a & 0x0000ffff00000000ull) >> 16; ! 333: r |= (a & 0xffff000000000000ull) >> 48; ! 334: return r; ! 335: } ! 336: ! 337: uint64_t helper_addg(CPUAlphaState *env, uint64_t a, uint64_t b) ! 338: { ! 339: float64 fa, fb, fr; ! 340: ! 341: fa = g_to_float64(env, GETPC(), a); ! 342: fb = g_to_float64(env, GETPC(), b); ! 343: fr = float64_add(fa, fb, &FP_STATUS); ! 344: return float64_to_g(fr); ! 345: } ! 346: ! 347: uint64_t helper_subg(CPUAlphaState *env, uint64_t a, uint64_t b) ! 348: { ! 349: float64 fa, fb, fr; ! 350: ! 351: fa = g_to_float64(env, GETPC(), a); ! 352: fb = g_to_float64(env, GETPC(), b); ! 353: fr = float64_sub(fa, fb, &FP_STATUS); ! 354: return float64_to_g(fr); ! 355: } ! 356: ! 357: uint64_t helper_mulg(CPUAlphaState *env, uint64_t a, uint64_t b) ! 358: { ! 359: float64 fa, fb, fr; ! 360: ! 361: fa = g_to_float64(env, GETPC(), a); ! 362: fb = g_to_float64(env, GETPC(), b); ! 363: fr = float64_mul(fa, fb, &FP_STATUS); ! 364: return float64_to_g(fr); ! 365: } ! 366: ! 367: uint64_t helper_divg(CPUAlphaState *env, uint64_t a, uint64_t b) ! 368: { ! 369: float64 fa, fb, fr; ! 370: ! 371: fa = g_to_float64(env, GETPC(), a); ! 372: fb = g_to_float64(env, GETPC(), b); ! 373: fr = float64_div(fa, fb, &FP_STATUS); ! 374: return float64_to_g(fr); ! 375: } ! 376: ! 377: uint64_t helper_sqrtg(CPUAlphaState *env, uint64_t a) ! 378: { ! 379: float64 fa, fr; ! 380: ! 381: fa = g_to_float64(env, GETPC(), a); ! 382: fr = float64_sqrt(fa, &FP_STATUS); ! 383: return float64_to_g(fr); ! 384: } ! 385: ! 386: ! 387: /* S floating (single) */ ! 388: ! 389: /* Taken from linux/arch/alpha/kernel/traps.c, s_mem_to_reg. */ ! 390: static inline uint64_t float32_to_s_int(uint32_t fi) ! 391: { ! 392: uint32_t frac = fi & 0x7fffff; ! 393: uint32_t sign = fi >> 31; ! 394: uint32_t exp_msb = (fi >> 30) & 1; ! 395: uint32_t exp_low = (fi >> 23) & 0x7f; ! 396: uint32_t exp; ! 397: ! 398: exp = (exp_msb << 10) | exp_low; ! 399: if (exp_msb) { ! 400: if (exp_low == 0x7f) { ! 401: exp = 0x7ff; ! 402: } ! 403: } else { ! 404: if (exp_low != 0x00) { ! 405: exp |= 0x380; ! 406: } ! 407: } ! 408: ! 409: return (((uint64_t)sign << 63) ! 410: | ((uint64_t)exp << 52) ! 411: | ((uint64_t)frac << 29)); ! 412: } ! 413: ! 414: static inline uint64_t float32_to_s(float32 fa) ! 415: { ! 416: CPU_FloatU a; ! 417: a.f = fa; ! 418: return float32_to_s_int(a.l); ! 419: } ! 420: ! 421: static inline uint32_t s_to_float32_int(uint64_t a) ! 422: { ! 423: return ((a >> 32) & 0xc0000000) | ((a >> 29) & 0x3fffffff); ! 424: } ! 425: ! 426: static inline float32 s_to_float32(uint64_t a) ! 427: { ! 428: CPU_FloatU r; ! 429: r.l = s_to_float32_int(a); ! 430: return r.f; ! 431: } ! 432: ! 433: uint32_t helper_s_to_memory(uint64_t a) ! 434: { ! 435: return s_to_float32_int(a); ! 436: } ! 437: ! 438: uint64_t helper_memory_to_s(uint32_t a) ! 439: { ! 440: return float32_to_s_int(a); ! 441: } ! 442: ! 443: uint64_t helper_adds(CPUAlphaState *env, uint64_t a, uint64_t b) ! 444: { ! 445: float32 fa, fb, fr; ! 446: ! 447: fa = s_to_float32(a); ! 448: fb = s_to_float32(b); ! 449: fr = float32_add(fa, fb, &FP_STATUS); ! 450: return float32_to_s(fr); ! 451: } ! 452: ! 453: uint64_t helper_subs(CPUAlphaState *env, uint64_t a, uint64_t b) ! 454: { ! 455: float32 fa, fb, fr; ! 456: ! 457: fa = s_to_float32(a); ! 458: fb = s_to_float32(b); ! 459: fr = float32_sub(fa, fb, &FP_STATUS); ! 460: return float32_to_s(fr); ! 461: } ! 462: ! 463: uint64_t helper_muls(CPUAlphaState *env, uint64_t a, uint64_t b) ! 464: { ! 465: float32 fa, fb, fr; ! 466: ! 467: fa = s_to_float32(a); ! 468: fb = s_to_float32(b); ! 469: fr = float32_mul(fa, fb, &FP_STATUS); ! 470: return float32_to_s(fr); ! 471: } ! 472: ! 473: uint64_t helper_divs(CPUAlphaState *env, uint64_t a, uint64_t b) ! 474: { ! 475: float32 fa, fb, fr; ! 476: ! 477: fa = s_to_float32(a); ! 478: fb = s_to_float32(b); ! 479: fr = float32_div(fa, fb, &FP_STATUS); ! 480: return float32_to_s(fr); ! 481: } ! 482: ! 483: uint64_t helper_sqrts(CPUAlphaState *env, uint64_t a) ! 484: { ! 485: float32 fa, fr; ! 486: ! 487: fa = s_to_float32(a); ! 488: fr = float32_sqrt(fa, &FP_STATUS); ! 489: return float32_to_s(fr); ! 490: } ! 491: ! 492: ! 493: /* T floating (double) */ ! 494: static inline float64 t_to_float64(uint64_t a) ! 495: { ! 496: /* Memory format is the same as float64 */ ! 497: CPU_DoubleU r; ! 498: r.ll = a; ! 499: return r.d; ! 500: } ! 501: ! 502: static inline uint64_t float64_to_t(float64 fa) ! 503: { ! 504: /* Memory format is the same as float64 */ ! 505: CPU_DoubleU r; ! 506: r.d = fa; ! 507: return r.ll; ! 508: } ! 509: ! 510: uint64_t helper_addt(CPUAlphaState *env, uint64_t a, uint64_t b) ! 511: { ! 512: float64 fa, fb, fr; ! 513: ! 514: fa = t_to_float64(a); ! 515: fb = t_to_float64(b); ! 516: fr = float64_add(fa, fb, &FP_STATUS); ! 517: return float64_to_t(fr); ! 518: } ! 519: ! 520: uint64_t helper_subt(CPUAlphaState *env, uint64_t a, uint64_t b) ! 521: { ! 522: float64 fa, fb, fr; ! 523: ! 524: fa = t_to_float64(a); ! 525: fb = t_to_float64(b); ! 526: fr = float64_sub(fa, fb, &FP_STATUS); ! 527: return float64_to_t(fr); ! 528: } ! 529: ! 530: uint64_t helper_mult(CPUAlphaState *env, uint64_t a, uint64_t b) ! 531: { ! 532: float64 fa, fb, fr; ! 533: ! 534: fa = t_to_float64(a); ! 535: fb = t_to_float64(b); ! 536: fr = float64_mul(fa, fb, &FP_STATUS); ! 537: return float64_to_t(fr); ! 538: } ! 539: ! 540: uint64_t helper_divt(CPUAlphaState *env, uint64_t a, uint64_t b) ! 541: { ! 542: float64 fa, fb, fr; ! 543: ! 544: fa = t_to_float64(a); ! 545: fb = t_to_float64(b); ! 546: fr = float64_div(fa, fb, &FP_STATUS); ! 547: return float64_to_t(fr); ! 548: } ! 549: ! 550: uint64_t helper_sqrtt(CPUAlphaState *env, uint64_t a) ! 551: { ! 552: float64 fa, fr; ! 553: ! 554: fa = t_to_float64(a); ! 555: fr = float64_sqrt(fa, &FP_STATUS); ! 556: return float64_to_t(fr); ! 557: } ! 558: ! 559: /* Comparisons */ ! 560: uint64_t helper_cmptun(CPUAlphaState *env, uint64_t a, uint64_t b) ! 561: { ! 562: float64 fa, fb; ! 563: ! 564: fa = t_to_float64(a); ! 565: fb = t_to_float64(b); ! 566: ! 567: if (float64_unordered_quiet(fa, fb, &FP_STATUS)) { ! 568: return 0x4000000000000000ULL; ! 569: } else { ! 570: return 0; ! 571: } ! 572: } ! 573: ! 574: uint64_t helper_cmpteq(CPUAlphaState *env, uint64_t a, uint64_t b) ! 575: { ! 576: float64 fa, fb; ! 577: ! 578: fa = t_to_float64(a); ! 579: fb = t_to_float64(b); ! 580: ! 581: if (float64_eq_quiet(fa, fb, &FP_STATUS)) { ! 582: return 0x4000000000000000ULL; ! 583: } else { ! 584: return 0; ! 585: } ! 586: } ! 587: ! 588: uint64_t helper_cmptle(CPUAlphaState *env, uint64_t a, uint64_t b) ! 589: { ! 590: float64 fa, fb; ! 591: ! 592: fa = t_to_float64(a); ! 593: fb = t_to_float64(b); ! 594: ! 595: if (float64_le(fa, fb, &FP_STATUS)) { ! 596: return 0x4000000000000000ULL; ! 597: } else { ! 598: return 0; ! 599: } ! 600: } ! 601: ! 602: uint64_t helper_cmptlt(CPUAlphaState *env, uint64_t a, uint64_t b) ! 603: { ! 604: float64 fa, fb; ! 605: ! 606: fa = t_to_float64(a); ! 607: fb = t_to_float64(b); ! 608: ! 609: if (float64_lt(fa, fb, &FP_STATUS)) { ! 610: return 0x4000000000000000ULL; ! 611: } else { ! 612: return 0; ! 613: } ! 614: } ! 615: ! 616: uint64_t helper_cmpgeq(CPUAlphaState *env, uint64_t a, uint64_t b) ! 617: { ! 618: float64 fa, fb; ! 619: ! 620: fa = g_to_float64(env, GETPC(), a); ! 621: fb = g_to_float64(env, GETPC(), b); ! 622: ! 623: if (float64_eq_quiet(fa, fb, &FP_STATUS)) { ! 624: return 0x4000000000000000ULL; ! 625: } else { ! 626: return 0; ! 627: } ! 628: } ! 629: ! 630: uint64_t helper_cmpgle(CPUAlphaState *env, uint64_t a, uint64_t b) ! 631: { ! 632: float64 fa, fb; ! 633: ! 634: fa = g_to_float64(env, GETPC(), a); ! 635: fb = g_to_float64(env, GETPC(), b); ! 636: ! 637: if (float64_le(fa, fb, &FP_STATUS)) { ! 638: return 0x4000000000000000ULL; ! 639: } else { ! 640: return 0; ! 641: } ! 642: } ! 643: ! 644: uint64_t helper_cmpglt(CPUAlphaState *env, uint64_t a, uint64_t b) ! 645: { ! 646: float64 fa, fb; ! 647: ! 648: fa = g_to_float64(env, GETPC(), a); ! 649: fb = g_to_float64(env, GETPC(), b); ! 650: ! 651: if (float64_lt(fa, fb, &FP_STATUS)) { ! 652: return 0x4000000000000000ULL; ! 653: } else { ! 654: return 0; ! 655: } ! 656: } ! 657: ! 658: /* Floating point format conversion */ ! 659: uint64_t helper_cvtts(CPUAlphaState *env, uint64_t a) ! 660: { ! 661: float64 fa; ! 662: float32 fr; ! 663: ! 664: fa = t_to_float64(a); ! 665: fr = float64_to_float32(fa, &FP_STATUS); ! 666: return float32_to_s(fr); ! 667: } ! 668: ! 669: uint64_t helper_cvtst(CPUAlphaState *env, uint64_t a) ! 670: { ! 671: float32 fa; ! 672: float64 fr; ! 673: ! 674: fa = s_to_float32(a); ! 675: fr = float32_to_float64(fa, &FP_STATUS); ! 676: return float64_to_t(fr); ! 677: } ! 678: ! 679: uint64_t helper_cvtqs(CPUAlphaState *env, uint64_t a) ! 680: { ! 681: float32 fr = int64_to_float32(a, &FP_STATUS); ! 682: return float32_to_s(fr); ! 683: } ! 684: ! 685: /* Implement float64 to uint64 conversion without saturation -- we must ! 686: supply the truncated result. This behaviour is used by the compiler ! 687: to get unsigned conversion for free with the same instruction. ! 688: ! 689: The VI flag is set when overflow or inexact exceptions should be raised. */ ! 690: ! 691: static inline uint64_t inline_cvttq(CPUAlphaState *env, uint64_t a, ! 692: int roundmode, int VI) ! 693: { ! 694: uint64_t frac, ret = 0; ! 695: uint32_t exp, sign, exc = 0; ! 696: int shift; ! 697: ! 698: sign = (a >> 63); ! 699: exp = (uint32_t)(a >> 52) & 0x7ff; ! 700: frac = a & 0xfffffffffffffull; ! 701: ! 702: if (exp == 0) { ! 703: if (unlikely(frac != 0)) { ! 704: goto do_underflow; ! 705: } ! 706: } else if (exp == 0x7ff) { ! 707: exc = (frac ? float_flag_invalid : VI ? float_flag_overflow : 0); ! 708: } else { ! 709: /* Restore implicit bit. */ ! 710: frac |= 0x10000000000000ull; ! 711: ! 712: shift = exp - 1023 - 52; ! 713: if (shift >= 0) { ! 714: /* In this case the number is so large that we must shift ! 715: the fraction left. There is no rounding to do. */ ! 716: if (shift < 63) { ! 717: ret = frac << shift; ! 718: if (VI && (ret >> shift) != frac) { ! 719: exc = float_flag_overflow; ! 720: } ! 721: } ! 722: } else { ! 723: uint64_t round; ! 724: ! 725: /* In this case the number is smaller than the fraction as ! 726: represented by the 52 bit number. Here we must think ! 727: about rounding the result. Handle this by shifting the ! 728: fractional part of the number into the high bits of ROUND. ! 729: This will let us efficiently handle round-to-nearest. */ ! 730: shift = -shift; ! 731: if (shift < 63) { ! 732: ret = frac >> shift; ! 733: round = frac << (64 - shift); ! 734: } else { ! 735: /* The exponent is so small we shift out everything. ! 736: Leave a sticky bit for proper rounding below. */ ! 737: do_underflow: ! 738: round = 1; ! 739: } ! 740: ! 741: if (round) { ! 742: exc = (VI ? float_flag_inexact : 0); ! 743: switch (roundmode) { ! 744: case float_round_nearest_even: ! 745: if (round == (1ull << 63)) { ! 746: /* Fraction is exactly 0.5; round to even. */ ! 747: ret += (ret & 1); ! 748: } else if (round > (1ull << 63)) { ! 749: ret += 1; ! 750: } ! 751: break; ! 752: case float_round_to_zero: ! 753: break; ! 754: case float_round_up: ! 755: ret += 1 - sign; ! 756: break; ! 757: case float_round_down: ! 758: ret += sign; ! 759: break; ! 760: } ! 761: } ! 762: } ! 763: if (sign) { ! 764: ret = -ret; ! 765: } ! 766: } ! 767: if (unlikely(exc)) { ! 768: float_raise(exc, &FP_STATUS); ! 769: } ! 770: ! 771: return ret; ! 772: } ! 773: ! 774: uint64_t helper_cvttq(CPUAlphaState *env, uint64_t a) ! 775: { ! 776: return inline_cvttq(env, a, FP_STATUS.float_rounding_mode, 1); ! 777: } ! 778: ! 779: uint64_t helper_cvttq_c(CPUAlphaState *env, uint64_t a) ! 780: { ! 781: return inline_cvttq(env, a, float_round_to_zero, 0); ! 782: } ! 783: ! 784: uint64_t helper_cvttq_svic(CPUAlphaState *env, uint64_t a) ! 785: { ! 786: return inline_cvttq(env, a, float_round_to_zero, 1); ! 787: } ! 788: ! 789: uint64_t helper_cvtqt(CPUAlphaState *env, uint64_t a) ! 790: { ! 791: float64 fr = int64_to_float64(a, &FP_STATUS); ! 792: return float64_to_t(fr); ! 793: } ! 794: ! 795: uint64_t helper_cvtqf(CPUAlphaState *env, uint64_t a) ! 796: { ! 797: float32 fr = int64_to_float32(a, &FP_STATUS); ! 798: return float32_to_f(fr); ! 799: } ! 800: ! 801: uint64_t helper_cvtgf(CPUAlphaState *env, uint64_t a) ! 802: { ! 803: float64 fa; ! 804: float32 fr; ! 805: ! 806: fa = g_to_float64(env, GETPC(), a); ! 807: fr = float64_to_float32(fa, &FP_STATUS); ! 808: return float32_to_f(fr); ! 809: } ! 810: ! 811: uint64_t helper_cvtgq(CPUAlphaState *env, uint64_t a) ! 812: { ! 813: float64 fa = g_to_float64(env, GETPC(), a); ! 814: return float64_to_int64_round_to_zero(fa, &FP_STATUS); ! 815: } ! 816: ! 817: uint64_t helper_cvtqg(CPUAlphaState *env, uint64_t a) ! 818: { ! 819: float64 fr; ! 820: fr = int64_to_float64(a, &FP_STATUS); ! 821: return float64_to_g(fr); ! 822: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.