target-alpha/fpu_helper.c

   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 "exec/helper-proto.h"
  22 #include "fpu/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 }
 823
 824 void helper_fcvtql_v_input(CPUAlphaState *env, uint64_t val)
 825 {
 826     if (val != (int32_t)val) {
 827         arith_excp(env, GETPC(), EXC_M_IOV, 0);
 828     }
 829 }