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, write to the Free Software

    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    19  */

    20 

    21 #include "exec.h"

    22 #include "host-utils.h"

    23 #include "softfloat.h"

    24 #include "helper.h"

    25 

    26 void helper_tb_flush (void)

    27 {

    28     tlb_flush(env, 1);

    29 }

    30 

    31 /*****************************************************************************/

    32 /* Exceptions processing helpers */

    33 void helper_excp (int excp, int error)

    34 {

    35     env->exception_index = excp;

    36     env->error_code = error;

    37     cpu_loop_exit();

    38 }

    39 

    40 uint64_t helper_amask (uint64_t arg)

    41 {

    42     switch (env->implver) {

    43     case IMPLVER_2106x:

    44         /* EV4, EV45, LCA, LCA45 & EV5 */

    45         break;

    46     case IMPLVER_21164:

    47     case IMPLVER_21264:

    48     case IMPLVER_21364:

    49         arg &= ~env->amask;

    50         break;

    51     }

    52     return arg;

    53 }

    54 

    55 uint64_t helper_load_pcc (void)

    56 {

    57     /* XXX: TODO */

    58     return 0;

    59 }

    60 

    61 uint64_t helper_load_implver (void)

    62 {

    63     return env->implver;

    64 }

    65 

    66 uint64_t helper_load_fpcr (void)

    67 {

    68     uint64_t ret = 0;

    69 #ifdef CONFIG_SOFTFLOAT

    70     ret |= env->fp_status.float_exception_flags << 52;

    71     if (env->fp_status.float_exception_flags)

    72         ret |= 1ULL << 63;

    73     env->ipr[IPR_EXC_SUM] &= ~0x3E:

    74     env->ipr[IPR_EXC_SUM] |= env->fp_status.float_exception_flags << 1;

    75 #endif

    76     switch (env->fp_status.float_rounding_mode) {

    77     case float_round_nearest_even:

    78         ret |= 2ULL << 58;

    79         break;

    80     case float_round_down:

    81         ret |= 1ULL << 58;

    82         break;

    83     case float_round_up:

    84         ret |= 3ULL << 58;

    85         break;

    86     case float_round_to_zero:

    87         break;

    88     }

    89     return ret;

    90 }

    91 

    92 void helper_store_fpcr (uint64_t val)

    93 {

    94 #ifdef CONFIG_SOFTFLOAT

    95     set_float_exception_flags((val >> 52) & 0x3F, &FP_STATUS);

    96 #endif

    97     switch ((val >> 58) & 3) {

    98     case 0:

    99         set_float_rounding_mode(float_round_to_zero, &FP_STATUS);

   100         break;

   101     case 1:

   102         set_float_rounding_mode(float_round_down, &FP_STATUS);

   103         break;

   104     case 2:

   105         set_float_rounding_mode(float_round_nearest_even, &FP_STATUS);

   106         break;

   107     case 3:

   108         set_float_rounding_mode(float_round_up, &FP_STATUS);

   109         break;

   110     }

   111 }

   112 

   113 spinlock_t intr_cpu_lock = SPIN_LOCK_UNLOCKED;

   114 

   115 uint64_t helper_rs(void)

   116 {

   117     uint64_t tmp;

   118 

   119     spin_lock(&intr_cpu_lock);

   120     tmp = env->intr_flag;

   121     env->intr_flag = 1;

   122     spin_unlock(&intr_cpu_lock);

   123 

   124     return tmp;

   125 }

   126 

   127 uint64_t helper_rc(void)

   128 {

   129     uint64_t tmp;

   130 

   131     spin_lock(&intr_cpu_lock);

   132     tmp = env->intr_flag;

   133     env->intr_flag = 0;

   134     spin_unlock(&intr_cpu_lock);

   135 

   136     return tmp;

   137 }

   138 

   139 uint64_t helper_addqv (uint64_t op1, uint64_t op2)

   140 {

   141     uint64_t tmp = op1;

   142     op1 += op2;

   143     if (unlikely((tmp ^ op2 ^ (-1ULL)) & (tmp ^ op1) & (1ULL << 63))) {

   144         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);

   145     }

   146     return op1;

   147 }

   148 

   149 uint64_t helper_addlv (uint64_t op1, uint64_t op2)

   150 {

   151     uint64_t tmp = op1;

   152     op1 = (uint32_t)(op1 + op2);

   153     if (unlikely((tmp ^ op2 ^ (-1UL)) & (tmp ^ op1) & (1UL << 31))) {

   154         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);

   155     }

   156     return op1;

   157 }

   158 

   159 uint64_t helper_subqv (uint64_t op1, uint64_t op2)

   160 {

   161     uint64_t tmp = op1;

   162     op1 -= op2;

   163     if (unlikely(((~tmp) ^ op1 ^ (-1ULL)) & ((~tmp) ^ op2) & (1ULL << 63))) {

   164         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);

   165     }

   166     return op1;

   167 }

   168 

   169 uint64_t helper_sublv (uint64_t op1, uint64_t op2)

   170 {

   171     uint64_t tmp = op1;

   172     op1 = (uint32_t)(op1 - op2);

   173     if (unlikely(((~tmp) ^ op1 ^ (-1UL)) & ((~tmp) ^ op2) & (1UL << 31))) {

   174         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);

   175     }

   176     return op1;

   177 }

   178 

   179 uint64_t helper_mullv (uint64_t op1, uint64_t op2)

   180 {

   181     int64_t res = (int64_t)op1 * (int64_t)op2;

   182 

   183     if (unlikely((int32_t)res != res)) {

   184         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);

   185     }

   186     return (int64_t)((int32_t)res);

   187 }

   188 

   189 uint64_t helper_mulqv (uint64_t op1, uint64_t op2)

   190 {

   191     uint64_t tl, th;

   192 

   193     muls64(&tl, &th, op1, op2);

   194     /* If th != 0 && th != -1, then we had an overflow */

   195     if (unlikely((th + 1) > 1)) {

   196         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);

   197     }

   198     return tl;

   199 }

   200 

   201 uint64_t helper_umulh (uint64_t op1, uint64_t op2)

   202 {

   203     uint64_t tl, th;

   204 

   205     mulu64(&tl, &th, op1, op2);

   206     return th;

   207 }

   208 

   209 uint64_t helper_ctpop (uint64_t arg)

   210 {

   211     return ctpop64(arg);

   212 }

   213 

   214 uint64_t helper_ctlz (uint64_t arg)

   215 {

   216     return clz64(arg);

   217 }

   218 

   219 uint64_t helper_cttz (uint64_t arg)

   220 {

   221     return ctz64(arg);

   222 }

   223 

   224 static always_inline uint64_t byte_zap (uint64_t op, uint8_t mskb)

   225 {

   226     uint64_t mask;

   227 

   228     mask = 0;

   229     mask |= ((mskb >> 0) & 1) * 0x00000000000000FFULL;

   230     mask |= ((mskb >> 1) & 1) * 0x000000000000FF00ULL;

   231     mask |= ((mskb >> 2) & 1) * 0x0000000000FF0000ULL;

   232     mask |= ((mskb >> 3) & 1) * 0x00000000FF000000ULL;

   233     mask |= ((mskb >> 4) & 1) * 0x000000FF00000000ULL;

   234     mask |= ((mskb >> 5) & 1) * 0x0000FF0000000000ULL;

   235     mask |= ((mskb >> 6) & 1) * 0x00FF000000000000ULL;

   236     mask |= ((mskb >> 7) & 1) * 0xFF00000000000000ULL;

   237 

   238     return op & ~mask;

   239 }

   240 

   241 uint64_t helper_mskbl(uint64_t val, uint64_t mask)

   242 {

   243     return byte_zap(val, 0x01 << (mask & 7));

   244 }

   245 

   246 uint64_t helper_insbl(uint64_t val, uint64_t mask)

   247 {

   248     val <<= (mask & 7) * 8;

   249     return byte_zap(val, ~(0x01 << (mask & 7)));

   250 }

   251 

   252 uint64_t helper_mskwl(uint64_t val, uint64_t mask)

   253 {

   254     return byte_zap(val, 0x03 << (mask & 7));

   255 }

   256 

   257 uint64_t helper_inswl(uint64_t val, uint64_t mask)

   258 {

   259     val <<= (mask & 7) * 8;

   260     return byte_zap(val, ~(0x03 << (mask & 7)));

   261 }

   262 

   263 uint64_t helper_mskll(uint64_t val, uint64_t mask)

   264 {

   265     return byte_zap(val, 0x0F << (mask & 7));

   266 }

   267 

   268 uint64_t helper_insll(uint64_t val, uint64_t mask)

   269 {

   270     val <<= (mask & 7) * 8;

   271     return byte_zap(val, ~(0x0F << (mask & 7)));

   272 }

   273 

   274 uint64_t helper_zap(uint64_t val, uint64_t mask)

   275 {

   276     return byte_zap(val, mask);

   277 }

   278 

   279 uint64_t helper_zapnot(uint64_t val, uint64_t mask)

   280 {

   281     return byte_zap(val, ~mask);

   282 }

   283 

   284 uint64_t helper_mskql(uint64_t val, uint64_t mask)

   285 {

   286     return byte_zap(val, 0xFF << (mask & 7));

   287 }

   288 

   289 uint64_t helper_insql(uint64_t val, uint64_t mask)

   290 {

   291     val <<= (mask & 7) * 8;

   292     return byte_zap(val, ~(0xFF << (mask & 7)));

   293 }

   294 

   295 uint64_t helper_mskwh(uint64_t val, uint64_t mask)

   296 {

   297     return byte_zap(val, (0x03 << (mask & 7)) >> 8);

   298 }

   299 

   300 uint64_t helper_inswh(uint64_t val, uint64_t mask)

   301 {

   302     val >>= 64 - ((mask & 7) * 8);

   303     return byte_zap(val, ~((0x03 << (mask & 7)) >> 8));

   304 }

   305 

   306 uint64_t helper_msklh(uint64_t val, uint64_t mask)

   307 {

   308     return byte_zap(val, (0x0F << (mask & 7)) >> 8);

   309 }

   310 

   311 uint64_t helper_inslh(uint64_t val, uint64_t mask)

   312 {

   313     val >>= 64 - ((mask & 7) * 8);

   314     return byte_zap(val, ~((0x0F << (mask & 7)) >> 8));

   315 }

   316 

   317 uint64_t helper_mskqh(uint64_t val, uint64_t mask)

   318 {

   319     return byte_zap(val, (0xFF << (mask & 7)) >> 8);

   320 }

   321 

   322 uint64_t helper_insqh(uint64_t val, uint64_t mask)

   323 {

   324     val >>= 64 - ((mask & 7) * 8);

   325     return byte_zap(val, ~((0xFF << (mask & 7)) >> 8));

   326 }

   327 

   328 uint64_t helper_cmpbge (uint64_t op1, uint64_t op2)

   329 {

   330     uint8_t opa, opb, res;

   331     int i;

   332 

   333     res = 0;

   334     for (i = 0; i < 8; i++) {

   335         opa = op1 >> (i * 8);

   336         opb = op2 >> (i * 8);

   337         if (opa >= opb)

   338             res |= 1 << i;

   339     }

   340     return res;

   341 }

   342 

   343 /* Floating point helpers */

   344 

   345 /* F floating (VAX) */

   346 static always_inline uint64_t float32_to_f (float32 fa)

   347 {

   348     uint64_t r, exp, mant, sig;

   349     CPU_FloatU a;

   350 

   351     a.f = fa;

   352     sig = ((uint64_t)a.l & 0x80000000) << 32;

   353     exp = (a.l >> 23) & 0xff;

   354     mant = ((uint64_t)a.l & 0x007fffff) << 29;

   355 

   356     if (exp == 255) {

   357         /* NaN or infinity */

   358         r = 1; /* VAX dirty zero */

   359     } else if (exp == 0) {

   360         if (mant == 0) {

   361             /* Zero */

   362             r = 0;

   363         } else {

   364             /* Denormalized */

   365             r = sig | ((exp + 1) << 52) | mant;

   366         }

   367     } else {

   368         if (exp >= 253) {

   369             /* Overflow */

   370             r = 1; /* VAX dirty zero */

   371         } else {

   372             r = sig | ((exp + 2) << 52);

   373         }

   374     }

   375 

   376     return r;

   377 }

   378 

   379 static always_inline float32 f_to_float32 (uint64_t a)

   380 {

   381     uint32_t exp, mant_sig;

   382     CPU_FloatU r;

   383 

   384     exp = ((a >> 55) & 0x80) | ((a >> 52) & 0x7f);

   385     mant_sig = ((a >> 32) & 0x80000000) | ((a >> 29) & 0x007fffff);

   386 

   387     if (unlikely(!exp && mant_sig)) {

   388         /* Reserved operands / Dirty zero */

   389         helper_excp(EXCP_OPCDEC, 0);

   390     }

   391 

   392     if (exp < 3) {

   393         /* Underflow */

   394         r.l = 0;

   395     } else {

   396         r.l = ((exp - 2) << 23) | mant_sig;

   397     }

   398 

   399     return r.f;

   400 }

   401 

   402 uint32_t helper_f_to_memory (uint64_t a)

   403 {

   404     uint32_t r;

   405     r =  (a & 0x00001fffe0000000ull) >> 13;

   406     r |= (a & 0x07ffe00000000000ull) >> 45;

   407     r |= (a & 0xc000000000000000ull) >> 48;

   408     return r;

   409 }

   410 

   411 uint64_t helper_memory_to_f (uint32_t a)

   412 {

   413     uint64_t r;

   414     r =  ((uint64_t)(a & 0x0000c000)) << 48;

   415     r |= ((uint64_t)(a & 0x003fffff)) << 45;

   416     r |= ((uint64_t)(a & 0xffff0000)) << 13;

   417     if (!(a & 0x00004000))

   418         r |= 0x7ll << 59;

   419     return r;

   420 }

   421 

   422 uint64_t helper_addf (uint64_t a, uint64_t b)

   423 {

   424     float32 fa, fb, fr;

   425 

   426     fa = f_to_float32(a);

   427     fb = f_to_float32(b);

   428     fr = float32_add(fa, fb, &FP_STATUS);

   429     return float32_to_f(fr);

   430 }

   431 

   432 uint64_t helper_subf (uint64_t a, uint64_t b)

   433 {

   434     float32 fa, fb, fr;

   435 

   436     fa = f_to_float32(a);

   437     fb = f_to_float32(b);

   438     fr = float32_sub(fa, fb, &FP_STATUS);

   439     return float32_to_f(fr);

   440 }

   441 

   442 uint64_t helper_mulf (uint64_t a, uint64_t b)

   443 {

   444     float32 fa, fb, fr;

   445 

   446     fa = f_to_float32(a);

   447     fb = f_to_float32(b);

   448     fr = float32_mul(fa, fb, &FP_STATUS);

   449     return float32_to_f(fr);

   450 }

   451 

   452 uint64_t helper_divf (uint64_t a, uint64_t b)

   453 {

   454     float32 fa, fb, fr;

   455 

   456     fa = f_to_float32(a);

   457     fb = f_to_float32(b);

   458     fr = float32_div(fa, fb, &FP_STATUS);

   459     return float32_to_f(fr);

   460 }

   461 

   462 uint64_t helper_sqrtf (uint64_t t)

   463 {

   464     float32 ft, fr;

   465 

   466     ft = f_to_float32(t);

   467     fr = float32_sqrt(ft, &FP_STATUS);

   468     return float32_to_f(fr);

   469 }

   470 

   471 

   472 /* G floating (VAX) */

   473 static always_inline uint64_t float64_to_g (float64 fa)

   474 {

   475     uint64_t r, exp, mant, sig;

   476     CPU_DoubleU a;

   477 

   478     a.d = fa;

   479     sig = a.ll & 0x8000000000000000ull;

   480     exp = (a.ll >> 52) & 0x7ff;

   481     mant = a.ll & 0x000fffffffffffffull;

   482 

   483     if (exp == 2047) {

   484         /* NaN or infinity */

   485         r = 1; /* VAX dirty zero */

   486     } else if (exp == 0) {

   487         if (mant == 0) {

   488             /* Zero */

   489             r = 0;

   490         } else {

   491             /* Denormalized */

   492             r = sig | ((exp + 1) << 52) | mant;

   493         }

   494     } else {

   495         if (exp >= 2045) {

   496             /* Overflow */

   497             r = 1; /* VAX dirty zero */

   498         } else {

   499             r = sig | ((exp + 2) << 52);

   500         }

   501     }

   502 

   503     return r;

   504 }

   505 

   506 static always_inline float64 g_to_float64 (uint64_t a)

   507 {

   508     uint64_t exp, mant_sig;

   509     CPU_DoubleU r;

   510 

   511     exp = (a >> 52) & 0x7ff;

   512     mant_sig = a & 0x800fffffffffffffull;

   513 

   514     if (!exp && mant_sig) {

   515         /* Reserved operands / Dirty zero */

   516         helper_excp(EXCP_OPCDEC, 0);

   517     }

   518 

   519     if (exp < 3) {

   520         /* Underflow */

   521         r.ll = 0;

   522     } else {

   523         r.ll = ((exp - 2) << 52) | mant_sig;

   524     }

   525 

   526     return r.d;

   527 }

   528 

   529 uint64_t helper_g_to_memory (uint64_t a)

   530 {

   531     uint64_t r;

   532     r =  (a & 0x000000000000ffffull) << 48;

   533     r |= (a & 0x00000000ffff0000ull) << 16;

   534     r |= (a & 0x0000ffff00000000ull) >> 16;

   535     r |= (a & 0xffff000000000000ull) >> 48;

   536     return r;

   537 }

   538 

   539 uint64_t helper_memory_to_g (uint64_t a)

   540 {

   541     uint64_t r;

   542     r =  (a & 0x000000000000ffffull) << 48;

   543     r |= (a & 0x00000000ffff0000ull) << 16;

   544     r |= (a & 0x0000ffff00000000ull) >> 16;

   545     r |= (a & 0xffff000000000000ull) >> 48;

   546     return r;

   547 }

   548 

   549 uint64_t helper_addg (uint64_t a, uint64_t b)

   550 {

   551     float64 fa, fb, fr;

   552 

   553     fa = g_to_float64(a);

   554     fb = g_to_float64(b);

   555     fr = float64_add(fa, fb, &FP_STATUS);

   556     return float64_to_g(fr);

   557 }

   558 

   559 uint64_t helper_subg (uint64_t a, uint64_t b)

   560 {

   561     float64 fa, fb, fr;

   562 

   563     fa = g_to_float64(a);

   564     fb = g_to_float64(b);

   565     fr = float64_sub(fa, fb, &FP_STATUS);

   566     return float64_to_g(fr);

   567 }

   568 

   569 uint64_t helper_mulg (uint64_t a, uint64_t b)

   570 {

   571     float64 fa, fb, fr;

   572 

   573     fa = g_to_float64(a);

   574     fb = g_to_float64(b);

   575     fr = float64_mul(fa, fb, &FP_STATUS);

   576     return float64_to_g(fr);

   577 }

   578 

   579 uint64_t helper_divg (uint64_t a, uint64_t b)

   580 {

   581     float64 fa, fb, fr;

   582 

   583     fa = g_to_float64(a);

   584     fb = g_to_float64(b);

   585     fr = float64_div(fa, fb, &FP_STATUS);

   586     return float64_to_g(fr);

   587 }

   588 

   589 uint64_t helper_sqrtg (uint64_t a)

   590 {

   591     float64 fa, fr;

   592 

   593     fa = g_to_float64(a);

   594     fr = float64_sqrt(fa, &FP_STATUS);

   595     return float64_to_g(fr);

   596 }

   597 

   598 

   599 /* S floating (single) */

   600 static always_inline uint64_t float32_to_s (float32 fa)

   601 {

   602     CPU_FloatU a;

   603     uint64_t r;

   604 

   605     a.f = fa;

   606 

   607     r = (((uint64_t)(a.l & 0xc0000000)) << 32) | (((uint64_t)(a.l & 0x3fffffff)) << 29);

   608     if (((a.l & 0x7f800000) != 0x7f800000) && (!(a.l & 0x40000000)))

   609         r |= 0x7ll << 59;

   610     return r;

   611 }

   612 

   613 static always_inline float32 s_to_float32 (uint64_t a)

   614 {

   615     CPU_FloatU r;

   616     r.l = ((a >> 32) & 0xc0000000) | ((a >> 29) & 0x3fffffff);

   617     return r.f;

   618 }

   619 

   620 uint32_t helper_s_to_memory (uint64_t a)

   621 {

   622     /* Memory format is the same as float32 */

   623     float32 fa = s_to_float32(a);

   624     return *(uint32_t*)(&fa);

   625 }

   626 

   627 uint64_t helper_memory_to_s (uint32_t a)

   628 {

   629     /* Memory format is the same as float32 */

   630     return float32_to_s(*(float32*)(&a));

   631 }

   632 

   633 uint64_t helper_adds (uint64_t a, uint64_t b)

   634 {

   635     float32 fa, fb, fr;

   636 

   637     fa = s_to_float32(a);

   638     fb = s_to_float32(b);

   639     fr = float32_add(fa, fb, &FP_STATUS);

   640     return float32_to_s(fr);

   641 }

   642 

   643 uint64_t helper_subs (uint64_t a, uint64_t b)

   644 {

   645     float32 fa, fb, fr;

   646 

   647     fa = s_to_float32(a);

   648     fb = s_to_float32(b);

   649     fr = float32_sub(fa, fb, &FP_STATUS);

   650     return float32_to_s(fr);

   651 }

   652 

   653 uint64_t helper_muls (uint64_t a, uint64_t b)

   654 {

   655     float32 fa, fb, fr;

   656 

   657     fa = s_to_float32(a);

   658     fb = s_to_float32(b);

   659     fr = float32_mul(fa, fb, &FP_STATUS);

   660     return float32_to_s(fr);

   661 }

   662 

   663 uint64_t helper_divs (uint64_t a, uint64_t b)

   664 {

   665     float32 fa, fb, fr;

   666 

   667     fa = s_to_float32(a);

   668     fb = s_to_float32(b);

   669     fr = float32_div(fa, fb, &FP_STATUS);

   670     return float32_to_s(fr);

   671 }

   672 

   673 uint64_t helper_sqrts (uint64_t a)

   674 {

   675     float32 fa, fr;

   676 

   677     fa = s_to_float32(a);

   678     fr = float32_sqrt(fa, &FP_STATUS);

   679     return float32_to_s(fr);

   680 }

   681 

   682 

   683 /* T floating (double) */

   684 static always_inline float64 t_to_float64 (uint64_t a)

   685 {

   686     /* Memory format is the same as float64 */

   687     CPU_DoubleU r;

   688     r.ll = a;

   689     return r.d;

   690 }

   691 

   692 static always_inline uint64_t float64_to_t (float64 fa)

   693 {

   694     /* Memory format is the same as float64 */

   695     CPU_DoubleU r;

   696     r.d = fa;

   697     return r.ll;

   698 }

   699 

   700 uint64_t helper_addt (uint64_t a, uint64_t b)

   701 {

   702     float64 fa, fb, fr;

   703 

   704     fa = t_to_float64(a);

   705     fb = t_to_float64(b);

   706     fr = float64_add(fa, fb, &FP_STATUS);

   707     return float64_to_t(fr);

   708 }

   709 

   710 uint64_t helper_subt (uint64_t a, uint64_t b)

   711 {

   712     float64 fa, fb, fr;

   713 

   714     fa = t_to_float64(a);

   715     fb = t_to_float64(b);

   716     fr = float64_sub(fa, fb, &FP_STATUS);

   717     return float64_to_t(fr);

   718 }

   719 

   720 uint64_t helper_mult (uint64_t a, uint64_t b)

   721 {

   722     float64 fa, fb, fr;

   723 

   724     fa = t_to_float64(a);

   725     fb = t_to_float64(b);

   726     fr = float64_mul(fa, fb, &FP_STATUS);

   727     return float64_to_t(fr);

   728 }

   729 

   730 uint64_t helper_divt (uint64_t a, uint64_t b)

   731 {

   732     float64 fa, fb, fr;

   733 

   734     fa = t_to_float64(a);

   735     fb = t_to_float64(b);

   736     fr = float64_div(fa, fb, &FP_STATUS);

   737     return float64_to_t(fr);

   738 }

   739 

   740 uint64_t helper_sqrtt (uint64_t a)

   741 {

   742     float64 fa, fr;

   743 

   744     fa = t_to_float64(a);

   745     fr = float64_sqrt(fa, &FP_STATUS);

   746     return float64_to_t(fr);

   747 }

   748 

   749 

   750 /* Sign copy */

   751 uint64_t helper_cpys(uint64_t a, uint64_t b)

   752 {

   753     return (a & 0x8000000000000000ULL) | (b & ~0x8000000000000000ULL);

   754 }

   755 

   756 uint64_t helper_cpysn(uint64_t a, uint64_t b)

   757 {

   758     return ((~a) & 0x8000000000000000ULL) | (b & ~0x8000000000000000ULL);

   759 }

   760 

   761 uint64_t helper_cpyse(uint64_t a, uint64_t b)

   762 {

   763     return (a & 0xFFF0000000000000ULL) | (b & ~0xFFF0000000000000ULL);

   764 }

   765 

   766 

   767 /* Comparisons */

   768 uint64_t helper_cmptun (uint64_t a, uint64_t b)

   769 {

   770     float64 fa, fb;

   771 

   772     fa = t_to_float64(a);

   773     fb = t_to_float64(b);

   774 

   775     if (float64_is_nan(fa) || float64_is_nan(fb))

   776         return 0x4000000000000000ULL;

   777     else

   778         return 0;

   779 }

   780 

   781 uint64_t helper_cmpteq(uint64_t a, uint64_t b)

   782 {

   783     float64 fa, fb;

   784 

   785     fa = t_to_float64(a);

   786     fb = t_to_float64(b);

   787 

   788     if (float64_eq(fa, fb, &FP_STATUS))

   789         return 0x4000000000000000ULL;

   790     else

   791         return 0;

   792 }

   793 

   794 uint64_t helper_cmptle(uint64_t a, uint64_t b)

   795 {

   796     float64 fa, fb;

   797 

   798     fa = t_to_float64(a);

   799     fb = t_to_float64(b);

   800 

   801     if (float64_le(fa, fb, &FP_STATUS))

   802         return 0x4000000000000000ULL;

   803     else

   804         return 0;

   805 }

   806 

   807 uint64_t helper_cmptlt(uint64_t a, uint64_t b)

   808 {

   809     float64 fa, fb;

   810 

   811     fa = t_to_float64(a);

   812     fb = t_to_float64(b);

   813 

   814     if (float64_lt(fa, fb, &FP_STATUS))

   815         return 0x4000000000000000ULL;

   816     else

   817         return 0;

   818 }

   819 

   820 uint64_t helper_cmpgeq(uint64_t a, uint64_t b)

   821 {

   822     float64 fa, fb;

   823 

   824     fa = g_to_float64(a);

   825     fb = g_to_float64(b);

   826 

   827     if (float64_eq(fa, fb, &FP_STATUS))

   828         return 0x4000000000000000ULL;

   829     else

   830         return 0;

   831 }

   832 

   833 uint64_t helper_cmpgle(uint64_t a, uint64_t b)

   834 {

   835     float64 fa, fb;

   836 

   837     fa = g_to_float64(a);

   838     fb = g_to_float64(b);

   839 

   840     if (float64_le(fa, fb, &FP_STATUS))

   841         return 0x4000000000000000ULL;

   842     else

   843         return 0;

   844 }

   845 

   846 uint64_t helper_cmpglt(uint64_t a, uint64_t b)

   847 {

   848     float64 fa, fb;

   849 

   850     fa = g_to_float64(a);

   851     fb = g_to_float64(b);

   852 

   853     if (float64_lt(fa, fb, &FP_STATUS))

   854         return 0x4000000000000000ULL;

   855     else

   856         return 0;

   857 }

   858 

   859 uint64_t helper_cmpfeq (uint64_t a)

   860 {

   861     return !(a & 0x7FFFFFFFFFFFFFFFULL);

   862 }

   863 

   864 uint64_t helper_cmpfne (uint64_t a)

   865 {

   866     return (a & 0x7FFFFFFFFFFFFFFFULL);

   867 }

   868 

   869 uint64_t helper_cmpflt (uint64_t a)

   870 {

   871     return (a & 0x8000000000000000ULL) && (a & 0x7FFFFFFFFFFFFFFFULL);

   872 }

   873 

   874 uint64_t helper_cmpfle (uint64_t a)

   875 {

   876     return (a & 0x8000000000000000ULL) || !(a & 0x7FFFFFFFFFFFFFFFULL);

   877 }

   878 

   879 uint64_t helper_cmpfgt (uint64_t a)

   880 {

   881     return !(a & 0x8000000000000000ULL) && (a & 0x7FFFFFFFFFFFFFFFULL);

   882 }

   883 

   884 uint64_t helper_cmpfge (uint64_t a)

   885 {

   886     return !(a & 0x8000000000000000ULL) || !(a & 0x7FFFFFFFFFFFFFFFULL);

   887 }

   888 

   889 

   890 /* Floating point format conversion */

   891 uint64_t helper_cvtts (uint64_t a)

   892 {

   893     float64 fa;

   894     float32 fr;

   895 

   896     fa = t_to_float64(a);

   897     fr = float64_to_float32(fa, &FP_STATUS);

   898     return float32_to_s(fr);

   899 }

   900 

   901 uint64_t helper_cvtst (uint64_t a)

   902 {

   903     float32 fa;

   904     float64 fr;

   905 

   906     fa = s_to_float32(a);

   907     fr = float32_to_float64(fa, &FP_STATUS);

   908     return float64_to_t(fr);

   909 }

   910 

   911 uint64_t helper_cvtqs (uint64_t a)

   912 {

   913     float32 fr = int64_to_float32(a, &FP_STATUS);

   914     return float32_to_s(fr);

   915 }

   916 

   917 uint64_t helper_cvttq (uint64_t a)

   918 {

   919     float64 fa = t_to_float64(a);

   920     return float64_to_int64_round_to_zero(fa, &FP_STATUS);

   921 }

   922 

   923 uint64_t helper_cvtqt (uint64_t a)

   924 {

   925     float64 fr = int64_to_float64(a, &FP_STATUS);

   926     return float64_to_t(fr);

   927 }

   928 

   929 uint64_t helper_cvtqf (uint64_t a)

   930 {

   931     float32 fr = int64_to_float32(a, &FP_STATUS);

   932     return float32_to_f(fr);

   933 }

   934 

   935 uint64_t helper_cvtgf (uint64_t a)

   936 {

   937     float64 fa;

   938     float32 fr;

   939 

   940     fa = g_to_float64(a);

   941     fr = float64_to_float32(fa, &FP_STATUS);

   942     return float32_to_f(fr);

   943 }

   944 

   945 uint64_t helper_cvtgq (uint64_t a)

   946 {

   947     float64 fa = g_to_float64(a);

   948     return float64_to_int64_round_to_zero(fa, &FP_STATUS);

   949 }

   950 

   951 uint64_t helper_cvtqg (uint64_t a)

   952 {

   953     float64 fr;

   954     fr = int64_to_float64(a, &FP_STATUS);

   955     return float64_to_g(fr);

   956 }

   957 

   958 uint64_t helper_cvtlq (uint64_t a)

   959 {

   960     return (int64_t)((int32_t)((a >> 32) | ((a >> 29) & 0x3FFFFFFF)));

   961 }

   962 

   963 static always_inline uint64_t __helper_cvtql (uint64_t a, int s, int v)

   964 {

   965     uint64_t r;

   966 

   967     r = ((uint64_t)(a & 0xC0000000)) << 32;

   968     r |= ((uint64_t)(a & 0x7FFFFFFF)) << 29;

   969 

   970     if (v && (int64_t)((int32_t)r) != (int64_t)r) {

   971         helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);

   972     }

   973     if (s) {

   974         /* TODO */

   975     }

   976     return r;

   977 }

   978 

   979 uint64_t helper_cvtql (uint64_t a)

   980 {

   981     return __helper_cvtql(a, 0, 0);

   982 }

   983 

   984 uint64_t helper_cvtqlv (uint64_t a)

   985 {

   986     return __helper_cvtql(a, 0, 1);

   987 }

   988 

   989 uint64_t helper_cvtqlsv (uint64_t a)

   990 {

   991     return __helper_cvtql(a, 1, 1);

   992 }

   993 

   994 /* PALcode support special instructions */

   995 #if !defined (CONFIG_USER_ONLY)

   996 void helper_hw_rei (void)

   997 {

   998     env->pc = env->ipr[IPR_EXC_ADDR] & ~3;

   999     env->ipr[IPR_EXC_ADDR] = env->ipr[IPR_EXC_ADDR] & 1;

  1000     /* XXX: re-enable interrupts and memory mapping */

  1001 }

  1002 

  1003 void helper_hw_ret (uint64_t a)

  1004 {

  1005     env->pc = a & ~3;

  1006     env->ipr[IPR_EXC_ADDR] = a & 1;

  1007     /* XXX: re-enable interrupts and memory mapping */

  1008 }

  1009 

  1010 uint64_t helper_mfpr (int iprn, uint64_t val)

  1011 {

  1012     uint64_t tmp;

  1013 

  1014     if (cpu_alpha_mfpr(env, iprn, &tmp) == 0)

  1015         val = tmp;

  1016 

  1017     return val;

  1018 }

  1019 

  1020 void helper_mtpr (int iprn, uint64_t val)

  1021 {

  1022     cpu_alpha_mtpr(env, iprn, val, NULL);

  1023 }

  1024 

  1025 void helper_set_alt_mode (void)

  1026 {

  1027     env->saved_mode = env->ps & 0xC;

  1028     env->ps = (env->ps & ~0xC) | (env->ipr[IPR_ALT_MODE] & 0xC);

  1029 }

  1030 

  1031 void helper_restore_mode (void)

  1032 {

  1033     env->ps = (env->ps & ~0xC) | env->saved_mode;

  1034 }

  1035 

  1036 #endif

  1037 

  1038 /*****************************************************************************/

  1039 /* Softmmu support */

  1040 #if !defined (CONFIG_USER_ONLY)

  1041 

  1042 /* XXX: the two following helpers are pure hacks.

  1043  *      Hopefully, we emulate the PALcode, then we should never see

  1044  *      HW_LD / HW_ST instructions.

  1045  */

  1046 uint64_t helper_ld_virt_to_phys (uint64_t virtaddr)

  1047 {

  1048     uint64_t tlb_addr, physaddr;

  1049     int index, mmu_idx;

  1050     void *retaddr;

  1051 

  1052     mmu_idx = cpu_mmu_index(env);

  1053     index = (virtaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);

  1054  redo:

  1055     tlb_addr = env->tlb_table[mmu_idx][index].addr_read;

  1056     if ((virtaddr & TARGET_PAGE_MASK) ==

  1057         (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {

  1058         physaddr = virtaddr + env->tlb_table[mmu_idx][index].addend;

  1059     } else {

  1060         /* the page is not in the TLB : fill it */

  1061         retaddr = GETPC();

  1062         tlb_fill(virtaddr, 0, mmu_idx, retaddr);

  1063         goto redo;

  1064     }

  1065     return physaddr;

  1066 }

  1067 

  1068 uint64_t helper_st_virt_to_phys (uint64_t virtaddr)

  1069 {

  1070     uint64_t tlb_addr, physaddr;

  1071     int index, mmu_idx;

  1072     void *retaddr;

  1073 

  1074     mmu_idx = cpu_mmu_index(env);

  1075     index = (virtaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);

  1076  redo:

  1077     tlb_addr = env->tlb_table[mmu_idx][index].addr_write;

  1078     if ((virtaddr & TARGET_PAGE_MASK) ==

  1079         (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {

  1080         physaddr = virtaddr + env->tlb_table[mmu_idx][index].addend;

  1081     } else {

  1082         /* the page is not in the TLB : fill it */

  1083         retaddr = GETPC();

  1084         tlb_fill(virtaddr, 1, mmu_idx, retaddr);

  1085         goto redo;

  1086     }

  1087     return physaddr;

  1088 }

  1089 

  1090 void helper_ldl_raw(uint64_t t0, uint64_t t1)

  1091 {

  1092     ldl_raw(t1, t0);

  1093 }

  1094 

  1095 void helper_ldq_raw(uint64_t t0, uint64_t t1)

  1096 {

  1097     ldq_raw(t1, t0);

  1098 }

  1099 

  1100 void helper_ldl_l_raw(uint64_t t0, uint64_t t1)

  1101 {

  1102     env->lock = t1;

  1103     ldl_raw(t1, t0);

  1104 }

  1105 

  1106 void helper_ldq_l_raw(uint64_t t0, uint64_t t1)

  1107 {

  1108     env->lock = t1;

  1109     ldl_raw(t1, t0);

  1110 }

  1111 

  1112 void helper_ldl_kernel(uint64_t t0, uint64_t t1)

  1113 {

  1114     ldl_kernel(t1, t0);

  1115 }

  1116 

  1117 void helper_ldq_kernel(uint64_t t0, uint64_t t1)

  1118 {

  1119     ldq_kernel(t1, t0);

  1120 }

  1121 

  1122 void helper_ldl_data(uint64_t t0, uint64_t t1)

  1123 {

  1124     ldl_data(t1, t0);

  1125 }

  1126 

  1127 void helper_ldq_data(uint64_t t0, uint64_t t1)

  1128 {

  1129     ldq_data(t1, t0);

  1130 }

  1131 

  1132 void helper_stl_raw(uint64_t t0, uint64_t t1)

  1133 {

  1134     stl_raw(t1, t0);

  1135 }