target-alpha/op_helper.c

   1 /*
   2  *  Alpha emulation cpu micro-operations helpers for qemu.
   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 "exec.h"
  21 #include "host-utils.h"
  22 #include "softfloat.h"
  23 #include "helper.h"
  24
  25 /*****************************************************************************/
  26 /* Exceptions processing helpers */
  27 void helper_excp (int excp, int error)
  28 {
  29     env->exception_index = excp;
  30     env->error_code = error;
  31     cpu_loop_exit();
  32 }
  33
  34 uint64_t helper_load_pcc (void)
  35 {
  36     /* XXX: TODO */
  37     return 0;
  38 }
  39
  40 uint64_t helper_load_fpcr (void)
  41 {
  42     return cpu_alpha_load_fpcr (env);
  43 }
  44
  45 void helper_store_fpcr (uint64_t val)
  46 {
  47     cpu_alpha_store_fpcr (env, val);
  48 }
  49
  50 static spinlock_t intr_cpu_lock = SPIN_LOCK_UNLOCKED;
  51
  52 uint64_t helper_rs(void)
  53 {
  54     uint64_t tmp;
  55
  56     spin_lock(&intr_cpu_lock);
  57     tmp = env->intr_flag;
  58     env->intr_flag = 1;
  59     spin_unlock(&intr_cpu_lock);
  60
  61     return tmp;
  62 }
  63
  64 uint64_t helper_rc(void)
  65 {
  66     uint64_t tmp;
  67
  68     spin_lock(&intr_cpu_lock);
  69     tmp = env->intr_flag;
  70     env->intr_flag = 0;
  71     spin_unlock(&intr_cpu_lock);
  72
  73     return tmp;
  74 }
  75
  76 uint64_t helper_addqv (uint64_t op1, uint64_t op2)
  77 {
  78     uint64_t tmp = op1;
  79     op1 += op2;
  80     if (unlikely((tmp ^ op2 ^ (-1ULL)) & (tmp ^ op1) & (1ULL << 63))) {
  81         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
  82     }
  83     return op1;
  84 }
  85
  86 uint64_t helper_addlv (uint64_t op1, uint64_t op2)
  87 {
  88     uint64_t tmp = op1;
  89     op1 = (uint32_t)(op1 + op2);
  90     if (unlikely((tmp ^ op2 ^ (-1UL)) & (tmp ^ op1) & (1UL << 31))) {
  91         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
  92     }
  93     return op1;
  94 }
  95
  96 uint64_t helper_subqv (uint64_t op1, uint64_t op2)
  97 {
  98     uint64_t res;
  99     res = op1 - op2;
 100     if (unlikely((op1 ^ op2) & (res ^ op1) & (1ULL << 63))) {
 101         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
 102     }
 103     return res;
 104 }
 105
 106 uint64_t helper_sublv (uint64_t op1, uint64_t op2)
 107 {
 108     uint32_t res;
 109     res = op1 - op2;
 110     if (unlikely((op1 ^ op2) & (res ^ op1) & (1UL << 31))) {
 111         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
 112     }
 113     return res;
 114 }
 115
 116 uint64_t helper_mullv (uint64_t op1, uint64_t op2)
 117 {
 118     int64_t res = (int64_t)op1 * (int64_t)op2;
 119
 120     if (unlikely((int32_t)res != res)) {
 121         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
 122     }
 123     return (int64_t)((int32_t)res);
 124 }
 125
 126 uint64_t helper_mulqv (uint64_t op1, uint64_t op2)
 127 {
 128     uint64_t tl, th;
 129
 130     muls64(&tl, &th, op1, op2);
 131     /* If th != 0 && th != -1, then we had an overflow */
 132     if (unlikely((th + 1) > 1)) {
 133         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
 134     }
 135     return tl;
 136 }
 137
 138 uint64_t helper_umulh (uint64_t op1, uint64_t op2)
 139 {
 140     uint64_t tl, th;
 141
 142     mulu64(&tl, &th, op1, op2);
 143     return th;
 144 }
 145
 146 uint64_t helper_ctpop (uint64_t arg)
 147 {
 148     return ctpop64(arg);
 149 }
 150
 151 uint64_t helper_ctlz (uint64_t arg)
 152 {
 153     return clz64(arg);
 154 }
 155
 156 uint64_t helper_cttz (uint64_t arg)
 157 {
 158     return ctz64(arg);
 159 }
 160
 161 static inline uint64_t byte_zap(uint64_t op, uint8_t mskb)
 162 {
 163     uint64_t mask;
 164
 165     mask = 0;
 166     mask |= ((mskb >> 0) & 1) * 0x00000000000000FFULL;
 167     mask |= ((mskb >> 1) & 1) * 0x000000000000FF00ULL;
 168     mask |= ((mskb >> 2) & 1) * 0x0000000000FF0000ULL;
 169     mask |= ((mskb >> 3) & 1) * 0x00000000FF000000ULL;
 170     mask |= ((mskb >> 4) & 1) * 0x000000FF00000000ULL;
 171     mask |= ((mskb >> 5) & 1) * 0x0000FF0000000000ULL;
 172     mask |= ((mskb >> 6) & 1) * 0x00FF000000000000ULL;
 173     mask |= ((mskb >> 7) & 1) * 0xFF00000000000000ULL;
 174
 175     return op & ~mask;
 176 }
 177
 178 uint64_t helper_mskbl(uint64_t val, uint64_t mask)
 179 {
 180     return byte_zap(val, 0x01 << (mask & 7));
 181 }
 182
 183 uint64_t helper_insbl(uint64_t val, uint64_t mask)
 184 {
 185     val <<= (mask & 7) * 8;
 186     return byte_zap(val, ~(0x01 << (mask & 7)));
 187 }
 188
 189 uint64_t helper_mskwl(uint64_t val, uint64_t mask)
 190 {
 191     return byte_zap(val, 0x03 << (mask & 7));
 192 }
 193
 194 uint64_t helper_inswl(uint64_t val, uint64_t mask)
 195 {
 196     val <<= (mask & 7) * 8;
 197     return byte_zap(val, ~(0x03 << (mask & 7)));
 198 }
 199
 200 uint64_t helper_mskll(uint64_t val, uint64_t mask)
 201 {
 202     return byte_zap(val, 0x0F << (mask & 7));
 203 }
 204
 205 uint64_t helper_insll(uint64_t val, uint64_t mask)
 206 {
 207     val <<= (mask & 7) * 8;
 208     return byte_zap(val, ~(0x0F << (mask & 7)));
 209 }
 210
 211 uint64_t helper_zap(uint64_t val, uint64_t mask)
 212 {
 213     return byte_zap(val, mask);
 214 }
 215
 216 uint64_t helper_zapnot(uint64_t val, uint64_t mask)
 217 {
 218     return byte_zap(val, ~mask);
 219 }
 220
 221 uint64_t helper_mskql(uint64_t val, uint64_t mask)
 222 {
 223     return byte_zap(val, 0xFF << (mask & 7));
 224 }
 225
 226 uint64_t helper_insql(uint64_t val, uint64_t mask)
 227 {
 228     val <<= (mask & 7) * 8;
 229     return byte_zap(val, ~(0xFF << (mask & 7)));
 230 }
 231
 232 uint64_t helper_mskwh(uint64_t val, uint64_t mask)
 233 {
 234     return byte_zap(val, (0x03 << (mask & 7)) >> 8);
 235 }
 236
 237 uint64_t helper_inswh(uint64_t val, uint64_t mask)
 238 {
 239     val >>= 64 - ((mask & 7) * 8);
 240     return byte_zap(val, ~((0x03 << (mask & 7)) >> 8));
 241 }
 242
 243 uint64_t helper_msklh(uint64_t val, uint64_t mask)
 244 {
 245     return byte_zap(val, (0x0F << (mask & 7)) >> 8);
 246 }
 247
 248 uint64_t helper_inslh(uint64_t val, uint64_t mask)
 249 {
 250     val >>= 64 - ((mask & 7) * 8);
 251     return byte_zap(val, ~((0x0F << (mask & 7)) >> 8));
 252 }
 253
 254 uint64_t helper_mskqh(uint64_t val, uint64_t mask)
 255 {
 256     return byte_zap(val, (0xFF << (mask & 7)) >> 8);
 257 }
 258
 259 uint64_t helper_insqh(uint64_t val, uint64_t mask)
 260 {
 261     val >>= 64 - ((mask & 7) * 8);
 262     return byte_zap(val, ~((0xFF << (mask & 7)) >> 8));
 263 }
 264
 265 uint64_t helper_cmpbge (uint64_t op1, uint64_t op2)
 266 {
 267     uint8_t opa, opb, res;
 268     int i;
 269
 270     res = 0;
 271     for (i = 0; i < 8; i++) {
 272         opa = op1 >> (i * 8);
 273         opb = op2 >> (i * 8);
 274         if (opa >= opb)
 275             res |= 1 << i;
 276     }
 277     return res;
 278 }
 279
 280 uint64_t helper_minub8 (uint64_t op1, uint64_t op2)
 281 {
 282     uint64_t res = 0;
 283     uint8_t opa, opb, opr;
 284     int i;
 285
 286     for (i = 0; i < 8; ++i) {
 287         opa = op1 >> (i * 8);
 288         opb = op2 >> (i * 8);
 289         opr = opa < opb ? opa : opb;
 290         res |= (uint64_t)opr << (i * 8);
 291     }
 292     return res;
 293 }
 294
 295 uint64_t helper_minsb8 (uint64_t op1, uint64_t op2)
 296 {
 297     uint64_t res = 0;
 298     int8_t opa, opb;
 299     uint8_t opr;
 300     int i;
 301
 302     for (i = 0; i < 8; ++i) {
 303         opa = op1 >> (i * 8);
 304         opb = op2 >> (i * 8);
 305         opr = opa < opb ? opa : opb;
 306         res |= (uint64_t)opr << (i * 8);
 307     }
 308     return res;
 309 }
 310
 311 uint64_t helper_minuw4 (uint64_t op1, uint64_t op2)
 312 {
 313     uint64_t res = 0;
 314     uint16_t opa, opb, opr;
 315     int i;
 316
 317     for (i = 0; i < 4; ++i) {
 318         opa = op1 >> (i * 16);
 319         opb = op2 >> (i * 16);
 320         opr = opa < opb ? opa : opb;
 321         res |= (uint64_t)opr << (i * 16);
 322     }
 323     return res;
 324 }
 325
 326 uint64_t helper_minsw4 (uint64_t op1, uint64_t op2)
 327 {
 328     uint64_t res = 0;
 329     int16_t opa, opb;
 330     uint16_t opr;
 331     int i;
 332
 333     for (i = 0; i < 4; ++i) {
 334         opa = op1 >> (i * 16);
 335         opb = op2 >> (i * 16);
 336         opr = opa < opb ? opa : opb;
 337         res |= (uint64_t)opr << (i * 16);
 338     }
 339     return res;
 340 }
 341
 342 uint64_t helper_maxub8 (uint64_t op1, uint64_t op2)
 343 {
 344     uint64_t res = 0;
 345     uint8_t opa, opb, opr;
 346     int i;
 347
 348     for (i = 0; i < 8; ++i) {
 349         opa = op1 >> (i * 8);
 350         opb = op2 >> (i * 8);
 351         opr = opa > opb ? opa : opb;
 352         res |= (uint64_t)opr << (i * 8);
 353     }
 354     return res;
 355 }
 356
 357 uint64_t helper_maxsb8 (uint64_t op1, uint64_t op2)
 358 {
 359     uint64_t res = 0;
 360     int8_t opa, opb;
 361     uint8_t opr;
 362     int i;
 363
 364     for (i = 0; i < 8; ++i) {
 365         opa = op1 >> (i * 8);
 366         opb = op2 >> (i * 8);
 367         opr = opa > opb ? opa : opb;
 368         res |= (uint64_t)opr << (i * 8);
 369     }
 370     return res;
 371 }
 372
 373 uint64_t helper_maxuw4 (uint64_t op1, uint64_t op2)
 374 {
 375     uint64_t res = 0;
 376     uint16_t opa, opb, opr;
 377     int i;
 378
 379     for (i = 0; i < 4; ++i) {
 380         opa = op1 >> (i * 16);
 381         opb = op2 >> (i * 16);
 382         opr = opa > opb ? opa : opb;
 383         res |= (uint64_t)opr << (i * 16);
 384     }
 385     return res;
 386 }
 387
 388 uint64_t helper_maxsw4 (uint64_t op1, uint64_t op2)
 389 {
 390     uint64_t res = 0;
 391     int16_t opa, opb;
 392     uint16_t opr;
 393     int i;
 394
 395     for (i = 0; i < 4; ++i) {
 396         opa = op1 >> (i * 16);
 397         opb = op2 >> (i * 16);
 398         opr = opa > opb ? opa : opb;
 399         res |= (uint64_t)opr << (i * 16);
 400     }
 401     return res;
 402 }
 403
 404 uint64_t helper_perr (uint64_t op1, uint64_t op2)
 405 {
 406     uint64_t res = 0;
 407     uint8_t opa, opb, opr;
 408     int i;
 409
 410     for (i = 0; i < 8; ++i) {
 411         opa = op1 >> (i * 8);
 412         opb = op2 >> (i * 8);
 413         if (opa >= opb)
 414             opr = opa - opb;
 415         else
 416             opr = opb - opa;
 417         res += opr;
 418     }
 419     return res;
 420 }
 421
 422 uint64_t helper_pklb (uint64_t op1)
 423 {
 424     return (op1 & 0xff) | ((op1 >> 24) & 0xff00);
 425 }
 426
 427 uint64_t helper_pkwb (uint64_t op1)
 428 {
 429     return ((op1 & 0xff)
 430             | ((op1 >> 8) & 0xff00)
 431             | ((op1 >> 16) & 0xff0000)
 432             | ((op1 >> 24) & 0xff000000));
 433 }
 434
 435 uint64_t helper_unpkbl (uint64_t op1)
 436 {
 437     return (op1 & 0xff) | ((op1 & 0xff00) << 24);
 438 }
 439
 440 uint64_t helper_unpkbw (uint64_t op1)
 441 {
 442     return ((op1 & 0xff)
 443             | ((op1 & 0xff00) << 8)
 444             | ((op1 & 0xff0000) << 16)
 445             | ((op1 & 0xff000000) << 24));
 446 }
 447
 448 /* Floating point helpers */
 449
 450 /* F floating (VAX) */
 451 static inline uint64_t float32_to_f(float32 fa)
 452 {
 453     uint64_t r, exp, mant, sig;
 454     CPU_FloatU a;
 455
 456     a.f = fa;
 457     sig = ((uint64_t)a.l & 0x80000000) << 32;
 458     exp = (a.l >> 23) & 0xff;
 459     mant = ((uint64_t)a.l & 0x007fffff) << 29;
 460
 461     if (exp == 255) {
 462         /* NaN or infinity */
 463         r = 1; /* VAX dirty zero */
 464     } else if (exp == 0) {
 465         if (mant == 0) {
 466             /* Zero */
 467             r = 0;
 468         } else {
 469             /* Denormalized */
 470             r = sig | ((exp + 1) << 52) | mant;
 471         }
 472     } else {
 473         if (exp >= 253) {
 474             /* Overflow */
 475             r = 1; /* VAX dirty zero */
 476         } else {
 477             r = sig | ((exp + 2) << 52);
 478         }
 479     }
 480
 481     return r;
 482 }
 483
 484 static inline float32 f_to_float32(uint64_t a)
 485 {
 486     uint32_t exp, mant_sig;
 487     CPU_FloatU r;
 488
 489     exp = ((a >> 55) & 0x80) | ((a >> 52) & 0x7f);
 490     mant_sig = ((a >> 32) & 0x80000000) | ((a >> 29) & 0x007fffff);
 491
 492     if (unlikely(!exp && mant_sig)) {
 493         /* Reserved operands / Dirty zero */
 494         helper_excp(EXCP_OPCDEC, 0);
 495     }
 496
 497     if (exp < 3) {
 498         /* Underflow */
 499         r.l = 0;
 500     } else {
 501         r.l = ((exp - 2) << 23) | mant_sig;
 502     }
 503
 504     return r.f;
 505 }
 506
 507 uint32_t helper_f_to_memory (uint64_t a)
 508 {
 509     uint32_t r;
 510     r =  (a & 0x00001fffe0000000ull) >> 13;
 511     r |= (a & 0x07ffe00000000000ull) >> 45;
 512     r |= (a & 0xc000000000000000ull) >> 48;
 513     return r;
 514 }
 515
 516 uint64_t helper_memory_to_f (uint32_t a)
 517 {
 518     uint64_t r;
 519     r =  ((uint64_t)(a & 0x0000c000)) << 48;
 520     r |= ((uint64_t)(a & 0x003fffff)) << 45;
 521     r |= ((uint64_t)(a & 0xffff0000)) << 13;
 522     if (!(a & 0x00004000))
 523         r |= 0x7ll << 59;
 524     return r;
 525 }
 526
 527 uint64_t helper_addf (uint64_t a, uint64_t b)
 528 {
 529     float32 fa, fb, fr;
 530
 531     fa = f_to_float32(a);
 532     fb = f_to_float32(b);
 533     fr = float32_add(fa, fb, &FP_STATUS);
 534     return float32_to_f(fr);
 535 }
 536
 537 uint64_t helper_subf (uint64_t a, uint64_t b)
 538 {
 539     float32 fa, fb, fr;
 540
 541     fa = f_to_float32(a);
 542     fb = f_to_float32(b);
 543     fr = float32_sub(fa, fb, &FP_STATUS);
 544     return float32_to_f(fr);
 545 }
 546
 547 uint64_t helper_mulf (uint64_t a, uint64_t b)
 548 {
 549     float32 fa, fb, fr;
 550
 551     fa = f_to_float32(a);
 552     fb = f_to_float32(b);
 553     fr = float32_mul(fa, fb, &FP_STATUS);
 554     return float32_to_f(fr);
 555 }
 556
 557 uint64_t helper_divf (uint64_t a, uint64_t b)
 558 {
 559     float32 fa, fb, fr;
 560
 561     fa = f_to_float32(a);
 562     fb = f_to_float32(b);
 563     fr = float32_div(fa, fb, &FP_STATUS);
 564     return float32_to_f(fr);
 565 }
 566
 567 uint64_t helper_sqrtf (uint64_t t)
 568 {
 569     float32 ft, fr;
 570
 571     ft = f_to_float32(t);
 572     fr = float32_sqrt(ft, &FP_STATUS);
 573     return float32_to_f(fr);
 574 }
 575
 576
 577 /* G floating (VAX) */
 578 static inline uint64_t float64_to_g(float64 fa)
 579 {
 580     uint64_t r, exp, mant, sig;
 581     CPU_DoubleU a;
 582
 583     a.d = fa;
 584     sig = a.ll & 0x8000000000000000ull;
 585     exp = (a.ll >> 52) & 0x7ff;
 586     mant = a.ll & 0x000fffffffffffffull;
 587
 588     if (exp == 2047) {
 589         /* NaN or infinity */
 590         r = 1; /* VAX dirty zero */
 591     } else if (exp == 0) {
 592         if (mant == 0) {
 593             /* Zero */
 594             r = 0;
 595         } else {
 596             /* Denormalized */
 597             r = sig | ((exp + 1) << 52) | mant;
 598         }
 599     } else {
 600         if (exp >= 2045) {
 601             /* Overflow */
 602             r = 1; /* VAX dirty zero */
 603         } else {
 604             r = sig | ((exp + 2) << 52);
 605         }
 606     }
 607
 608     return r;
 609 }
 610
 611 static inline float64 g_to_float64(uint64_t a)
 612 {
 613     uint64_t exp, mant_sig;
 614     CPU_DoubleU r;
 615
 616     exp = (a >> 52) & 0x7ff;
 617     mant_sig = a & 0x800fffffffffffffull;
 618
 619     if (!exp && mant_sig) {
 620         /* Reserved operands / Dirty zero */
 621         helper_excp(EXCP_OPCDEC, 0);
 622     }
 623
 624     if (exp < 3) {
 625         /* Underflow */
 626         r.ll = 0;
 627     } else {
 628         r.ll = ((exp - 2) << 52) | mant_sig;
 629     }
 630
 631     return r.d;
 632 }
 633
 634 uint64_t helper_g_to_memory (uint64_t a)
 635 {
 636     uint64_t r;
 637     r =  (a & 0x000000000000ffffull) << 48;
 638     r |= (a & 0x00000000ffff0000ull) << 16;
 639     r |= (a & 0x0000ffff00000000ull) >> 16;
 640     r |= (a & 0xffff000000000000ull) >> 48;
 641     return r;
 642 }
 643
 644 uint64_t helper_memory_to_g (uint64_t a)
 645 {
 646     uint64_t r;
 647     r =  (a & 0x000000000000ffffull) << 48;
 648     r |= (a & 0x00000000ffff0000ull) << 16;
 649     r |= (a & 0x0000ffff00000000ull) >> 16;
 650     r |= (a & 0xffff000000000000ull) >> 48;
 651     return r;
 652 }
 653
 654 uint64_t helper_addg (uint64_t a, uint64_t b)
 655 {
 656     float64 fa, fb, fr;
 657
 658     fa = g_to_float64(a);
 659     fb = g_to_float64(b);
 660     fr = float64_add(fa, fb, &FP_STATUS);
 661     return float64_to_g(fr);
 662 }
 663
 664 uint64_t helper_subg (uint64_t a, uint64_t b)
 665 {
 666     float64 fa, fb, fr;
 667
 668     fa = g_to_float64(a);
 669     fb = g_to_float64(b);
 670     fr = float64_sub(fa, fb, &FP_STATUS);
 671     return float64_to_g(fr);
 672 }
 673
 674 uint64_t helper_mulg (uint64_t a, uint64_t b)
 675 {
 676     float64 fa, fb, fr;
 677
 678     fa = g_to_float64(a);
 679     fb = g_to_float64(b);
 680     fr = float64_mul(fa, fb, &FP_STATUS);
 681     return float64_to_g(fr);
 682 }
 683
 684 uint64_t helper_divg (uint64_t a, uint64_t b)
 685 {
 686     float64 fa, fb, fr;
 687
 688     fa = g_to_float64(a);
 689     fb = g_to_float64(b);
 690     fr = float64_div(fa, fb, &FP_STATUS);
 691     return float64_to_g(fr);
 692 }
 693
 694 uint64_t helper_sqrtg (uint64_t a)
 695 {
 696     float64 fa, fr;
 697
 698     fa = g_to_float64(a);
 699     fr = float64_sqrt(fa, &FP_STATUS);
 700     return float64_to_g(fr);
 701 }
 702
 703
 704 /* S floating (single) */
 705 static inline uint64_t float32_to_s(float32 fa)
 706 {
 707     CPU_FloatU a;
 708     uint64_t r;
 709
 710     a.f = fa;
 711
 712     r = (((uint64_t)(a.l & 0xc0000000)) << 32) | (((uint64_t)(a.l & 0x3fffffff)) << 29);
 713     if (((a.l & 0x7f800000) != 0x7f800000) && (!(a.l & 0x40000000)))
 714         r |= 0x7ll << 59;
 715     return r;
 716 }
 717
 718 static inline float32 s_to_float32(uint64_t a)
 719 {
 720     CPU_FloatU r;
 721     r.l = ((a >> 32) & 0xc0000000) | ((a >> 29) & 0x3fffffff);
 722     return r.f;
 723 }
 724
 725 uint32_t helper_s_to_memory (uint64_t a)
 726 {
 727     /* Memory format is the same as float32 */
 728     float32 fa = s_to_float32(a);
 729     return *(uint32_t*)(&fa);
 730 }
 731
 732 uint64_t helper_memory_to_s (uint32_t a)
 733 {
 734     /* Memory format is the same as float32 */
 735     return float32_to_s(*(float32*)(&a));
 736 }
 737
 738 uint64_t helper_adds (uint64_t a, uint64_t b)
 739 {
 740     float32 fa, fb, fr;
 741
 742     fa = s_to_float32(a);
 743     fb = s_to_float32(b);
 744     fr = float32_add(fa, fb, &FP_STATUS);
 745     return float32_to_s(fr);
 746 }
 747
 748 uint64_t helper_subs (uint64_t a, uint64_t b)
 749 {
 750     float32 fa, fb, fr;
 751
 752     fa = s_to_float32(a);
 753     fb = s_to_float32(b);
 754     fr = float32_sub(fa, fb, &FP_STATUS);
 755     return float32_to_s(fr);
 756 }
 757
 758 uint64_t helper_muls (uint64_t a, uint64_t b)
 759 {
 760     float32 fa, fb, fr;
 761
 762     fa = s_to_float32(a);
 763     fb = s_to_float32(b);
 764     fr = float32_mul(fa, fb, &FP_STATUS);
 765     return float32_to_s(fr);
 766 }
 767
 768 uint64_t helper_divs (uint64_t a, uint64_t b)
 769 {
 770     float32 fa, fb, fr;
 771
 772     fa = s_to_float32(a);
 773     fb = s_to_float32(b);
 774     fr = float32_div(fa, fb, &FP_STATUS);
 775     return float32_to_s(fr);
 776 }
 777
 778 uint64_t helper_sqrts (uint64_t a)
 779 {
 780     float32 fa, fr;
 781
 782     fa = s_to_float32(a);
 783     fr = float32_sqrt(fa, &FP_STATUS);
 784     return float32_to_s(fr);
 785 }
 786
 787
 788 /* T floating (double) */
 789 static inline float64 t_to_float64(uint64_t a)
 790 {
 791     /* Memory format is the same as float64 */
 792     CPU_DoubleU r;
 793     r.ll = a;
 794     return r.d;
 795 }
 796
 797 static inline uint64_t float64_to_t(float64 fa)
 798 {
 799     /* Memory format is the same as float64 */
 800     CPU_DoubleU r;
 801     r.d = fa;
 802     return r.ll;
 803 }
 804
 805 uint64_t helper_addt (uint64_t a, uint64_t b)
 806 {
 807     float64 fa, fb, fr;
 808
 809     fa = t_to_float64(a);
 810     fb = t_to_float64(b);
 811     fr = float64_add(fa, fb, &FP_STATUS);
 812     return float64_to_t(fr);
 813 }
 814
 815 uint64_t helper_subt (uint64_t a, uint64_t b)
 816 {
 817     float64 fa, fb, fr;
 818
 819     fa = t_to_float64(a);
 820     fb = t_to_float64(b);
 821     fr = float64_sub(fa, fb, &FP_STATUS);
 822     return float64_to_t(fr);
 823 }
 824
 825 uint64_t helper_mult (uint64_t a, uint64_t b)
 826 {
 827     float64 fa, fb, fr;
 828
 829     fa = t_to_float64(a);
 830     fb = t_to_float64(b);
 831     fr = float64_mul(fa, fb, &FP_STATUS);
 832     return float64_to_t(fr);
 833 }
 834
 835 uint64_t helper_divt (uint64_t a, uint64_t b)
 836 {
 837     float64 fa, fb, fr;
 838
 839     fa = t_to_float64(a);
 840     fb = t_to_float64(b);
 841     fr = float64_div(fa, fb, &FP_STATUS);
 842     return float64_to_t(fr);
 843 }
 844
 845 uint64_t helper_sqrtt (uint64_t a)
 846 {
 847     float64 fa, fr;
 848
 849     fa = t_to_float64(a);
 850     fr = float64_sqrt(fa, &FP_STATUS);
 851     return float64_to_t(fr);
 852 }
 853
 854
 855 /* Sign copy */
 856 uint64_t helper_cpys(uint64_t a, uint64_t b)
 857 {
 858     return (a & 0x8000000000000000ULL) | (b & ~0x8000000000000000ULL);
 859 }
 860
 861 uint64_t helper_cpysn(uint64_t a, uint64_t b)
 862 {
 863     return ((~a) & 0x8000000000000000ULL) | (b & ~0x8000000000000000ULL);
 864 }
 865
 866 uint64_t helper_cpyse(uint64_t a, uint64_t b)
 867 {
 868     return (a & 0xFFF0000000000000ULL) | (b & ~0xFFF0000000000000ULL);
 869 }
 870
 871
 872 /* Comparisons */
 873 uint64_t helper_cmptun (uint64_t a, uint64_t b)
 874 {
 875     float64 fa, fb;
 876
 877     fa = t_to_float64(a);
 878     fb = t_to_float64(b);
 879
 880     if (float64_is_nan(fa) || float64_is_nan(fb))
 881         return 0x4000000000000000ULL;
 882     else
 883         return 0;
 884 }
 885
 886 uint64_t helper_cmpteq(uint64_t a, uint64_t b)
 887 {
 888     float64 fa, fb;
 889
 890     fa = t_to_float64(a);
 891     fb = t_to_float64(b);
 892
 893     if (float64_eq(fa, fb, &FP_STATUS))
 894         return 0x4000000000000000ULL;
 895     else
 896         return 0;
 897 }
 898
 899 uint64_t helper_cmptle(uint64_t a, uint64_t b)
 900 {
 901     float64 fa, fb;
 902
 903     fa = t_to_float64(a);
 904     fb = t_to_float64(b);
 905
 906     if (float64_le(fa, fb, &FP_STATUS))
 907         return 0x4000000000000000ULL;
 908     else
 909         return 0;
 910 }
 911
 912 uint64_t helper_cmptlt(uint64_t a, uint64_t b)
 913 {
 914     float64 fa, fb;
 915
 916     fa = t_to_float64(a);
 917     fb = t_to_float64(b);
 918
 919     if (float64_lt(fa, fb, &FP_STATUS))
 920         return 0x4000000000000000ULL;
 921     else
 922         return 0;
 923 }
 924
 925 uint64_t helper_cmpgeq(uint64_t a, uint64_t b)
 926 {
 927     float64 fa, fb;
 928
 929     fa = g_to_float64(a);
 930     fb = g_to_float64(b);
 931
 932     if (float64_eq(fa, fb, &FP_STATUS))
 933         return 0x4000000000000000ULL;
 934     else
 935         return 0;
 936 }
 937
 938 uint64_t helper_cmpgle(uint64_t a, uint64_t b)
 939 {
 940     float64 fa, fb;
 941
 942     fa = g_to_float64(a);
 943     fb = g_to_float64(b);
 944
 945     if (float64_le(fa, fb, &FP_STATUS))
 946         return 0x4000000000000000ULL;
 947     else
 948         return 0;
 949 }
 950
 951 uint64_t helper_cmpglt(uint64_t a, uint64_t b)
 952 {
 953     float64 fa, fb;
 954
 955     fa = g_to_float64(a);
 956     fb = g_to_float64(b);
 957
 958     if (float64_lt(fa, fb, &FP_STATUS))
 959         return 0x4000000000000000ULL;
 960     else
 961         return 0;
 962 }
 963
 964 uint64_t helper_cmpfeq (uint64_t a)
 965 {
 966     return !(a & 0x7FFFFFFFFFFFFFFFULL);
 967 }
 968
 969 uint64_t helper_cmpfne (uint64_t a)
 970 {
 971     return (a & 0x7FFFFFFFFFFFFFFFULL);
 972 }
 973
 974 uint64_t helper_cmpflt (uint64_t a)
 975 {
 976     return (a & 0x8000000000000000ULL) && (a & 0x7FFFFFFFFFFFFFFFULL);
 977 }
 978
 979 uint64_t helper_cmpfle (uint64_t a)
 980 {
 981     return (a & 0x8000000000000000ULL) || !(a & 0x7FFFFFFFFFFFFFFFULL);
 982 }
 983
 984 uint64_t helper_cmpfgt (uint64_t a)
 985 {
 986     return !(a & 0x8000000000000000ULL) && (a & 0x7FFFFFFFFFFFFFFFULL);
 987 }
 988
 989 uint64_t helper_cmpfge (uint64_t a)
 990 {
 991     return !(a & 0x8000000000000000ULL) || !(a & 0x7FFFFFFFFFFFFFFFULL);
 992 }
 993
 994
 995 /* Floating point format conversion */
 996 uint64_t helper_cvtts (uint64_t a)
 997 {
 998     float64 fa;
 999     float32 fr;
1000
1001     fa = t_to_float64(a);
1002     fr = float64_to_float32(fa, &FP_STATUS);
1003     return float32_to_s(fr);
1004 }
1005
1006 uint64_t helper_cvtst (uint64_t a)
1007 {
1008     float32 fa;
1009     float64 fr;
1010
1011     fa = s_to_float32(a);
1012     fr = float32_to_float64(fa, &FP_STATUS);
1013     return float64_to_t(fr);
1014 }
1015
1016 uint64_t helper_cvtqs (uint64_t a)
1017 {
1018     float32 fr = int64_to_float32(a, &FP_STATUS);
1019     return float32_to_s(fr);
1020 }
1021
1022 uint64_t helper_cvttq (uint64_t a)
1023 {
1024     float64 fa = t_to_float64(a);
1025     return float64_to_int64_round_to_zero(fa, &FP_STATUS);
1026 }
1027
1028 uint64_t helper_cvtqt (uint64_t a)
1029 {
1030     float64 fr = int64_to_float64(a, &FP_STATUS);
1031     return float64_to_t(fr);
1032 }
1033
1034 uint64_t helper_cvtqf (uint64_t a)
1035 {
1036     float32 fr = int64_to_float32(a, &FP_STATUS);
1037     return float32_to_f(fr);
1038 }
1039
1040 uint64_t helper_cvtgf (uint64_t a)
1041 {
1042     float64 fa;
1043     float32 fr;
1044
1045     fa = g_to_float64(a);
1046     fr = float64_to_float32(fa, &FP_STATUS);
1047     return float32_to_f(fr);
1048 }
1049
1050 uint64_t helper_cvtgq (uint64_t a)
1051 {
1052     float64 fa = g_to_float64(a);
1053     return float64_to_int64_round_to_zero(fa, &FP_STATUS);
1054 }
1055
1056 uint64_t helper_cvtqg (uint64_t a)
1057 {
1058     float64 fr;
1059     fr = int64_to_float64(a, &FP_STATUS);
1060     return float64_to_g(fr);
1061 }
1062
1063 uint64_t helper_cvtlq (uint64_t a)
1064 {
1065     return (int64_t)((int32_t)((a >> 32) | ((a >> 29) & 0x3FFFFFFF)));
1066 }
1067
1068 static inline uint64_t __helper_cvtql(uint64_t a, int s, int v)
1069 {
1070     uint64_t r;
1071
1072     r = ((uint64_t)(a & 0xC0000000)) << 32;
1073     r |= ((uint64_t)(a & 0x7FFFFFFF)) << 29;
1074
1075     if (v && (int64_t)((int32_t)r) != (int64_t)r) {
1076         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
1077     }
1078     if (s) {
1079         /* TODO */
1080     }
1081     return r;
1082 }
1083
1084 uint64_t helper_cvtql (uint64_t a)
1085 {
1086     return __helper_cvtql(a, 0, 0);
1087 }
1088
1089 uint64_t helper_cvtqlv (uint64_t a)
1090 {
1091     return __helper_cvtql(a, 0, 1);
1092 }
1093
1094 uint64_t helper_cvtqlsv (uint64_t a)
1095 {
1096     return __helper_cvtql(a, 1, 1);
1097 }
1098
1099 /* PALcode support special instructions */
1100 #if !defined (CONFIG_USER_ONLY)
1101 void helper_hw_rei (void)
1102 {
1103     env->pc = env->ipr[IPR_EXC_ADDR] & ~3;
1104     env->ipr[IPR_EXC_ADDR] = env->ipr[IPR_EXC_ADDR] & 1;
1105     /* XXX: re-enable interrupts and memory mapping */
1106 }
1107
1108 void helper_hw_ret (uint64_t a)
1109 {
1110     env->pc = a & ~3;
1111     env->ipr[IPR_EXC_ADDR] = a & 1;
1112     /* XXX: re-enable interrupts and memory mapping */
1113 }
1114
1115 uint64_t helper_mfpr (int iprn, uint64_t val)
1116 {
1117     uint64_t tmp;
1118
1119     if (cpu_alpha_mfpr(env, iprn, &tmp) == 0)
1120         val = tmp;
1121
1122     return val;
1123 }
1124
1125 void helper_mtpr (int iprn, uint64_t val)
1126 {
1127     cpu_alpha_mtpr(env, iprn, val, NULL);
1128 }
1129
1130 void helper_set_alt_mode (void)
1131 {
1132     env->saved_mode = env->ps & 0xC;
1133     env->ps = (env->ps & ~0xC) | (env->ipr[IPR_ALT_MODE] & 0xC);
1134 }
1135
1136 void helper_restore_mode (void)
1137 {
1138     env->ps = (env->ps & ~0xC) | env->saved_mode;
1139 }
1140
1141 #endif
1142
1143 /*****************************************************************************/
1144 /* Softmmu support */
1145 #if !defined (CONFIG_USER_ONLY)
1146
1147 /* XXX: the two following helpers are pure hacks.
1148  *      Hopefully, we emulate the PALcode, then we should never see
1149  *      HW_LD / HW_ST instructions.
1150  */
1151 uint64_t helper_ld_virt_to_phys (uint64_t virtaddr)
1152 {
1153     uint64_t tlb_addr, physaddr;
1154     int index, mmu_idx;
1155     void *retaddr;
1156
1157     mmu_idx = cpu_mmu_index(env);
1158     index = (virtaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1159  redo:
1160     tlb_addr = env->tlb_table[mmu_idx][index].addr_read;
1161     if ((virtaddr & TARGET_PAGE_MASK) ==
1162         (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
1163         physaddr = virtaddr + env->tlb_table[mmu_idx][index].addend;
1164     } else {
1165         /* the page is not in the TLB : fill it */
1166         retaddr = GETPC();
1167         tlb_fill(virtaddr, 0, mmu_idx, retaddr);
1168         goto redo;
1169     }
1170     return physaddr;
1171 }
1172
1173 uint64_t helper_st_virt_to_phys (uint64_t virtaddr)
1174 {
1175     uint64_t tlb_addr, physaddr;
1176     int index, mmu_idx;
1177     void *retaddr;
1178
1179     mmu_idx = cpu_mmu_index(env);
1180     index = (virtaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1181  redo:
1182     tlb_addr = env->tlb_table[mmu_idx][index].addr_write;
1183     if ((virtaddr & TARGET_PAGE_MASK) ==
1184         (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
1185         physaddr = virtaddr + env->tlb_table[mmu_idx][index].addend;
1186     } else {
1187         /* the page is not in the TLB : fill it */
1188         retaddr = GETPC();
1189         tlb_fill(virtaddr, 1, mmu_idx, retaddr);
1190         goto redo;
1191     }
1192     return physaddr;
1193 }
1194
1195 void helper_ldl_raw(uint64_t t0, uint64_t t1)
1196 {
1197     ldl_raw(t1, t0);
1198 }
1199
1200 void helper_ldq_raw(uint64_t t0, uint64_t t1)
1201 {
1202     ldq_raw(t1, t0);
1203 }
1204
1205 void helper_ldl_l_raw(uint64_t t0, uint64_t t1)
1206 {
1207     env->lock = t1;
1208     ldl_raw(t1, t0);
1209 }
1210
1211 void helper_ldq_l_raw(uint64_t t0, uint64_t t1)
1212 {
1213     env->lock = t1;
1214     ldl_raw(t1, t0);
1215 }
1216
1217 void helper_ldl_kernel(uint64_t t0, uint64_t t1)
1218 {
1219     ldl_kernel(t1, t0);
1220 }
1221
1222 void helper_ldq_kernel(uint64_t t0, uint64_t t1)
1223 {
1224     ldq_kernel(t1, t0);
1225 }
1226
1227 void helper_ldl_data(uint64_t t0, uint64_t t1)
1228 {
1229     ldl_data(t1, t0);
1230 }
1231
1232 void helper_ldq_data(uint64_t t0, uint64_t t1)
1233 {
1234     ldq_data(t1, t0);
1235 }
1236
1237 void helper_stl_raw(uint64_t t0, uint64_t t1)
1238 {
1239     stl_raw(t1, t0);
1240 }
1241
1242 void helper_stq_raw(uint64_t t0, uint64_t t1)
1243 {
1244     stq_raw(t1, t0);
1245 }
1246
1247 uint64_t helper_stl_c_raw(uint64_t t0, uint64_t t1)
1248 {
1249     uint64_t ret;
1250
1251     if (t1 == env->lock) {
1252         stl_raw(t1, t0);
1253         ret = 0;
1254     } else
1255         ret = 1;
1256
1257     env->lock = 1;
1258
1259     return ret;
1260 }
1261
1262 uint64_t helper_stq_c_raw(uint64_t t0, uint64_t t1)
1263 {
1264     uint64_t ret;
1265
1266     if (t1 == env->lock) {
1267         stq_raw(t1, t0);
1268         ret = 0;
1269     } else
1270         ret = 1;
1271
1272     env->lock = 1;
1273
1274     return ret;
1275 }
1276
1277 #define MMUSUFFIX _mmu
1278
1279 #define SHIFT 0
1280 #include "softmmu_template.h"
1281
1282 #define SHIFT 1
1283 #include "softmmu_template.h"
1284
1285 #define SHIFT 2
1286 #include "softmmu_template.h"
1287
1288 #define SHIFT 3
1289 #include "softmmu_template.h"
1290
1291 /* try to fill the TLB and return an exception if error. If retaddr is
1292    NULL, it means that the function was called in C code (i.e. not
1293    from generated code or from helper.c) */
1294 /* XXX: fix it to restore all registers */
1295 void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
1296 {
1297     TranslationBlock *tb;
1298     CPUState *saved_env;
1299     unsigned long pc;
1300     int ret;
1301
1302     /* XXX: hack to restore env in all cases, even if not called from
1303        generated code */
1304     saved_env = env;
1305     env = cpu_single_env;
1306     ret = cpu_alpha_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
1307     if (!likely(ret == 0)) {
1308         if (likely(retaddr)) {
1309             /* now we have a real cpu fault */
1310             pc = (unsigned long)retaddr;
1311             tb = tb_find_pc(pc);
1312             if (likely(tb)) {
1313                 /* the PC is inside the translated code. It means that we have
1314                    a virtual CPU fault */
1315                 cpu_restore_state(tb, env, pc, NULL);
1316             }
1317         }
1318         /* Exception index and error code are already set */
1319         cpu_loop_exit();
1320     }
1321     env = saved_env;
1322 }
1323
1324 #endif