target-mips/op_helper.c

   1 /*
   2  *  MIPS emulation helpers for qemu.
   3  *
   4  *  Copyright (c) 2004-2005 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 #include <stdlib.h>
  20 #include "cpu.h"
  21 #include "host-utils.h"
  22
  23 #include "helper.h"
  24
  25 #if !defined(CONFIG_USER_ONLY)
  26 #include "softmmu_exec.h"
  27 #endif /* !defined(CONFIG_USER_ONLY) */
  28
  29 #ifndef CONFIG_USER_ONLY
  30 static inline void cpu_mips_tlb_flush (CPUMIPSState *env, int flush_global);
  31 #endif
  32
  33 /*****************************************************************************/
  34 /* Exceptions processing helpers */
  35
  36 static inline void QEMU_NORETURN do_raise_exception_err(CPUMIPSState *env,
  37                                                         uint32_t exception,
  38                                                         int error_code,
  39                                                         uintptr_t pc)
  40 {
  41     TranslationBlock *tb;
  42 #if 1
  43     if (exception < 0x100)
  44         qemu_log("%s: %d %d\n", __func__, exception, error_code);
  45 #endif
  46     env->exception_index = exception;
  47     env->error_code = error_code;
  48
  49     if (pc) {
  50         /* now we have a real cpu fault */
  51         tb = tb_find_pc(pc);
  52         if (tb) {
  53             /* the PC is inside the translated code. It means that we have
  54                a virtual CPU fault */
  55             cpu_restore_state(tb, env, pc);
  56         }
  57     }
  58
  59     cpu_loop_exit(env);
  60 }
  61
  62 static inline void QEMU_NORETURN do_raise_exception(CPUMIPSState *env,
  63                                                     uint32_t exception,
  64                                                     uintptr_t pc)
  65 {
  66     do_raise_exception_err(env, exception, 0, pc);
  67 }
  68
  69 void helper_raise_exception_err(CPUMIPSState *env, uint32_t exception,
  70                                 int error_code)
  71 {
  72     do_raise_exception_err(env, exception, error_code, 0);
  73 }
  74
  75 void helper_raise_exception(CPUMIPSState *env, uint32_t exception)
  76 {
  77     do_raise_exception(env, exception, 0);
  78 }
  79
  80 #if defined(CONFIG_USER_ONLY)
  81 #define HELPER_LD(name, insn, type)                                     \
  82 static inline type do_##name(CPUMIPSState *env, target_ulong addr,      \
  83                              int mem_idx)                               \
  84 {                                                                       \
  85     return (type) insn##_raw(addr);                                     \
  86 }
  87 #else
  88 #define HELPER_LD(name, insn, type)                                     \
  89 static inline type do_##name(CPUMIPSState *env, target_ulong addr,      \
  90                              int mem_idx)                               \
  91 {                                                                       \
  92     switch (mem_idx)                                                    \
  93     {                                                                   \
  94     case 0: return (type) cpu_##insn##_kernel(env, addr); break;        \
  95     case 1: return (type) cpu_##insn##_super(env, addr); break;         \
  96     default:                                                            \
  97     case 2: return (type) cpu_##insn##_user(env, addr); break;          \
  98     }                                                                   \
  99 }
 100 #endif
 101 HELPER_LD(lbu, ldub, uint8_t)
 102 HELPER_LD(lw, ldl, int32_t)
 103 #ifdef TARGET_MIPS64
 104 HELPER_LD(ld, ldq, int64_t)
 105 #endif
 106 #undef HELPER_LD
 107
 108 #if defined(CONFIG_USER_ONLY)
 109 #define HELPER_ST(name, insn, type)                                     \
 110 static inline void do_##name(CPUMIPSState *env, target_ulong addr,      \
 111                              type val, int mem_idx)                     \
 112 {                                                                       \
 113     insn##_raw(addr, val);                                              \
 114 }
 115 #else
 116 #define HELPER_ST(name, insn, type)                                     \
 117 static inline void do_##name(CPUMIPSState *env, target_ulong addr,      \
 118                              type val, int mem_idx)                     \
 119 {                                                                       \
 120     switch (mem_idx)                                                    \
 121     {                                                                   \
 122     case 0: cpu_##insn##_kernel(env, addr, val); break;                 \
 123     case 1: cpu_##insn##_super(env, addr, val); break;                  \
 124     default:                                                            \
 125     case 2: cpu_##insn##_user(env, addr, val); break;                   \
 126     }                                                                   \
 127 }
 128 #endif
 129 HELPER_ST(sb, stb, uint8_t)
 130 HELPER_ST(sw, stl, uint32_t)
 131 #ifdef TARGET_MIPS64
 132 HELPER_ST(sd, stq, uint64_t)
 133 #endif
 134 #undef HELPER_ST
 135
 136 target_ulong helper_clo (target_ulong arg1)
 137 {
 138     return clo32(arg1);
 139 }
 140
 141 target_ulong helper_clz (target_ulong arg1)
 142 {
 143     return clz32(arg1);
 144 }
 145
 146 #if defined(TARGET_MIPS64)
 147 target_ulong helper_dclo (target_ulong arg1)
 148 {
 149     return clo64(arg1);
 150 }
 151
 152 target_ulong helper_dclz (target_ulong arg1)
 153 {
 154     return clz64(arg1);
 155 }
 156 #endif /* TARGET_MIPS64 */
 157
 158 /* 64 bits arithmetic for 32 bits hosts */
 159 static inline uint64_t get_HILO(CPUMIPSState *env)
 160 {
 161     return ((uint64_t)(env->active_tc.HI[0]) << 32) | (uint32_t)env->active_tc.LO[0];
 162 }
 163
 164 static inline target_ulong set_HIT0_LO(CPUMIPSState *env, uint64_t HILO)
 165 {
 166     target_ulong tmp;
 167     env->active_tc.LO[0] = (int32_t)(HILO & 0xFFFFFFFF);
 168     tmp = env->active_tc.HI[0] = (int32_t)(HILO >> 32);
 169     return tmp;
 170 }
 171
 172 static inline target_ulong set_HI_LOT0(CPUMIPSState *env, uint64_t HILO)
 173 {
 174     target_ulong tmp = env->active_tc.LO[0] = (int32_t)(HILO & 0xFFFFFFFF);
 175     env->active_tc.HI[0] = (int32_t)(HILO >> 32);
 176     return tmp;
 177 }
 178
 179 /* Multiplication variants of the vr54xx. */
 180 target_ulong helper_muls(CPUMIPSState *env, target_ulong arg1,
 181                          target_ulong arg2)
 182 {
 183     return set_HI_LOT0(env, 0 - ((int64_t)(int32_t)arg1 *
 184                                  (int64_t)(int32_t)arg2));
 185 }
 186
 187 target_ulong helper_mulsu(CPUMIPSState *env, target_ulong arg1,
 188                           target_ulong arg2)
 189 {
 190     return set_HI_LOT0(env, 0 - (uint64_t)(uint32_t)arg1 *
 191                        (uint64_t)(uint32_t)arg2);
 192 }
 193
 194 target_ulong helper_macc(CPUMIPSState *env, target_ulong arg1,
 195                          target_ulong arg2)
 196 {
 197     return set_HI_LOT0(env, (int64_t)get_HILO(env) + (int64_t)(int32_t)arg1 *
 198                        (int64_t)(int32_t)arg2);
 199 }
 200
 201 target_ulong helper_macchi(CPUMIPSState *env, target_ulong arg1,
 202                            target_ulong arg2)
 203 {
 204     return set_HIT0_LO(env, (int64_t)get_HILO(env) + (int64_t)(int32_t)arg1 *
 205                        (int64_t)(int32_t)arg2);
 206 }
 207
 208 target_ulong helper_maccu(CPUMIPSState *env, target_ulong arg1,
 209                           target_ulong arg2)
 210 {
 211     return set_HI_LOT0(env, (uint64_t)get_HILO(env) +
 212                        (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
 213 }
 214
 215 target_ulong helper_macchiu(CPUMIPSState *env, target_ulong arg1,
 216                             target_ulong arg2)
 217 {
 218     return set_HIT0_LO(env, (uint64_t)get_HILO(env) +
 219                        (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
 220 }
 221
 222 target_ulong helper_msac(CPUMIPSState *env, target_ulong arg1,
 223                          target_ulong arg2)
 224 {
 225     return set_HI_LOT0(env, (int64_t)get_HILO(env) - (int64_t)(int32_t)arg1 *
 226                        (int64_t)(int32_t)arg2);
 227 }
 228
 229 target_ulong helper_msachi(CPUMIPSState *env, target_ulong arg1,
 230                            target_ulong arg2)
 231 {
 232     return set_HIT0_LO(env, (int64_t)get_HILO(env) - (int64_t)(int32_t)arg1 *
 233                        (int64_t)(int32_t)arg2);
 234 }
 235
 236 target_ulong helper_msacu(CPUMIPSState *env, target_ulong arg1,
 237                           target_ulong arg2)
 238 {
 239     return set_HI_LOT0(env, (uint64_t)get_HILO(env) -
 240                        (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
 241 }
 242
 243 target_ulong helper_msachiu(CPUMIPSState *env, target_ulong arg1,
 244                             target_ulong arg2)
 245 {
 246     return set_HIT0_LO(env, (uint64_t)get_HILO(env) -
 247                        (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
 248 }
 249
 250 target_ulong helper_mulhi(CPUMIPSState *env, target_ulong arg1,
 251                           target_ulong arg2)
 252 {
 253     return set_HIT0_LO(env, (int64_t)(int32_t)arg1 * (int64_t)(int32_t)arg2);
 254 }
 255
 256 target_ulong helper_mulhiu(CPUMIPSState *env, target_ulong arg1,
 257                            target_ulong arg2)
 258 {
 259     return set_HIT0_LO(env, (uint64_t)(uint32_t)arg1 *
 260                        (uint64_t)(uint32_t)arg2);
 261 }
 262
 263 target_ulong helper_mulshi(CPUMIPSState *env, target_ulong arg1,
 264                            target_ulong arg2)
 265 {
 266     return set_HIT0_LO(env, 0 - (int64_t)(int32_t)arg1 *
 267                        (int64_t)(int32_t)arg2);
 268 }
 269
 270 target_ulong helper_mulshiu(CPUMIPSState *env, target_ulong arg1,
 271                             target_ulong arg2)
 272 {
 273     return set_HIT0_LO(env, 0 - (uint64_t)(uint32_t)arg1 *
 274                        (uint64_t)(uint32_t)arg2);
 275 }
 276
 277 #ifdef TARGET_MIPS64
 278 void helper_dmult(CPUMIPSState *env, target_ulong arg1, target_ulong arg2)
 279 {
 280     muls64(&(env->active_tc.LO[0]), &(env->active_tc.HI[0]), arg1, arg2);
 281 }
 282
 283 void helper_dmultu(CPUMIPSState *env, target_ulong arg1, target_ulong arg2)
 284 {
 285     mulu64(&(env->active_tc.LO[0]), &(env->active_tc.HI[0]), arg1, arg2);
 286 }
 287 #endif
 288
 289 #ifndef CONFIG_USER_ONLY
 290
 291 static inline hwaddr do_translate_address(CPUMIPSState *env,
 292                                                       target_ulong address,
 293                                                       int rw)
 294 {
 295     hwaddr lladdr;
 296
 297     lladdr = cpu_mips_translate_address(env, address, rw);
 298
 299     if (lladdr == -1LL) {
 300         cpu_loop_exit(env);
 301     } else {
 302         return lladdr;
 303     }
 304 }
 305
 306 #define HELPER_LD_ATOMIC(name, insn)                                          \
 307 target_ulong helper_##name(CPUMIPSState *env, target_ulong arg, int mem_idx)  \
 308 {                                                                             \
 309     env->lladdr = do_translate_address(env, arg, 0);                          \
 310     env->llval = do_##insn(env, arg, mem_idx);                                \
 311     return env->llval;                                                        \
 312 }
 313 HELPER_LD_ATOMIC(ll, lw)
 314 #ifdef TARGET_MIPS64
 315 HELPER_LD_ATOMIC(lld, ld)
 316 #endif
 317 #undef HELPER_LD_ATOMIC
 318
 319 #define HELPER_ST_ATOMIC(name, ld_insn, st_insn, almask)                      \
 320 target_ulong helper_##name(CPUMIPSState *env, target_ulong arg1,              \
 321                            target_ulong arg2, int mem_idx)                    \
 322 {                                                                             \
 323     target_long tmp;                                                          \
 324                                                                               \
 325     if (arg2 & almask) {                                                      \
 326         env->CP0_BadVAddr = arg2;                                             \
 327         helper_raise_exception(env, EXCP_AdES);                               \
 328     }                                                                         \
 329     if (do_translate_address(env, arg2, 1) == env->lladdr) {                  \
 330         tmp = do_##ld_insn(env, arg2, mem_idx);                               \
 331         if (tmp == env->llval) {                                              \
 332             do_##st_insn(env, arg2, arg1, mem_idx);                           \
 333             return 1;                                                         \
 334         }                                                                     \
 335     }                                                                         \
 336     return 0;                                                                 \
 337 }
 338 HELPER_ST_ATOMIC(sc, lw, sw, 0x3)
 339 #ifdef TARGET_MIPS64
 340 HELPER_ST_ATOMIC(scd, ld, sd, 0x7)
 341 #endif
 342 #undef HELPER_ST_ATOMIC
 343 #endif
 344
 345 #ifdef TARGET_WORDS_BIGENDIAN
 346 #define GET_LMASK(v) ((v) & 3)
 347 #define GET_OFFSET(addr, offset) (addr + (offset))
 348 #else
 349 #define GET_LMASK(v) (((v) & 3) ^ 3)
 350 #define GET_OFFSET(addr, offset) (addr - (offset))
 351 #endif
 352
 353 target_ulong helper_lwl(CPUMIPSState *env, target_ulong arg1,
 354                         target_ulong arg2, int mem_idx)
 355 {
 356     target_ulong tmp;
 357
 358     tmp = do_lbu(env, arg2, mem_idx);
 359     arg1 = (arg1 & 0x00FFFFFF) | (tmp << 24);
 360
 361     if (GET_LMASK(arg2) <= 2) {
 362         tmp = do_lbu(env, GET_OFFSET(arg2, 1), mem_idx);
 363         arg1 = (arg1 & 0xFF00FFFF) | (tmp << 16);
 364     }
 365
 366     if (GET_LMASK(arg2) <= 1) {
 367         tmp = do_lbu(env, GET_OFFSET(arg2, 2), mem_idx);
 368         arg1 = (arg1 & 0xFFFF00FF) | (tmp << 8);
 369     }
 370
 371     if (GET_LMASK(arg2) == 0) {
 372         tmp = do_lbu(env, GET_OFFSET(arg2, 3), mem_idx);
 373         arg1 = (arg1 & 0xFFFFFF00) | tmp;
 374     }
 375     return (int32_t)arg1;
 376 }
 377
 378 target_ulong helper_lwr(CPUMIPSState *env, target_ulong arg1,
 379                         target_ulong arg2, int mem_idx)
 380 {
 381     target_ulong tmp;
 382
 383     tmp = do_lbu(env, arg2, mem_idx);
 384     arg1 = (arg1 & 0xFFFFFF00) | tmp;
 385
 386     if (GET_LMASK(arg2) >= 1) {
 387         tmp = do_lbu(env, GET_OFFSET(arg2, -1), mem_idx);
 388         arg1 = (arg1 & 0xFFFF00FF) | (tmp << 8);
 389     }
 390
 391     if (GET_LMASK(arg2) >= 2) {
 392         tmp = do_lbu(env, GET_OFFSET(arg2, -2), mem_idx);
 393         arg1 = (arg1 & 0xFF00FFFF) | (tmp << 16);
 394     }
 395
 396     if (GET_LMASK(arg2) == 3) {
 397         tmp = do_lbu(env, GET_OFFSET(arg2, -3), mem_idx);
 398         arg1 = (arg1 & 0x00FFFFFF) | (tmp << 24);
 399     }
 400     return (int32_t)arg1;
 401 }
 402
 403 void helper_swl(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
 404                 int mem_idx)
 405 {
 406     do_sb(env, arg2, (uint8_t)(arg1 >> 24), mem_idx);
 407
 408     if (GET_LMASK(arg2) <= 2)
 409         do_sb(env, GET_OFFSET(arg2, 1), (uint8_t)(arg1 >> 16), mem_idx);
 410
 411     if (GET_LMASK(arg2) <= 1)
 412         do_sb(env, GET_OFFSET(arg2, 2), (uint8_t)(arg1 >> 8), mem_idx);
 413
 414     if (GET_LMASK(arg2) == 0)
 415         do_sb(env, GET_OFFSET(arg2, 3), (uint8_t)arg1, mem_idx);
 416 }
 417
 418 void helper_swr(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
 419                 int mem_idx)
 420 {
 421     do_sb(env, arg2, (uint8_t)arg1, mem_idx);
 422
 423     if (GET_LMASK(arg2) >= 1)
 424         do_sb(env, GET_OFFSET(arg2, -1), (uint8_t)(arg1 >> 8), mem_idx);
 425
 426     if (GET_LMASK(arg2) >= 2)
 427         do_sb(env, GET_OFFSET(arg2, -2), (uint8_t)(arg1 >> 16), mem_idx);
 428
 429     if (GET_LMASK(arg2) == 3)
 430         do_sb(env, GET_OFFSET(arg2, -3), (uint8_t)(arg1 >> 24), mem_idx);
 431 }
 432
 433 #if defined(TARGET_MIPS64)
 434 /* "half" load and stores.  We must do the memory access inline,
 435    or fault handling won't work.  */
 436
 437 #ifdef TARGET_WORDS_BIGENDIAN
 438 #define GET_LMASK64(v) ((v) & 7)
 439 #else
 440 #define GET_LMASK64(v) (((v) & 7) ^ 7)
 441 #endif
 442
 443 target_ulong helper_ldl(CPUMIPSState *env, target_ulong arg1,
 444                         target_ulong arg2, int mem_idx)
 445 {
 446     uint64_t tmp;
 447
 448     tmp = do_lbu(env, arg2, mem_idx);
 449     arg1 = (arg1 & 0x00FFFFFFFFFFFFFFULL) | (tmp << 56);
 450
 451     if (GET_LMASK64(arg2) <= 6) {
 452         tmp = do_lbu(env, GET_OFFSET(arg2, 1), mem_idx);
 453         arg1 = (arg1 & 0xFF00FFFFFFFFFFFFULL) | (tmp << 48);
 454     }
 455
 456     if (GET_LMASK64(arg2) <= 5) {
 457         tmp = do_lbu(env, GET_OFFSET(arg2, 2), mem_idx);
 458         arg1 = (arg1 & 0xFFFF00FFFFFFFFFFULL) | (tmp << 40);
 459     }
 460
 461     if (GET_LMASK64(arg2) <= 4) {
 462         tmp = do_lbu(env, GET_OFFSET(arg2, 3), mem_idx);
 463         arg1 = (arg1 & 0xFFFFFF00FFFFFFFFULL) | (tmp << 32);
 464     }
 465
 466     if (GET_LMASK64(arg2) <= 3) {
 467         tmp = do_lbu(env, GET_OFFSET(arg2, 4), mem_idx);
 468         arg1 = (arg1 & 0xFFFFFFFF00FFFFFFULL) | (tmp << 24);
 469     }
 470
 471     if (GET_LMASK64(arg2) <= 2) {
 472         tmp = do_lbu(env, GET_OFFSET(arg2, 5), mem_idx);
 473         arg1 = (arg1 & 0xFFFFFFFFFF00FFFFULL) | (tmp << 16);
 474     }
 475
 476     if (GET_LMASK64(arg2) <= 1) {
 477         tmp = do_lbu(env, GET_OFFSET(arg2, 6), mem_idx);
 478         arg1 = (arg1 & 0xFFFFFFFFFFFF00FFULL) | (tmp << 8);
 479     }
 480
 481     if (GET_LMASK64(arg2) == 0) {
 482         tmp = do_lbu(env, GET_OFFSET(arg2, 7), mem_idx);
 483         arg1 = (arg1 & 0xFFFFFFFFFFFFFF00ULL) | tmp;
 484     }
 485
 486     return arg1;
 487 }
 488
 489 target_ulong helper_ldr(CPUMIPSState *env, target_ulong arg1,
 490                         target_ulong arg2, int mem_idx)
 491 {
 492     uint64_t tmp;
 493
 494     tmp = do_lbu(env, arg2, mem_idx);
 495     arg1 = (arg1 & 0xFFFFFFFFFFFFFF00ULL) | tmp;
 496
 497     if (GET_LMASK64(arg2) >= 1) {
 498         tmp = do_lbu(env, GET_OFFSET(arg2, -1), mem_idx);
 499         arg1 = (arg1 & 0xFFFFFFFFFFFF00FFULL) | (tmp  << 8);
 500     }
 501
 502     if (GET_LMASK64(arg2) >= 2) {
 503         tmp = do_lbu(env, GET_OFFSET(arg2, -2), mem_idx);
 504         arg1 = (arg1 & 0xFFFFFFFFFF00FFFFULL) | (tmp << 16);
 505     }
 506
 507     if (GET_LMASK64(arg2) >= 3) {
 508         tmp = do_lbu(env, GET_OFFSET(arg2, -3), mem_idx);
 509         arg1 = (arg1 & 0xFFFFFFFF00FFFFFFULL) | (tmp << 24);
 510     }
 511
 512     if (GET_LMASK64(arg2) >= 4) {
 513         tmp = do_lbu(env, GET_OFFSET(arg2, -4), mem_idx);
 514         arg1 = (arg1 & 0xFFFFFF00FFFFFFFFULL) | (tmp << 32);
 515     }
 516
 517     if (GET_LMASK64(arg2) >= 5) {
 518         tmp = do_lbu(env, GET_OFFSET(arg2, -5), mem_idx);
 519         arg1 = (arg1 & 0xFFFF00FFFFFFFFFFULL) | (tmp << 40);
 520     }
 521
 522     if (GET_LMASK64(arg2) >= 6) {
 523         tmp = do_lbu(env, GET_OFFSET(arg2, -6), mem_idx);
 524         arg1 = (arg1 & 0xFF00FFFFFFFFFFFFULL) | (tmp << 48);
 525     }
 526
 527     if (GET_LMASK64(arg2) == 7) {
 528         tmp = do_lbu(env, GET_OFFSET(arg2, -7), mem_idx);
 529         arg1 = (arg1 & 0x00FFFFFFFFFFFFFFULL) | (tmp << 56);
 530     }
 531
 532     return arg1;
 533 }
 534
 535 void helper_sdl(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
 536                 int mem_idx)
 537 {
 538     do_sb(env, arg2, (uint8_t)(arg1 >> 56), mem_idx);
 539
 540     if (GET_LMASK64(arg2) <= 6)
 541         do_sb(env, GET_OFFSET(arg2, 1), (uint8_t)(arg1 >> 48), mem_idx);
 542
 543     if (GET_LMASK64(arg2) <= 5)
 544         do_sb(env, GET_OFFSET(arg2, 2), (uint8_t)(arg1 >> 40), mem_idx);
 545
 546     if (GET_LMASK64(arg2) <= 4)
 547         do_sb(env, GET_OFFSET(arg2, 3), (uint8_t)(arg1 >> 32), mem_idx);
 548
 549     if (GET_LMASK64(arg2) <= 3)
 550         do_sb(env, GET_OFFSET(arg2, 4), (uint8_t)(arg1 >> 24), mem_idx);
 551
 552     if (GET_LMASK64(arg2) <= 2)
 553         do_sb(env, GET_OFFSET(arg2, 5), (uint8_t)(arg1 >> 16), mem_idx);
 554
 555     if (GET_LMASK64(arg2) <= 1)
 556         do_sb(env, GET_OFFSET(arg2, 6), (uint8_t)(arg1 >> 8), mem_idx);
 557
 558     if (GET_LMASK64(arg2) <= 0)
 559         do_sb(env, GET_OFFSET(arg2, 7), (uint8_t)arg1, mem_idx);
 560 }
 561
 562 void helper_sdr(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
 563                 int mem_idx)
 564 {
 565     do_sb(env, arg2, (uint8_t)arg1, mem_idx);
 566
 567     if (GET_LMASK64(arg2) >= 1)
 568         do_sb(env, GET_OFFSET(arg2, -1), (uint8_t)(arg1 >> 8), mem_idx);
 569
 570     if (GET_LMASK64(arg2) >= 2)
 571         do_sb(env, GET_OFFSET(arg2, -2), (uint8_t)(arg1 >> 16), mem_idx);
 572
 573     if (GET_LMASK64(arg2) >= 3)
 574         do_sb(env, GET_OFFSET(arg2, -3), (uint8_t)(arg1 >> 24), mem_idx);
 575
 576     if (GET_LMASK64(arg2) >= 4)
 577         do_sb(env, GET_OFFSET(arg2, -4), (uint8_t)(arg1 >> 32), mem_idx);
 578
 579     if (GET_LMASK64(arg2) >= 5)
 580         do_sb(env, GET_OFFSET(arg2, -5), (uint8_t)(arg1 >> 40), mem_idx);
 581
 582     if (GET_LMASK64(arg2) >= 6)
 583         do_sb(env, GET_OFFSET(arg2, -6), (uint8_t)(arg1 >> 48), mem_idx);
 584
 585     if (GET_LMASK64(arg2) == 7)
 586         do_sb(env, GET_OFFSET(arg2, -7), (uint8_t)(arg1 >> 56), mem_idx);
 587 }
 588 #endif /* TARGET_MIPS64 */
 589
 590 static const int multiple_regs[] = { 16, 17, 18, 19, 20, 21, 22, 23, 30 };
 591
 592 void helper_lwm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
 593                 uint32_t mem_idx)
 594 {
 595     target_ulong base_reglist = reglist & 0xf;
 596     target_ulong do_r31 = reglist & 0x10;
 597 #ifdef CONFIG_USER_ONLY
 598 #undef ldfun
 599 #define ldfun(env, addr) ldl_raw(addr)
 600 #else
 601     uint32_t (*ldfun)(CPUMIPSState *env, target_ulong);
 602
 603     switch (mem_idx)
 604     {
 605     case 0: ldfun = cpu_ldl_kernel; break;
 606     case 1: ldfun = cpu_ldl_super; break;
 607     default:
 608     case 2: ldfun = cpu_ldl_user; break;
 609     }
 610 #endif
 611
 612     if (base_reglist > 0 && base_reglist <= ARRAY_SIZE (multiple_regs)) {
 613         target_ulong i;
 614
 615         for (i = 0; i < base_reglist; i++) {
 616             env->active_tc.gpr[multiple_regs[i]] = (target_long)ldfun(env, addr);
 617             addr += 4;
 618         }
 619     }
 620
 621     if (do_r31) {
 622         env->active_tc.gpr[31] = (target_long)ldfun(env, addr);
 623     }
 624 }
 625
 626 void helper_swm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
 627                 uint32_t mem_idx)
 628 {
 629     target_ulong base_reglist = reglist & 0xf;
 630     target_ulong do_r31 = reglist & 0x10;
 631 #ifdef CONFIG_USER_ONLY
 632 #undef stfun
 633 #define stfun(env, addr, val) stl_raw(addr, val)
 634 #else
 635     void (*stfun)(CPUMIPSState *env, target_ulong, uint32_t);
 636
 637     switch (mem_idx)
 638     {
 639     case 0: stfun = cpu_stl_kernel; break;
 640     case 1: stfun = cpu_stl_super; break;
 641      default:
 642     case 2: stfun = cpu_stl_user; break;
 643     }
 644 #endif
 645
 646     if (base_reglist > 0 && base_reglist <= ARRAY_SIZE (multiple_regs)) {
 647         target_ulong i;
 648
 649         for (i = 0; i < base_reglist; i++) {
 650             stfun(env, addr, env->active_tc.gpr[multiple_regs[i]]);
 651             addr += 4;
 652         }
 653     }
 654
 655     if (do_r31) {
 656         stfun(env, addr, env->active_tc.gpr[31]);
 657     }
 658 }
 659
 660 #if defined(TARGET_MIPS64)
 661 void helper_ldm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
 662                 uint32_t mem_idx)
 663 {
 664     target_ulong base_reglist = reglist & 0xf;
 665     target_ulong do_r31 = reglist & 0x10;
 666 #ifdef CONFIG_USER_ONLY
 667 #undef ldfun
 668 #define ldfun(env, addr) ldq_raw(addr)
 669 #else
 670     uint64_t (*ldfun)(CPUMIPSState *env, target_ulong);
 671
 672     switch (mem_idx)
 673     {
 674     case 0: ldfun = cpu_ldq_kernel; break;
 675     case 1: ldfun = cpu_ldq_super; break;
 676     default:
 677     case 2: ldfun = cpu_ldq_user; break;
 678     }
 679 #endif
 680
 681     if (base_reglist > 0 && base_reglist <= ARRAY_SIZE (multiple_regs)) {
 682         target_ulong i;
 683
 684         for (i = 0; i < base_reglist; i++) {
 685             env->active_tc.gpr[multiple_regs[i]] = ldfun(env, addr);
 686             addr += 8;
 687         }
 688     }
 689
 690     if (do_r31) {
 691         env->active_tc.gpr[31] = ldfun(env, addr);
 692     }
 693 }
 694
 695 void helper_sdm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
 696                 uint32_t mem_idx)
 697 {
 698     target_ulong base_reglist = reglist & 0xf;
 699     target_ulong do_r31 = reglist & 0x10;
 700 #ifdef CONFIG_USER_ONLY
 701 #undef stfun
 702 #define stfun(env, addr, val) stq_raw(addr, val)
 703 #else
 704     void (*stfun)(CPUMIPSState *env, target_ulong, uint64_t);
 705
 706     switch (mem_idx)
 707     {
 708     case 0: stfun = cpu_stq_kernel; break;
 709     case 1: stfun = cpu_stq_super; break;
 710      default:
 711     case 2: stfun = cpu_stq_user; break;
 712     }
 713 #endif
 714
 715     if (base_reglist > 0 && base_reglist <= ARRAY_SIZE (multiple_regs)) {
 716         target_ulong i;
 717
 718         for (i = 0; i < base_reglist; i++) {
 719             stfun(env, addr, env->active_tc.gpr[multiple_regs[i]]);
 720             addr += 8;
 721         }
 722     }
 723
 724     if (do_r31) {
 725         stfun(env, addr, env->active_tc.gpr[31]);
 726     }
 727 }
 728 #endif
 729
 730 #ifndef CONFIG_USER_ONLY
 731 /* SMP helpers.  */
 732 static bool mips_vpe_is_wfi(MIPSCPU *c)
 733 {
 734     CPUMIPSState *env = &c->env;
 735
 736     /* If the VPE is halted but otherwise active, it means it's waiting for
 737        an interrupt.  */
 738     return env->halted && mips_vpe_active(env);
 739 }
 740
 741 static inline void mips_vpe_wake(CPUMIPSState *c)
 742 {
 743     /* Dont set ->halted = 0 directly, let it be done via cpu_has_work
 744        because there might be other conditions that state that c should
 745        be sleeping.  */
 746     cpu_interrupt(c, CPU_INTERRUPT_WAKE);
 747 }
 748
 749 static inline void mips_vpe_sleep(MIPSCPU *cpu)
 750 {
 751     CPUMIPSState *c = &cpu->env;
 752
 753     /* The VPE was shut off, really go to bed.
 754        Reset any old _WAKE requests.  */
 755     c->halted = 1;
 756     cpu_reset_interrupt(c, CPU_INTERRUPT_WAKE);
 757 }
 758
 759 static inline void mips_tc_wake(MIPSCPU *cpu, int tc)
 760 {
 761     CPUMIPSState *c = &cpu->env;
 762
 763     /* FIXME: TC reschedule.  */
 764     if (mips_vpe_active(c) && !mips_vpe_is_wfi(cpu)) {
 765         mips_vpe_wake(c);
 766     }
 767 }
 768
 769 static inline void mips_tc_sleep(MIPSCPU *cpu, int tc)
 770 {
 771     CPUMIPSState *c = &cpu->env;
 772
 773     /* FIXME: TC reschedule.  */
 774     if (!mips_vpe_active(c)) {
 775         mips_vpe_sleep(cpu);
 776     }
 777 }
 778
 779 /* tc should point to an int with the value of the global TC index.
 780    This function will transform it into a local index within the
 781    returned CPUMIPSState.
 782
 783    FIXME: This code assumes that all VPEs have the same number of TCs,
 784           which depends on runtime setup. Can probably be fixed by
 785           walking the list of CPUMIPSStates.  */
 786 static CPUMIPSState *mips_cpu_map_tc(CPUMIPSState *env, int *tc)
 787 {
 788     CPUMIPSState *other;
 789     int vpe_idx, nr_threads = env->nr_threads;
 790     int tc_idx = *tc;
 791
 792     if (!(env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP))) {
 793         /* Not allowed to address other CPUs.  */
 794         *tc = env->current_tc;
 795         return env;
 796     }
 797
 798     vpe_idx = tc_idx / nr_threads;
 799     *tc = tc_idx % nr_threads;
 800     other = qemu_get_cpu(vpe_idx);
 801     return other ? other : env;
 802 }
 803
 804 /* The per VPE CP0_Status register shares some fields with the per TC
 805    CP0_TCStatus registers. These fields are wired to the same registers,
 806    so changes to either of them should be reflected on both registers.
 807
 808    Also, EntryHi shares the bottom 8 bit ASID with TCStauts.
 809
 810    These helper call synchronizes the regs for a given cpu.  */
 811
 812 /* Called for updates to CP0_Status.  */
 813 static void sync_c0_status(CPUMIPSState *env, CPUMIPSState *cpu, int tc)
 814 {
 815     int32_t tcstatus, *tcst;
 816     uint32_t v = cpu->CP0_Status;
 817     uint32_t cu, mx, asid, ksu;
 818     uint32_t mask = ((1 << CP0TCSt_TCU3)
 819                        | (1 << CP0TCSt_TCU2)
 820                        | (1 << CP0TCSt_TCU1)
 821                        | (1 << CP0TCSt_TCU0)
 822                        | (1 << CP0TCSt_TMX)
 823                        | (3 << CP0TCSt_TKSU)
 824                        | (0xff << CP0TCSt_TASID));
 825
 826     cu = (v >> CP0St_CU0) & 0xf;
 827     mx = (v >> CP0St_MX) & 0x1;
 828     ksu = (v >> CP0St_KSU) & 0x3;
 829     asid = env->CP0_EntryHi & 0xff;
 830
 831     tcstatus = cu << CP0TCSt_TCU0;
 832     tcstatus |= mx << CP0TCSt_TMX;
 833     tcstatus |= ksu << CP0TCSt_TKSU;
 834     tcstatus |= asid;
 835
 836     if (tc == cpu->current_tc) {
 837         tcst = &cpu->active_tc.CP0_TCStatus;
 838     } else {
 839         tcst = &cpu->tcs[tc].CP0_TCStatus;
 840     }
 841
 842     *tcst &= ~mask;
 843     *tcst |= tcstatus;
 844     compute_hflags(cpu);
 845 }
 846
 847 /* Called for updates to CP0_TCStatus.  */
 848 static void sync_c0_tcstatus(CPUMIPSState *cpu, int tc,
 849                              target_ulong v)
 850 {
 851     uint32_t status;
 852     uint32_t tcu, tmx, tasid, tksu;
 853     uint32_t mask = ((1 << CP0St_CU3)
 854                        | (1 << CP0St_CU2)
 855                        | (1 << CP0St_CU1)
 856                        | (1 << CP0St_CU0)
 857                        | (1 << CP0St_MX)
 858                        | (3 << CP0St_KSU));
 859
 860     tcu = (v >> CP0TCSt_TCU0) & 0xf;
 861     tmx = (v >> CP0TCSt_TMX) & 0x1;
 862     tasid = v & 0xff;
 863     tksu = (v >> CP0TCSt_TKSU) & 0x3;
 864
 865     status = tcu << CP0St_CU0;
 866     status |= tmx << CP0St_MX;
 867     status |= tksu << CP0St_KSU;
 868
 869     cpu->CP0_Status &= ~mask;
 870     cpu->CP0_Status |= status;
 871
 872     /* Sync the TASID with EntryHi.  */
 873     cpu->CP0_EntryHi &= ~0xff;
 874     cpu->CP0_EntryHi = tasid;
 875
 876     compute_hflags(cpu);
 877 }
 878
 879 /* Called for updates to CP0_EntryHi.  */
 880 static void sync_c0_entryhi(CPUMIPSState *cpu, int tc)
 881 {
 882     int32_t *tcst;
 883     uint32_t asid, v = cpu->CP0_EntryHi;
 884
 885     asid = v & 0xff;
 886
 887     if (tc == cpu->current_tc) {
 888         tcst = &cpu->active_tc.CP0_TCStatus;
 889     } else {
 890         tcst = &cpu->tcs[tc].CP0_TCStatus;
 891     }
 892
 893     *tcst &= ~0xff;
 894     *tcst |= asid;
 895 }
 896
 897 /* CP0 helpers */
 898 target_ulong helper_mfc0_mvpcontrol(CPUMIPSState *env)
 899 {
 900     return env->mvp->CP0_MVPControl;
 901 }
 902
 903 target_ulong helper_mfc0_mvpconf0(CPUMIPSState *env)
 904 {
 905     return env->mvp->CP0_MVPConf0;
 906 }
 907
 908 target_ulong helper_mfc0_mvpconf1(CPUMIPSState *env)
 909 {
 910     return env->mvp->CP0_MVPConf1;
 911 }
 912
 913 target_ulong helper_mfc0_random(CPUMIPSState *env)
 914 {
 915     return (int32_t)cpu_mips_get_random(env);
 916 }
 917
 918 target_ulong helper_mfc0_tcstatus(CPUMIPSState *env)
 919 {
 920     return env->active_tc.CP0_TCStatus;
 921 }
 922
 923 target_ulong helper_mftc0_tcstatus(CPUMIPSState *env)
 924 {
 925     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
 926     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
 927
 928     if (other_tc == other->current_tc)
 929         return other->active_tc.CP0_TCStatus;
 930     else
 931         return other->tcs[other_tc].CP0_TCStatus;
 932 }
 933
 934 target_ulong helper_mfc0_tcbind(CPUMIPSState *env)
 935 {
 936     return env->active_tc.CP0_TCBind;
 937 }
 938
 939 target_ulong helper_mftc0_tcbind(CPUMIPSState *env)
 940 {
 941     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
 942     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
 943
 944     if (other_tc == other->current_tc)
 945         return other->active_tc.CP0_TCBind;
 946     else
 947         return other->tcs[other_tc].CP0_TCBind;
 948 }
 949
 950 target_ulong helper_mfc0_tcrestart(CPUMIPSState *env)
 951 {
 952     return env->active_tc.PC;
 953 }
 954
 955 target_ulong helper_mftc0_tcrestart(CPUMIPSState *env)
 956 {
 957     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
 958     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
 959
 960     if (other_tc == other->current_tc)
 961         return other->active_tc.PC;
 962     else
 963         return other->tcs[other_tc].PC;
 964 }
 965
 966 target_ulong helper_mfc0_tchalt(CPUMIPSState *env)
 967 {
 968     return env->active_tc.CP0_TCHalt;
 969 }
 970
 971 target_ulong helper_mftc0_tchalt(CPUMIPSState *env)
 972 {
 973     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
 974     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
 975
 976     if (other_tc == other->current_tc)
 977         return other->active_tc.CP0_TCHalt;
 978     else
 979         return other->tcs[other_tc].CP0_TCHalt;
 980 }
 981
 982 target_ulong helper_mfc0_tccontext(CPUMIPSState *env)
 983 {
 984     return env->active_tc.CP0_TCContext;
 985 }
 986
 987 target_ulong helper_mftc0_tccontext(CPUMIPSState *env)
 988 {
 989     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
 990     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
 991
 992     if (other_tc == other->current_tc)
 993         return other->active_tc.CP0_TCContext;
 994     else
 995         return other->tcs[other_tc].CP0_TCContext;
 996 }
 997
 998 target_ulong helper_mfc0_tcschedule(CPUMIPSState *env)
 999 {
1000     return env->active_tc.CP0_TCSchedule;
1001 }
1002
1003 target_ulong helper_mftc0_tcschedule(CPUMIPSState *env)
1004 {
1005     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1006     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1007
1008     if (other_tc == other->current_tc)
1009         return other->active_tc.CP0_TCSchedule;
1010     else
1011         return other->tcs[other_tc].CP0_TCSchedule;
1012 }
1013
1014 target_ulong helper_mfc0_tcschefback(CPUMIPSState *env)
1015 {
1016     return env->active_tc.CP0_TCScheFBack;
1017 }
1018
1019 target_ulong helper_mftc0_tcschefback(CPUMIPSState *env)
1020 {
1021     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1022     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1023
1024     if (other_tc == other->current_tc)
1025         return other->active_tc.CP0_TCScheFBack;
1026     else
1027         return other->tcs[other_tc].CP0_TCScheFBack;
1028 }
1029
1030 target_ulong helper_mfc0_count(CPUMIPSState *env)
1031 {
1032     return (int32_t)cpu_mips_get_count(env);
1033 }
1034
1035 target_ulong helper_mftc0_entryhi(CPUMIPSState *env)
1036 {
1037     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1038     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1039
1040     return other->CP0_EntryHi;
1041 }
1042
1043 target_ulong helper_mftc0_cause(CPUMIPSState *env)
1044 {
1045     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1046     int32_t tccause;
1047     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1048
1049     if (other_tc == other->current_tc) {
1050         tccause = other->CP0_Cause;
1051     } else {
1052         tccause = other->CP0_Cause;
1053     }
1054
1055     return tccause;
1056 }
1057
1058 target_ulong helper_mftc0_status(CPUMIPSState *env)
1059 {
1060     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1061     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1062
1063     return other->CP0_Status;
1064 }
1065
1066 target_ulong helper_mfc0_lladdr(CPUMIPSState *env)
1067 {
1068     return (int32_t)(env->lladdr >> env->CP0_LLAddr_shift);
1069 }
1070
1071 target_ulong helper_mfc0_watchlo(CPUMIPSState *env, uint32_t sel)
1072 {
1073     return (int32_t)env->CP0_WatchLo[sel];
1074 }
1075
1076 target_ulong helper_mfc0_watchhi(CPUMIPSState *env, uint32_t sel)
1077 {
1078     return env->CP0_WatchHi[sel];
1079 }
1080
1081 target_ulong helper_mfc0_debug(CPUMIPSState *env)
1082 {
1083     target_ulong t0 = env->CP0_Debug;
1084     if (env->hflags & MIPS_HFLAG_DM)
1085         t0 |= 1 << CP0DB_DM;
1086
1087     return t0;
1088 }
1089
1090 target_ulong helper_mftc0_debug(CPUMIPSState *env)
1091 {
1092     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1093     int32_t tcstatus;
1094     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1095
1096     if (other_tc == other->current_tc)
1097         tcstatus = other->active_tc.CP0_Debug_tcstatus;
1098     else
1099         tcstatus = other->tcs[other_tc].CP0_Debug_tcstatus;
1100
1101     /* XXX: Might be wrong, check with EJTAG spec. */
1102     return (other->CP0_Debug & ~((1 << CP0DB_SSt) | (1 << CP0DB_Halt))) |
1103             (tcstatus & ((1 << CP0DB_SSt) | (1 << CP0DB_Halt)));
1104 }
1105
1106 #if defined(TARGET_MIPS64)
1107 target_ulong helper_dmfc0_tcrestart(CPUMIPSState *env)
1108 {
1109     return env->active_tc.PC;
1110 }
1111
1112 target_ulong helper_dmfc0_tchalt(CPUMIPSState *env)
1113 {
1114     return env->active_tc.CP0_TCHalt;
1115 }
1116
1117 target_ulong helper_dmfc0_tccontext(CPUMIPSState *env)
1118 {
1119     return env->active_tc.CP0_TCContext;
1120 }
1121
1122 target_ulong helper_dmfc0_tcschedule(CPUMIPSState *env)
1123 {
1124     return env->active_tc.CP0_TCSchedule;
1125 }
1126
1127 target_ulong helper_dmfc0_tcschefback(CPUMIPSState *env)
1128 {
1129     return env->active_tc.CP0_TCScheFBack;
1130 }
1131
1132 target_ulong helper_dmfc0_lladdr(CPUMIPSState *env)
1133 {
1134     return env->lladdr >> env->CP0_LLAddr_shift;
1135 }
1136
1137 target_ulong helper_dmfc0_watchlo(CPUMIPSState *env, uint32_t sel)
1138 {
1139     return env->CP0_WatchLo[sel];
1140 }
1141 #endif /* TARGET_MIPS64 */
1142
1143 void helper_mtc0_index(CPUMIPSState *env, target_ulong arg1)
1144 {
1145     int num = 1;
1146     unsigned int tmp = env->tlb->nb_tlb;
1147
1148     do {
1149         tmp >>= 1;
1150         num <<= 1;
1151     } while (tmp);
1152     env->CP0_Index = (env->CP0_Index & 0x80000000) | (arg1 & (num - 1));
1153 }
1154
1155 void helper_mtc0_mvpcontrol(CPUMIPSState *env, target_ulong arg1)
1156 {
1157     uint32_t mask = 0;
1158     uint32_t newval;
1159
1160     if (env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP))
1161         mask |= (1 << CP0MVPCo_CPA) | (1 << CP0MVPCo_VPC) |
1162                 (1 << CP0MVPCo_EVP);
1163     if (env->mvp->CP0_MVPControl & (1 << CP0MVPCo_VPC))
1164         mask |= (1 << CP0MVPCo_STLB);
1165     newval = (env->mvp->CP0_MVPControl & ~mask) | (arg1 & mask);
1166
1167     // TODO: Enable/disable shared TLB, enable/disable VPEs.
1168
1169     env->mvp->CP0_MVPControl = newval;
1170 }
1171
1172 void helper_mtc0_vpecontrol(CPUMIPSState *env, target_ulong arg1)
1173 {
1174     uint32_t mask;
1175     uint32_t newval;
1176
1177     mask = (1 << CP0VPECo_YSI) | (1 << CP0VPECo_GSI) |
1178            (1 << CP0VPECo_TE) | (0xff << CP0VPECo_TargTC);
1179     newval = (env->CP0_VPEControl & ~mask) | (arg1 & mask);
1180
1181     /* Yield scheduler intercept not implemented. */
1182     /* Gating storage scheduler intercept not implemented. */
1183
1184     // TODO: Enable/disable TCs.
1185
1186     env->CP0_VPEControl = newval;
1187 }
1188
1189 void helper_mttc0_vpecontrol(CPUMIPSState *env, target_ulong arg1)
1190 {
1191     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1192     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1193     uint32_t mask;
1194     uint32_t newval;
1195
1196     mask = (1 << CP0VPECo_YSI) | (1 << CP0VPECo_GSI) |
1197            (1 << CP0VPECo_TE) | (0xff << CP0VPECo_TargTC);
1198     newval = (other->CP0_VPEControl & ~mask) | (arg1 & mask);
1199
1200     /* TODO: Enable/disable TCs.  */
1201
1202     other->CP0_VPEControl = newval;
1203 }
1204
1205 target_ulong helper_mftc0_vpecontrol(CPUMIPSState *env)
1206 {
1207     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1208     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1209     /* FIXME: Mask away return zero on read bits.  */
1210     return other->CP0_VPEControl;
1211 }
1212
1213 target_ulong helper_mftc0_vpeconf0(CPUMIPSState *env)
1214 {
1215     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1216     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1217
1218     return other->CP0_VPEConf0;
1219 }
1220
1221 void helper_mtc0_vpeconf0(CPUMIPSState *env, target_ulong arg1)
1222 {
1223     uint32_t mask = 0;
1224     uint32_t newval;
1225
1226     if (env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP)) {
1227         if (env->CP0_VPEConf0 & (1 << CP0VPEC0_VPA))
1228             mask |= (0xff << CP0VPEC0_XTC);
1229         mask |= (1 << CP0VPEC0_MVP) | (1 << CP0VPEC0_VPA);
1230     }
1231     newval = (env->CP0_VPEConf0 & ~mask) | (arg1 & mask);
1232
1233     // TODO: TC exclusive handling due to ERL/EXL.
1234
1235     env->CP0_VPEConf0 = newval;
1236 }
1237
1238 void helper_mttc0_vpeconf0(CPUMIPSState *env, target_ulong arg1)
1239 {
1240     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1241     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1242     uint32_t mask = 0;
1243     uint32_t newval;
1244
1245     mask |= (1 << CP0VPEC0_MVP) | (1 << CP0VPEC0_VPA);
1246     newval = (other->CP0_VPEConf0 & ~mask) | (arg1 & mask);
1247
1248     /* TODO: TC exclusive handling due to ERL/EXL.  */
1249     other->CP0_VPEConf0 = newval;
1250 }
1251
1252 void helper_mtc0_vpeconf1(CPUMIPSState *env, target_ulong arg1)
1253 {
1254     uint32_t mask = 0;
1255     uint32_t newval;
1256
1257     if (env->mvp->CP0_MVPControl & (1 << CP0MVPCo_VPC))
1258         mask |= (0xff << CP0VPEC1_NCX) | (0xff << CP0VPEC1_NCP2) |
1259                 (0xff << CP0VPEC1_NCP1);
1260     newval = (env->CP0_VPEConf1 & ~mask) | (arg1 & mask);
1261
1262     /* UDI not implemented. */
1263     /* CP2 not implemented. */
1264
1265     // TODO: Handle FPU (CP1) binding.
1266
1267     env->CP0_VPEConf1 = newval;
1268 }
1269
1270 void helper_mtc0_yqmask(CPUMIPSState *env, target_ulong arg1)
1271 {
1272     /* Yield qualifier inputs not implemented. */
1273     env->CP0_YQMask = 0x00000000;
1274 }
1275
1276 void helper_mtc0_vpeopt(CPUMIPSState *env, target_ulong arg1)
1277 {
1278     env->CP0_VPEOpt = arg1 & 0x0000ffff;
1279 }
1280
1281 void helper_mtc0_entrylo0(CPUMIPSState *env, target_ulong arg1)
1282 {
1283     /* Large physaddr (PABITS) not implemented */
1284     /* 1k pages not implemented */
1285     env->CP0_EntryLo0 = arg1 & 0x3FFFFFFF;
1286 }
1287
1288 void helper_mtc0_tcstatus(CPUMIPSState *env, target_ulong arg1)
1289 {
1290     uint32_t mask = env->CP0_TCStatus_rw_bitmask;
1291     uint32_t newval;
1292
1293     newval = (env->active_tc.CP0_TCStatus & ~mask) | (arg1 & mask);
1294
1295     env->active_tc.CP0_TCStatus = newval;
1296     sync_c0_tcstatus(env, env->current_tc, newval);
1297 }
1298
1299 void helper_mttc0_tcstatus(CPUMIPSState *env, target_ulong arg1)
1300 {
1301     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1302     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1303
1304     if (other_tc == other->current_tc)
1305         other->active_tc.CP0_TCStatus = arg1;
1306     else
1307         other->tcs[other_tc].CP0_TCStatus = arg1;
1308     sync_c0_tcstatus(other, other_tc, arg1);
1309 }
1310
1311 void helper_mtc0_tcbind(CPUMIPSState *env, target_ulong arg1)
1312 {
1313     uint32_t mask = (1 << CP0TCBd_TBE);
1314     uint32_t newval;
1315
1316     if (env->mvp->CP0_MVPControl & (1 << CP0MVPCo_VPC))
1317         mask |= (1 << CP0TCBd_CurVPE);
1318     newval = (env->active_tc.CP0_TCBind & ~mask) | (arg1 & mask);
1319     env->active_tc.CP0_TCBind = newval;
1320 }
1321
1322 void helper_mttc0_tcbind(CPUMIPSState *env, target_ulong arg1)
1323 {
1324     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1325     uint32_t mask = (1 << CP0TCBd_TBE);
1326     uint32_t newval;
1327     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1328
1329     if (other->mvp->CP0_MVPControl & (1 << CP0MVPCo_VPC))
1330         mask |= (1 << CP0TCBd_CurVPE);
1331     if (other_tc == other->current_tc) {
1332         newval = (other->active_tc.CP0_TCBind & ~mask) | (arg1 & mask);
1333         other->active_tc.CP0_TCBind = newval;
1334     } else {
1335         newval = (other->tcs[other_tc].CP0_TCBind & ~mask) | (arg1 & mask);
1336         other->tcs[other_tc].CP0_TCBind = newval;
1337     }
1338 }
1339
1340 void helper_mtc0_tcrestart(CPUMIPSState *env, target_ulong arg1)
1341 {
1342     env->active_tc.PC = arg1;
1343     env->active_tc.CP0_TCStatus &= ~(1 << CP0TCSt_TDS);
1344     env->lladdr = 0ULL;
1345     /* MIPS16 not implemented. */
1346 }
1347
1348 void helper_mttc0_tcrestart(CPUMIPSState *env, target_ulong arg1)
1349 {
1350     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1351     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1352
1353     if (other_tc == other->current_tc) {
1354         other->active_tc.PC = arg1;
1355         other->active_tc.CP0_TCStatus &= ~(1 << CP0TCSt_TDS);
1356         other->lladdr = 0ULL;
1357         /* MIPS16 not implemented. */
1358     } else {
1359         other->tcs[other_tc].PC = arg1;
1360         other->tcs[other_tc].CP0_TCStatus &= ~(1 << CP0TCSt_TDS);
1361         other->lladdr = 0ULL;
1362         /* MIPS16 not implemented. */
1363     }
1364 }
1365
1366 void helper_mtc0_tchalt(CPUMIPSState *env, target_ulong arg1)
1367 {
1368     MIPSCPU *cpu = mips_env_get_cpu(env);
1369
1370     env->active_tc.CP0_TCHalt = arg1 & 0x1;
1371
1372     // TODO: Halt TC / Restart (if allocated+active) TC.
1373     if (env->active_tc.CP0_TCHalt & 1) {
1374         mips_tc_sleep(cpu, env->current_tc);
1375     } else {
1376         mips_tc_wake(cpu, env->current_tc);
1377     }
1378 }
1379
1380 void helper_mttc0_tchalt(CPUMIPSState *env, target_ulong arg1)
1381 {
1382     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1383     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1384     MIPSCPU *other_cpu = mips_env_get_cpu(other);
1385
1386     // TODO: Halt TC / Restart (if allocated+active) TC.
1387
1388     if (other_tc == other->current_tc)
1389         other->active_tc.CP0_TCHalt = arg1;
1390     else
1391         other->tcs[other_tc].CP0_TCHalt = arg1;
1392
1393     if (arg1 & 1) {
1394         mips_tc_sleep(other_cpu, other_tc);
1395     } else {
1396         mips_tc_wake(other_cpu, other_tc);
1397     }
1398 }
1399
1400 void helper_mtc0_tccontext(CPUMIPSState *env, target_ulong arg1)
1401 {
1402     env->active_tc.CP0_TCContext = arg1;
1403 }
1404
1405 void helper_mttc0_tccontext(CPUMIPSState *env, target_ulong arg1)
1406 {
1407     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1408     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1409
1410     if (other_tc == other->current_tc)
1411         other->active_tc.CP0_TCContext = arg1;
1412     else
1413         other->tcs[other_tc].CP0_TCContext = arg1;
1414 }
1415
1416 void helper_mtc0_tcschedule(CPUMIPSState *env, target_ulong arg1)
1417 {
1418     env->active_tc.CP0_TCSchedule = arg1;
1419 }
1420
1421 void helper_mttc0_tcschedule(CPUMIPSState *env, target_ulong arg1)
1422 {
1423     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1424     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1425
1426     if (other_tc == other->current_tc)
1427         other->active_tc.CP0_TCSchedule = arg1;
1428     else
1429         other->tcs[other_tc].CP0_TCSchedule = arg1;
1430 }
1431
1432 void helper_mtc0_tcschefback(CPUMIPSState *env, target_ulong arg1)
1433 {
1434     env->active_tc.CP0_TCScheFBack = arg1;
1435 }
1436
1437 void helper_mttc0_tcschefback(CPUMIPSState *env, target_ulong arg1)
1438 {
1439     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1440     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1441
1442     if (other_tc == other->current_tc)
1443         other->active_tc.CP0_TCScheFBack = arg1;
1444     else
1445         other->tcs[other_tc].CP0_TCScheFBack = arg1;
1446 }
1447
1448 void helper_mtc0_entrylo1(CPUMIPSState *env, target_ulong arg1)
1449 {
1450     /* Large physaddr (PABITS) not implemented */
1451     /* 1k pages not implemented */
1452     env->CP0_EntryLo1 = arg1 & 0x3FFFFFFF;
1453 }
1454
1455 void helper_mtc0_context(CPUMIPSState *env, target_ulong arg1)
1456 {
1457     env->CP0_Context = (env->CP0_Context & 0x007FFFFF) | (arg1 & ~0x007FFFFF);
1458 }
1459
1460 void helper_mtc0_pagemask(CPUMIPSState *env, target_ulong arg1)
1461 {
1462     /* 1k pages not implemented */
1463     env->CP0_PageMask = arg1 & (0x1FFFFFFF & (TARGET_PAGE_MASK << 1));
1464 }
1465
1466 void helper_mtc0_pagegrain(CPUMIPSState *env, target_ulong arg1)
1467 {
1468     /* SmartMIPS not implemented */
1469     /* Large physaddr (PABITS) not implemented */
1470     /* 1k pages not implemented */
1471     env->CP0_PageGrain = 0;
1472 }
1473
1474 void helper_mtc0_wired(CPUMIPSState *env, target_ulong arg1)
1475 {
1476     env->CP0_Wired = arg1 % env->tlb->nb_tlb;
1477 }
1478
1479 void helper_mtc0_srsconf0(CPUMIPSState *env, target_ulong arg1)
1480 {
1481     env->CP0_SRSConf0 |= arg1 & env->CP0_SRSConf0_rw_bitmask;
1482 }
1483
1484 void helper_mtc0_srsconf1(CPUMIPSState *env, target_ulong arg1)
1485 {
1486     env->CP0_SRSConf1 |= arg1 & env->CP0_SRSConf1_rw_bitmask;
1487 }
1488
1489 void helper_mtc0_srsconf2(CPUMIPSState *env, target_ulong arg1)
1490 {
1491     env->CP0_SRSConf2 |= arg1 & env->CP0_SRSConf2_rw_bitmask;
1492 }
1493
1494 void helper_mtc0_srsconf3(CPUMIPSState *env, target_ulong arg1)
1495 {
1496     env->CP0_SRSConf3 |= arg1 & env->CP0_SRSConf3_rw_bitmask;
1497 }
1498
1499 void helper_mtc0_srsconf4(CPUMIPSState *env, target_ulong arg1)
1500 {
1501     env->CP0_SRSConf4 |= arg1 & env->CP0_SRSConf4_rw_bitmask;
1502 }
1503
1504 void helper_mtc0_hwrena(CPUMIPSState *env, target_ulong arg1)
1505 {
1506     env->CP0_HWREna = arg1 & 0x0000000F;
1507 }
1508
1509 void helper_mtc0_count(CPUMIPSState *env, target_ulong arg1)
1510 {
1511     cpu_mips_store_count(env, arg1);
1512 }
1513
1514 void helper_mtc0_entryhi(CPUMIPSState *env, target_ulong arg1)
1515 {
1516     target_ulong old, val;
1517
1518     /* 1k pages not implemented */
1519     val = arg1 & ((TARGET_PAGE_MASK << 1) | 0xFF);
1520 #if defined(TARGET_MIPS64)
1521     val &= env->SEGMask;
1522 #endif
1523     old = env->CP0_EntryHi;
1524     env->CP0_EntryHi = val;
1525     if (env->CP0_Config3 & (1 << CP0C3_MT)) {
1526         sync_c0_entryhi(env, env->current_tc);
1527     }
1528     /* If the ASID changes, flush qemu's TLB.  */
1529     if ((old & 0xFF) != (val & 0xFF))
1530         cpu_mips_tlb_flush(env, 1);
1531 }
1532
1533 void helper_mttc0_entryhi(CPUMIPSState *env, target_ulong arg1)
1534 {
1535     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1536     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1537
1538     other->CP0_EntryHi = arg1;
1539     sync_c0_entryhi(other, other_tc);
1540 }
1541
1542 void helper_mtc0_compare(CPUMIPSState *env, target_ulong arg1)
1543 {
1544     cpu_mips_store_compare(env, arg1);
1545 }
1546
1547 void helper_mtc0_status(CPUMIPSState *env, target_ulong arg1)
1548 {
1549     uint32_t val, old;
1550     uint32_t mask = env->CP0_Status_rw_bitmask;
1551
1552     val = arg1 & mask;
1553     old = env->CP0_Status;
1554     env->CP0_Status = (env->CP0_Status & ~mask) | val;
1555     if (env->CP0_Config3 & (1 << CP0C3_MT)) {
1556         sync_c0_status(env, env, env->current_tc);
1557     } else {
1558         compute_hflags(env);
1559     }
1560
1561     if (qemu_loglevel_mask(CPU_LOG_EXEC)) {
1562         qemu_log("Status %08x (%08x) => %08x (%08x) Cause %08x",
1563                 old, old & env->CP0_Cause & CP0Ca_IP_mask,
1564                 val, val & env->CP0_Cause & CP0Ca_IP_mask,
1565                 env->CP0_Cause);
1566         switch (env->hflags & MIPS_HFLAG_KSU) {
1567         case MIPS_HFLAG_UM: qemu_log(", UM\n"); break;
1568         case MIPS_HFLAG_SM: qemu_log(", SM\n"); break;
1569         case MIPS_HFLAG_KM: qemu_log("\n"); break;
1570         default: cpu_abort(env, "Invalid MMU mode!\n"); break;
1571         }
1572     }
1573 }
1574
1575 void helper_mttc0_status(CPUMIPSState *env, target_ulong arg1)
1576 {
1577     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1578     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1579
1580     other->CP0_Status = arg1 & ~0xf1000018;
1581     sync_c0_status(env, other, other_tc);
1582 }
1583
1584 void helper_mtc0_intctl(CPUMIPSState *env, target_ulong arg1)
1585 {
1586     /* vectored interrupts not implemented, no performance counters. */
1587     env->CP0_IntCtl = (env->CP0_IntCtl & ~0x000003e0) | (arg1 & 0x000003e0);
1588 }
1589
1590 void helper_mtc0_srsctl(CPUMIPSState *env, target_ulong arg1)
1591 {
1592     uint32_t mask = (0xf << CP0SRSCtl_ESS) | (0xf << CP0SRSCtl_PSS);
1593     env->CP0_SRSCtl = (env->CP0_SRSCtl & ~mask) | (arg1 & mask);
1594 }
1595
1596 static void mtc0_cause(CPUMIPSState *cpu, target_ulong arg1)
1597 {
1598     uint32_t mask = 0x00C00300;
1599     uint32_t old = cpu->CP0_Cause;
1600     int i;
1601
1602     if (cpu->insn_flags & ISA_MIPS32R2) {
1603         mask |= 1 << CP0Ca_DC;
1604     }
1605
1606     cpu->CP0_Cause = (cpu->CP0_Cause & ~mask) | (arg1 & mask);
1607
1608     if ((old ^ cpu->CP0_Cause) & (1 << CP0Ca_DC)) {
1609         if (cpu->CP0_Cause & (1 << CP0Ca_DC)) {
1610             cpu_mips_stop_count(cpu);
1611         } else {
1612             cpu_mips_start_count(cpu);
1613         }
1614     }
1615
1616     /* Set/reset software interrupts */
1617     for (i = 0 ; i < 2 ; i++) {
1618         if ((old ^ cpu->CP0_Cause) & (1 << (CP0Ca_IP + i))) {
1619             cpu_mips_soft_irq(cpu, i, cpu->CP0_Cause & (1 << (CP0Ca_IP + i)));
1620         }
1621     }
1622 }
1623
1624 void helper_mtc0_cause(CPUMIPSState *env, target_ulong arg1)
1625 {
1626     mtc0_cause(env, arg1);
1627 }
1628
1629 void helper_mttc0_cause(CPUMIPSState *env, target_ulong arg1)
1630 {
1631     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1632     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1633
1634     mtc0_cause(other, arg1);
1635 }
1636
1637 target_ulong helper_mftc0_epc(CPUMIPSState *env)
1638 {
1639     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1640     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1641
1642     return other->CP0_EPC;
1643 }
1644
1645 target_ulong helper_mftc0_ebase(CPUMIPSState *env)
1646 {
1647     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1648     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1649
1650     return other->CP0_EBase;
1651 }
1652
1653 void helper_mtc0_ebase(CPUMIPSState *env, target_ulong arg1)
1654 {
1655     /* vectored interrupts not implemented */
1656     env->CP0_EBase = (env->CP0_EBase & ~0x3FFFF000) | (arg1 & 0x3FFFF000);
1657 }
1658
1659 void helper_mttc0_ebase(CPUMIPSState *env, target_ulong arg1)
1660 {
1661     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1662     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1663     other->CP0_EBase = (other->CP0_EBase & ~0x3FFFF000) | (arg1 & 0x3FFFF000);
1664 }
1665
1666 target_ulong helper_mftc0_configx(CPUMIPSState *env, target_ulong idx)
1667 {
1668     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1669     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1670
1671     switch (idx) {
1672     case 0: return other->CP0_Config0;
1673     case 1: return other->CP0_Config1;
1674     case 2: return other->CP0_Config2;
1675     case 3: return other->CP0_Config3;
1676     /* 4 and 5 are reserved.  */
1677     case 6: return other->CP0_Config6;
1678     case 7: return other->CP0_Config7;
1679     default:
1680         break;
1681     }
1682     return 0;
1683 }
1684
1685 void helper_mtc0_config0(CPUMIPSState *env, target_ulong arg1)
1686 {
1687     env->CP0_Config0 = (env->CP0_Config0 & 0x81FFFFF8) | (arg1 & 0x00000007);
1688 }
1689
1690 void helper_mtc0_config2(CPUMIPSState *env, target_ulong arg1)
1691 {
1692     /* tertiary/secondary caches not implemented */
1693     env->CP0_Config2 = (env->CP0_Config2 & 0x8FFF0FFF);
1694 }
1695
1696 void helper_mtc0_lladdr(CPUMIPSState *env, target_ulong arg1)
1697 {
1698     target_long mask = env->CP0_LLAddr_rw_bitmask;
1699     arg1 = arg1 << env->CP0_LLAddr_shift;
1700     env->lladdr = (env->lladdr & ~mask) | (arg1 & mask);
1701 }
1702
1703 void helper_mtc0_watchlo(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1704 {
1705     /* Watch exceptions for instructions, data loads, data stores
1706        not implemented. */
1707     env->CP0_WatchLo[sel] = (arg1 & ~0x7);
1708 }
1709
1710 void helper_mtc0_watchhi(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1711 {
1712     env->CP0_WatchHi[sel] = (arg1 & 0x40FF0FF8);
1713     env->CP0_WatchHi[sel] &= ~(env->CP0_WatchHi[sel] & arg1 & 0x7);
1714 }
1715
1716 void helper_mtc0_xcontext(CPUMIPSState *env, target_ulong arg1)
1717 {
1718     target_ulong mask = (1ULL << (env->SEGBITS - 7)) - 1;
1719     env->CP0_XContext = (env->CP0_XContext & mask) | (arg1 & ~mask);
1720 }
1721
1722 void helper_mtc0_framemask(CPUMIPSState *env, target_ulong arg1)
1723 {
1724     env->CP0_Framemask = arg1; /* XXX */
1725 }
1726
1727 void helper_mtc0_debug(CPUMIPSState *env, target_ulong arg1)
1728 {
1729     env->CP0_Debug = (env->CP0_Debug & 0x8C03FC1F) | (arg1 & 0x13300120);
1730     if (arg1 & (1 << CP0DB_DM))
1731         env->hflags |= MIPS_HFLAG_DM;
1732     else
1733         env->hflags &= ~MIPS_HFLAG_DM;
1734 }
1735
1736 void helper_mttc0_debug(CPUMIPSState *env, target_ulong arg1)
1737 {
1738     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1739     uint32_t val = arg1 & ((1 << CP0DB_SSt) | (1 << CP0DB_Halt));
1740     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1741
1742     /* XXX: Might be wrong, check with EJTAG spec. */
1743     if (other_tc == other->current_tc)
1744         other->active_tc.CP0_Debug_tcstatus = val;
1745     else
1746         other->tcs[other_tc].CP0_Debug_tcstatus = val;
1747     other->CP0_Debug = (other->CP0_Debug &
1748                      ((1 << CP0DB_SSt) | (1 << CP0DB_Halt))) |
1749                      (arg1 & ~((1 << CP0DB_SSt) | (1 << CP0DB_Halt)));
1750 }
1751
1752 void helper_mtc0_performance0(CPUMIPSState *env, target_ulong arg1)
1753 {
1754     env->CP0_Performance0 = arg1 & 0x000007ff;
1755 }
1756
1757 void helper_mtc0_taglo(CPUMIPSState *env, target_ulong arg1)
1758 {
1759     env->CP0_TagLo = arg1 & 0xFFFFFCF6;
1760 }
1761
1762 void helper_mtc0_datalo(CPUMIPSState *env, target_ulong arg1)
1763 {
1764     env->CP0_DataLo = arg1; /* XXX */
1765 }
1766
1767 void helper_mtc0_taghi(CPUMIPSState *env, target_ulong arg1)
1768 {
1769     env->CP0_TagHi = arg1; /* XXX */
1770 }
1771
1772 void helper_mtc0_datahi(CPUMIPSState *env, target_ulong arg1)
1773 {
1774     env->CP0_DataHi = arg1; /* XXX */
1775 }
1776
1777 /* MIPS MT functions */
1778 target_ulong helper_mftgpr(CPUMIPSState *env, uint32_t sel)
1779 {
1780     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1781     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1782
1783     if (other_tc == other->current_tc)
1784         return other->active_tc.gpr[sel];
1785     else
1786         return other->tcs[other_tc].gpr[sel];
1787 }
1788
1789 target_ulong helper_mftlo(CPUMIPSState *env, uint32_t sel)
1790 {
1791     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1792     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1793
1794     if (other_tc == other->current_tc)
1795         return other->active_tc.LO[sel];
1796     else
1797         return other->tcs[other_tc].LO[sel];
1798 }
1799
1800 target_ulong helper_mfthi(CPUMIPSState *env, uint32_t sel)
1801 {
1802     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1803     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1804
1805     if (other_tc == other->current_tc)
1806         return other->active_tc.HI[sel];
1807     else
1808         return other->tcs[other_tc].HI[sel];
1809 }
1810
1811 target_ulong helper_mftacx(CPUMIPSState *env, uint32_t sel)
1812 {
1813     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1814     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1815
1816     if (other_tc == other->current_tc)
1817         return other->active_tc.ACX[sel];
1818     else
1819         return other->tcs[other_tc].ACX[sel];
1820 }
1821
1822 target_ulong helper_mftdsp(CPUMIPSState *env)
1823 {
1824     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1825     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1826
1827     if (other_tc == other->current_tc)
1828         return other->active_tc.DSPControl;
1829     else
1830         return other->tcs[other_tc].DSPControl;
1831 }
1832
1833 void helper_mttgpr(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1834 {
1835     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1836     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1837
1838     if (other_tc == other->current_tc)
1839         other->active_tc.gpr[sel] = arg1;
1840     else
1841         other->tcs[other_tc].gpr[sel] = arg1;
1842 }
1843
1844 void helper_mttlo(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1845 {
1846     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1847     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1848
1849     if (other_tc == other->current_tc)
1850         other->active_tc.LO[sel] = arg1;
1851     else
1852         other->tcs[other_tc].LO[sel] = arg1;
1853 }
1854
1855 void helper_mtthi(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1856 {
1857     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1858     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1859
1860     if (other_tc == other->current_tc)
1861         other->active_tc.HI[sel] = arg1;
1862     else
1863         other->tcs[other_tc].HI[sel] = arg1;
1864 }
1865
1866 void helper_mttacx(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1867 {
1868     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1869     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1870
1871     if (other_tc == other->current_tc)
1872         other->active_tc.ACX[sel] = arg1;
1873     else
1874         other->tcs[other_tc].ACX[sel] = arg1;
1875 }
1876
1877 void helper_mttdsp(CPUMIPSState *env, target_ulong arg1)
1878 {
1879     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1880     CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1881
1882     if (other_tc == other->current_tc)
1883         other->active_tc.DSPControl = arg1;
1884     else
1885         other->tcs[other_tc].DSPControl = arg1;
1886 }
1887
1888 /* MIPS MT functions */
1889 target_ulong helper_dmt(void)
1890 {
1891     // TODO
1892      return 0;
1893 }
1894
1895 target_ulong helper_emt(void)
1896 {
1897     // TODO
1898     return 0;
1899 }
1900
1901 target_ulong helper_dvpe(CPUMIPSState *env)
1902 {
1903     CPUMIPSState *other_cpu_env = first_cpu;
1904     target_ulong prev = env->mvp->CP0_MVPControl;
1905
1906     do {
1907         /* Turn off all VPEs except the one executing the dvpe.  */
1908         if (other_cpu_env != env) {
1909             MIPSCPU *other_cpu = mips_env_get_cpu(other_cpu_env);
1910
1911             other_cpu_env->mvp->CP0_MVPControl &= ~(1 << CP0MVPCo_EVP);
1912             mips_vpe_sleep(other_cpu);
1913         }
1914         other_cpu_env = other_cpu_env->next_cpu;
1915     } while (other_cpu_env);
1916     return prev;
1917 }
1918
1919 target_ulong helper_evpe(CPUMIPSState *env)
1920 {
1921     CPUMIPSState *other_cpu_env = first_cpu;
1922     target_ulong prev = env->mvp->CP0_MVPControl;
1923
1924     do {
1925         MIPSCPU *other_cpu = mips_env_get_cpu(other_cpu_env);
1926
1927         if (other_cpu_env != env
1928             /* If the VPE is WFI, don't disturb its sleep.  */
1929             && !mips_vpe_is_wfi(other_cpu)) {
1930             /* Enable the VPE.  */
1931             other_cpu_env->mvp->CP0_MVPControl |= (1 << CP0MVPCo_EVP);
1932             mips_vpe_wake(other_cpu_env); /* And wake it up.  */
1933         }
1934         other_cpu_env = other_cpu_env->next_cpu;
1935     } while (other_cpu_env);
1936     return prev;
1937 }
1938 #endif /* !CONFIG_USER_ONLY */
1939
1940 void helper_fork(target_ulong arg1, target_ulong arg2)
1941 {
1942     // arg1 = rt, arg2 = rs
1943     arg1 = 0;
1944     // TODO: store to TC register
1945 }
1946
1947 target_ulong helper_yield(CPUMIPSState *env, target_ulong arg)
1948 {
1949     target_long arg1 = arg;
1950
1951     if (arg1 < 0) {
1952         /* No scheduling policy implemented. */
1953         if (arg1 != -2) {
1954             if (env->CP0_VPEControl & (1 << CP0VPECo_YSI) &&
1955                 env->active_tc.CP0_TCStatus & (1 << CP0TCSt_DT)) {
1956                 env->CP0_VPEControl &= ~(0x7 << CP0VPECo_EXCPT);
1957                 env->CP0_VPEControl |= 4 << CP0VPECo_EXCPT;
1958                 helper_raise_exception(env, EXCP_THREAD);
1959             }
1960         }
1961     } else if (arg1 == 0) {
1962         if (0 /* TODO: TC underflow */) {
1963             env->CP0_VPEControl &= ~(0x7 << CP0VPECo_EXCPT);
1964             helper_raise_exception(env, EXCP_THREAD);
1965         } else {
1966             // TODO: Deallocate TC
1967         }
1968     } else if (arg1 > 0) {
1969         /* Yield qualifier inputs not implemented. */
1970         env->CP0_VPEControl &= ~(0x7 << CP0VPECo_EXCPT);
1971         env->CP0_VPEControl |= 2 << CP0VPECo_EXCPT;
1972         helper_raise_exception(env, EXCP_THREAD);
1973     }
1974     return env->CP0_YQMask;
1975 }
1976
1977 #ifndef CONFIG_USER_ONLY
1978 /* TLB management */
1979 static void cpu_mips_tlb_flush (CPUMIPSState *env, int flush_global)
1980 {
1981     /* Flush qemu's TLB and discard all shadowed entries.  */
1982     tlb_flush (env, flush_global);
1983     env->tlb->tlb_in_use = env->tlb->nb_tlb;
1984 }
1985
1986 static void r4k_mips_tlb_flush_extra (CPUMIPSState *env, int first)
1987 {
1988     /* Discard entries from env->tlb[first] onwards.  */
1989     while (env->tlb->tlb_in_use > first) {
1990         r4k_invalidate_tlb(env, --env->tlb->tlb_in_use, 0);
1991     }
1992 }
1993
1994 static void r4k_fill_tlb(CPUMIPSState *env, int idx)
1995 {
1996     r4k_tlb_t *tlb;
1997
1998     /* XXX: detect conflicting TLBs and raise a MCHECK exception when needed */
1999     tlb = &env->tlb->mmu.r4k.tlb[idx];
2000     tlb->VPN = env->CP0_EntryHi & (TARGET_PAGE_MASK << 1);
2001 #if defined(TARGET_MIPS64)
2002     tlb->VPN &= env->SEGMask;
2003 #endif
2004     tlb->ASID = env->CP0_EntryHi & 0xFF;
2005     tlb->PageMask = env->CP0_PageMask;
2006     tlb->G = env->CP0_EntryLo0 & env->CP0_EntryLo1 & 1;
2007     tlb->V0 = (env->CP0_EntryLo0 & 2) != 0;
2008     tlb->D0 = (env->CP0_EntryLo0 & 4) != 0;
2009     tlb->C0 = (env->CP0_EntryLo0 >> 3) & 0x7;
2010     tlb->PFN[0] = (env->CP0_EntryLo0 >> 6) << 12;
2011     tlb->V1 = (env->CP0_EntryLo1 & 2) != 0;
2012     tlb->D1 = (env->CP0_EntryLo1 & 4) != 0;
2013     tlb->C1 = (env->CP0_EntryLo1 >> 3) & 0x7;
2014     tlb->PFN[1] = (env->CP0_EntryLo1 >> 6) << 12;
2015 }
2016
2017 void r4k_helper_tlbwi(CPUMIPSState *env)
2018 {
2019     int idx;
2020
2021     idx = (env->CP0_Index & ~0x80000000) % env->tlb->nb_tlb;
2022
2023     /* Discard cached TLB entries.  We could avoid doing this if the
2024        tlbwi is just upgrading access permissions on the current entry;
2025        that might be a further win.  */
2026     r4k_mips_tlb_flush_extra (env, env->tlb->nb_tlb);
2027
2028     r4k_invalidate_tlb(env, idx, 0);
2029     r4k_fill_tlb(env, idx);
2030 }
2031
2032 void r4k_helper_tlbwr(CPUMIPSState *env)
2033 {
2034     int r = cpu_mips_get_random(env);
2035
2036     r4k_invalidate_tlb(env, r, 1);
2037     r4k_fill_tlb(env, r);
2038 }
2039
2040 void r4k_helper_tlbp(CPUMIPSState *env)
2041 {
2042     r4k_tlb_t *tlb;
2043     target_ulong mask;
2044     target_ulong tag;
2045     target_ulong VPN;
2046     uint8_t ASID;
2047     int i;
2048
2049     ASID = env->CP0_EntryHi & 0xFF;
2050     for (i = 0; i < env->tlb->nb_tlb; i++) {
2051         tlb = &env->tlb->mmu.r4k.tlb[i];
2052         /* 1k pages are not supported. */
2053         mask = tlb->PageMask | ~(TARGET_PAGE_MASK << 1);
2054         tag = env->CP0_EntryHi & ~mask;
2055         VPN = tlb->VPN & ~mask;
2056         /* Check ASID, virtual page number & size */
2057         if ((tlb->G == 1 || tlb->ASID == ASID) && VPN == tag) {
2058             /* TLB match */
2059             env->CP0_Index = i;
2060             break;
2061         }
2062     }
2063     if (i == env->tlb->nb_tlb) {
2064         /* No match.  Discard any shadow entries, if any of them match.  */
2065         for (i = env->tlb->nb_tlb; i < env->tlb->tlb_in_use; i++) {
2066             tlb = &env->tlb->mmu.r4k.tlb[i];
2067             /* 1k pages are not supported. */
2068             mask = tlb->PageMask | ~(TARGET_PAGE_MASK << 1);
2069             tag = env->CP0_EntryHi & ~mask;
2070             VPN = tlb->VPN & ~mask;
2071             /* Check ASID, virtual page number & size */
2072             if ((tlb->G == 1 || tlb->ASID == ASID) && VPN == tag) {
2073                 r4k_mips_tlb_flush_extra (env, i);
2074                 break;
2075             }
2076         }
2077
2078         env->CP0_Index |= 0x80000000;
2079     }
2080 }
2081
2082 void r4k_helper_tlbr(CPUMIPSState *env)
2083 {
2084     r4k_tlb_t *tlb;
2085     uint8_t ASID;
2086     int idx;
2087
2088     ASID = env->CP0_EntryHi & 0xFF;
2089     idx = (env->CP0_Index & ~0x80000000) % env->tlb->nb_tlb;
2090     tlb = &env->tlb->mmu.r4k.tlb[idx];
2091
2092     /* If this will change the current ASID, flush qemu's TLB.  */
2093     if (ASID != tlb->ASID)
2094         cpu_mips_tlb_flush (env, 1);
2095
2096     r4k_mips_tlb_flush_extra(env, env->tlb->nb_tlb);
2097
2098     env->CP0_EntryHi = tlb->VPN | tlb->ASID;
2099     env->CP0_PageMask = tlb->PageMask;
2100     env->CP0_EntryLo0 = tlb->G | (tlb->V0 << 1) | (tlb->D0 << 2) |
2101                         (tlb->C0 << 3) | (tlb->PFN[0] >> 6);
2102     env->CP0_EntryLo1 = tlb->G | (tlb->V1 << 1) | (tlb->D1 << 2) |
2103                         (tlb->C1 << 3) | (tlb->PFN[1] >> 6);
2104 }
2105
2106 void helper_tlbwi(CPUMIPSState *env)
2107 {
2108     env->tlb->helper_tlbwi(env);
2109 }
2110
2111 void helper_tlbwr(CPUMIPSState *env)
2112 {
2113     env->tlb->helper_tlbwr(env);
2114 }
2115
2116 void helper_tlbp(CPUMIPSState *env)
2117 {
2118     env->tlb->helper_tlbp(env);
2119 }
2120
2121 void helper_tlbr(CPUMIPSState *env)
2122 {
2123     env->tlb->helper_tlbr(env);
2124 }
2125
2126 /* Specials */
2127 target_ulong helper_di(CPUMIPSState *env)
2128 {
2129     target_ulong t0 = env->CP0_Status;
2130
2131     env->CP0_Status = t0 & ~(1 << CP0St_IE);
2132     return t0;
2133 }
2134
2135 target_ulong helper_ei(CPUMIPSState *env)
2136 {
2137     target_ulong t0 = env->CP0_Status;
2138
2139     env->CP0_Status = t0 | (1 << CP0St_IE);
2140     return t0;
2141 }
2142
2143 static void debug_pre_eret(CPUMIPSState *env)
2144 {
2145     if (qemu_loglevel_mask(CPU_LOG_EXEC)) {
2146         qemu_log("ERET: PC " TARGET_FMT_lx " EPC " TARGET_FMT_lx,
2147                 env->active_tc.PC, env->CP0_EPC);
2148         if (env->CP0_Status & (1 << CP0St_ERL))
2149             qemu_log(" ErrorEPC " TARGET_FMT_lx, env->CP0_ErrorEPC);
2150         if (env->hflags & MIPS_HFLAG_DM)
2151             qemu_log(" DEPC " TARGET_FMT_lx, env->CP0_DEPC);
2152         qemu_log("\n");
2153     }
2154 }
2155
2156 static void debug_post_eret(CPUMIPSState *env)
2157 {
2158     if (qemu_loglevel_mask(CPU_LOG_EXEC)) {
2159         qemu_log("  =>  PC " TARGET_FMT_lx " EPC " TARGET_FMT_lx,
2160                 env->active_tc.PC, env->CP0_EPC);
2161         if (env->CP0_Status & (1 << CP0St_ERL))
2162             qemu_log(" ErrorEPC " TARGET_FMT_lx, env->CP0_ErrorEPC);
2163         if (env->hflags & MIPS_HFLAG_DM)
2164             qemu_log(" DEPC " TARGET_FMT_lx, env->CP0_DEPC);
2165         switch (env->hflags & MIPS_HFLAG_KSU) {
2166         case MIPS_HFLAG_UM: qemu_log(", UM\n"); break;
2167         case MIPS_HFLAG_SM: qemu_log(", SM\n"); break;
2168         case MIPS_HFLAG_KM: qemu_log("\n"); break;
2169         default: cpu_abort(env, "Invalid MMU mode!\n"); break;
2170         }
2171     }
2172 }
2173
2174 static void set_pc(CPUMIPSState *env, target_ulong error_pc)
2175 {
2176     env->active_tc.PC = error_pc & ~(target_ulong)1;
2177     if (error_pc & 1) {
2178         env->hflags |= MIPS_HFLAG_M16;
2179     } else {
2180         env->hflags &= ~(MIPS_HFLAG_M16);
2181     }
2182 }
2183
2184 void helper_eret(CPUMIPSState *env)
2185 {
2186     debug_pre_eret(env);
2187     if (env->CP0_Status & (1 << CP0St_ERL)) {
2188         set_pc(env, env->CP0_ErrorEPC);
2189         env->CP0_Status &= ~(1 << CP0St_ERL);
2190     } else {
2191         set_pc(env, env->CP0_EPC);
2192         env->CP0_Status &= ~(1 << CP0St_EXL);
2193     }
2194     compute_hflags(env);
2195     debug_post_eret(env);
2196     env->lladdr = 1;
2197 }
2198
2199 void helper_deret(CPUMIPSState *env)
2200 {
2201     debug_pre_eret(env);
2202     set_pc(env, env->CP0_DEPC);
2203
2204     env->hflags &= MIPS_HFLAG_DM;
2205     compute_hflags(env);
2206     debug_post_eret(env);
2207     env->lladdr = 1;
2208 }
2209 #endif /* !CONFIG_USER_ONLY */
2210
2211 target_ulong helper_rdhwr_cpunum(CPUMIPSState *env)
2212 {
2213     if ((env->hflags & MIPS_HFLAG_CP0) ||
2214         (env->CP0_HWREna & (1 << 0)))
2215         return env->CP0_EBase & 0x3ff;
2216     else
2217         helper_raise_exception(env, EXCP_RI);
2218
2219     return 0;
2220 }
2221
2222 target_ulong helper_rdhwr_synci_step(CPUMIPSState *env)
2223 {
2224     if ((env->hflags & MIPS_HFLAG_CP0) ||
2225         (env->CP0_HWREna & (1 << 1)))
2226         return env->SYNCI_Step;
2227     else
2228         helper_raise_exception(env, EXCP_RI);
2229
2230     return 0;
2231 }
2232
2233 target_ulong helper_rdhwr_cc(CPUMIPSState *env)
2234 {
2235     if ((env->hflags & MIPS_HFLAG_CP0) ||
2236         (env->CP0_HWREna & (1 << 2)))
2237         return env->CP0_Count;
2238     else
2239         helper_raise_exception(env, EXCP_RI);
2240
2241     return 0;
2242 }
2243
2244 target_ulong helper_rdhwr_ccres(CPUMIPSState *env)
2245 {
2246     if ((env->hflags & MIPS_HFLAG_CP0) ||
2247         (env->CP0_HWREna & (1 << 3)))
2248         return env->CCRes;
2249     else
2250         helper_raise_exception(env, EXCP_RI);
2251
2252     return 0;
2253 }
2254
2255 void helper_pmon(CPUMIPSState *env, int function)
2256 {
2257     function /= 2;
2258     switch (function) {
2259     case 2: /* TODO: char inbyte(int waitflag); */
2260         if (env->active_tc.gpr[4] == 0)
2261             env->active_tc.gpr[2] = -1;
2262         /* Fall through */
2263     case 11: /* TODO: char inbyte (void); */
2264         env->active_tc.gpr[2] = -1;
2265         break;
2266     case 3:
2267     case 12:
2268         printf("%c", (char)(env->active_tc.gpr[4] & 0xFF));
2269         break;
2270     case 17:
2271         break;
2272     case 158:
2273         {
2274             unsigned char *fmt = (void *)(uintptr_t)env->active_tc.gpr[4];
2275             printf("%s", fmt);
2276         }
2277         break;
2278     }
2279 }
2280
2281 void helper_wait(CPUMIPSState *env)
2282 {
2283     env->halted = 1;
2284     cpu_reset_interrupt(env, CPU_INTERRUPT_WAKE);
2285     helper_raise_exception(env, EXCP_HLT);
2286 }
2287
2288 #if !defined(CONFIG_USER_ONLY)
2289
2290 static void QEMU_NORETURN do_unaligned_access(CPUMIPSState *env,
2291                                               target_ulong addr, int is_write,
2292                                               int is_user, uintptr_t retaddr);
2293
2294 #define MMUSUFFIX _mmu
2295 #define ALIGNED_ONLY
2296
2297 #define SHIFT 0
2298 #include "softmmu_template.h"
2299
2300 #define SHIFT 1
2301 #include "softmmu_template.h"
2302
2303 #define SHIFT 2
2304 #include "softmmu_template.h"
2305
2306 #define SHIFT 3
2307 #include "softmmu_template.h"
2308
2309 static void do_unaligned_access(CPUMIPSState *env, target_ulong addr,
2310                                 int is_write, int is_user, uintptr_t retaddr)
2311 {
2312     env->CP0_BadVAddr = addr;
2313     do_raise_exception(env, (is_write == 1) ? EXCP_AdES : EXCP_AdEL, retaddr);
2314 }
2315
2316 void tlb_fill(CPUMIPSState *env, target_ulong addr, int is_write, int mmu_idx,
2317               uintptr_t retaddr)
2318 {
2319     int ret;
2320
2321     ret = cpu_mips_handle_mmu_fault(env, addr, is_write, mmu_idx);
2322     if (ret) {
2323         do_raise_exception_err(env, env->exception_index,
2324                                env->error_code, retaddr);
2325     }
2326 }
2327
2328 void cpu_unassigned_access(CPUMIPSState *env, hwaddr addr,
2329                            int is_write, int is_exec, int unused, int size)
2330 {
2331     if (is_exec)
2332         helper_raise_exception(env, EXCP_IBE);
2333     else
2334         helper_raise_exception(env, EXCP_DBE);
2335 }
2336 #endif /* !CONFIG_USER_ONLY */
2337
2338 /* Complex FPU operations which may need stack space. */
2339
2340 #define FLOAT_TWO32 make_float32(1 << 30)
2341 #define FLOAT_TWO64 make_float64(1ULL << 62)
2342 #define FP_TO_INT32_OVERFLOW 0x7fffffff
2343 #define FP_TO_INT64_OVERFLOW 0x7fffffffffffffffULL
2344
2345 /* convert MIPS rounding mode in FCR31 to IEEE library */
2346 static unsigned int ieee_rm[] = {
2347     float_round_nearest_even,
2348     float_round_to_zero,
2349     float_round_up,
2350     float_round_down
2351 };
2352
2353 #define RESTORE_ROUNDING_MODE \
2354     set_float_rounding_mode(ieee_rm[env->active_fpu.fcr31 & 3], &env->active_fpu.fp_status)
2355
2356 #define RESTORE_FLUSH_MODE \
2357     set_flush_to_zero((env->active_fpu.fcr31 & (1 << 24)) != 0, &env->active_fpu.fp_status);
2358
2359 target_ulong helper_cfc1(CPUMIPSState *env, uint32_t reg)
2360 {
2361     target_ulong arg1;
2362
2363     switch (reg) {
2364     case 0:
2365         arg1 = (int32_t)env->active_fpu.fcr0;
2366         break;
2367     case 25:
2368         arg1 = ((env->active_fpu.fcr31 >> 24) & 0xfe) | ((env->active_fpu.fcr31 >> 23) & 0x1);
2369         break;
2370     case 26:
2371         arg1 = env->active_fpu.fcr31 & 0x0003f07c;
2372         break;
2373     case 28:
2374         arg1 = (env->active_fpu.fcr31 & 0x00000f83) | ((env->active_fpu.fcr31 >> 22) & 0x4);
2375         break;
2376     default:
2377         arg1 = (int32_t)env->active_fpu.fcr31;
2378         break;
2379     }
2380
2381     return arg1;
2382 }
2383
2384 void helper_ctc1(CPUMIPSState *env, target_ulong arg1, uint32_t reg)
2385 {
2386     switch(reg) {
2387     case 25:
2388         if (arg1 & 0xffffff00)
2389             return;
2390         env->active_fpu.fcr31 = (env->active_fpu.fcr31 & 0x017fffff) | ((arg1 & 0xfe) << 24) |
2391                      ((arg1 & 0x1) << 23);
2392         break;
2393     case 26:
2394         if (arg1 & 0x007c0000)
2395             return;
2396         env->active_fpu.fcr31 = (env->active_fpu.fcr31 & 0xfffc0f83) | (arg1 & 0x0003f07c);
2397         break;
2398     case 28:
2399         if (arg1 & 0x007c0000)
2400             return;
2401         env->active_fpu.fcr31 = (env->active_fpu.fcr31 & 0xfefff07c) | (arg1 & 0x00000f83) |
2402                      ((arg1 & 0x4) << 22);
2403         break;
2404     case 31:
2405         if (arg1 & 0x007c0000)
2406             return;
2407         env->active_fpu.fcr31 = arg1;
2408         break;
2409     default:
2410         return;
2411     }
2412     /* set rounding mode */
2413     RESTORE_ROUNDING_MODE;
2414     /* set flush-to-zero mode */
2415     RESTORE_FLUSH_MODE;
2416     set_float_exception_flags(0, &env->active_fpu.fp_status);
2417     if ((GET_FP_ENABLE(env->active_fpu.fcr31) | 0x20) & GET_FP_CAUSE(env->active_fpu.fcr31))
2418         do_raise_exception(env, EXCP_FPE, GETPC());
2419 }
2420
2421 static inline int ieee_ex_to_mips(int xcpt)
2422 {
2423     int ret = 0;
2424     if (xcpt) {
2425         if (xcpt & float_flag_invalid) {
2426             ret |= FP_INVALID;
2427         }
2428         if (xcpt & float_flag_overflow) {
2429             ret |= FP_OVERFLOW;
2430         }
2431         if (xcpt & float_flag_underflow) {
2432             ret |= FP_UNDERFLOW;
2433         }
2434         if (xcpt & float_flag_divbyzero) {
2435             ret |= FP_DIV0;
2436         }
2437         if (xcpt & float_flag_inexact) {
2438             ret |= FP_INEXACT;
2439         }
2440     }
2441     return ret;
2442 }
2443
2444 static inline void update_fcr31(CPUMIPSState *env, uintptr_t pc)
2445 {
2446     int tmp = ieee_ex_to_mips(get_float_exception_flags(&env->active_fpu.fp_status));
2447
2448     SET_FP_CAUSE(env->active_fpu.fcr31, tmp);
2449
2450     if (tmp) {
2451         set_float_exception_flags(0, &env->active_fpu.fp_status);
2452
2453         if (GET_FP_ENABLE(env->active_fpu.fcr31) & tmp) {
2454             do_raise_exception(env, EXCP_FPE, pc);
2455         } else {
2456             UPDATE_FP_FLAGS(env->active_fpu.fcr31, tmp);
2457         }
2458     }
2459 }
2460
2461 /* Float support.
2462    Single precition routines have a "s" suffix, double precision a
2463    "d" suffix, 32bit integer "w", 64bit integer "l", paired single "ps",
2464    paired single lower "pl", paired single upper "pu".  */
2465
2466 /* unary operations, modifying fp status  */
2467 uint64_t helper_float_sqrt_d(CPUMIPSState *env, uint64_t fdt0)
2468 {
2469     fdt0 = float64_sqrt(fdt0, &env->active_fpu.fp_status);
2470     update_fcr31(env, GETPC());
2471     return fdt0;
2472 }
2473
2474 uint32_t helper_float_sqrt_s(CPUMIPSState *env, uint32_t fst0)
2475 {
2476     fst0 = float32_sqrt(fst0, &env->active_fpu.fp_status);
2477     update_fcr31(env, GETPC());
2478     return fst0;
2479 }
2480
2481 uint64_t helper_float_cvtd_s(CPUMIPSState *env, uint32_t fst0)
2482 {
2483     uint64_t fdt2;
2484
2485     fdt2 = float32_to_float64(fst0, &env->active_fpu.fp_status);
2486     update_fcr31(env, GETPC());
2487     return fdt2;
2488 }
2489
2490 uint64_t helper_float_cvtd_w(CPUMIPSState *env, uint32_t wt0)
2491 {
2492     uint64_t fdt2;
2493
2494     fdt2 = int32_to_float64(wt0, &env->active_fpu.fp_status);
2495     update_fcr31(env, GETPC());
2496     return fdt2;
2497 }
2498
2499 uint64_t helper_float_cvtd_l(CPUMIPSState *env, uint64_t dt0)
2500 {
2501     uint64_t fdt2;
2502
2503     fdt2 = int64_to_float64(dt0, &env->active_fpu.fp_status);
2504     update_fcr31(env, GETPC());
2505     return fdt2;
2506 }
2507
2508 uint64_t helper_float_cvtl_d(CPUMIPSState *env, uint64_t fdt0)
2509 {
2510     uint64_t dt2;
2511
2512     dt2 = float64_to_int64(fdt0, &env->active_fpu.fp_status);
2513     if (get_float_exception_flags(&env->active_fpu.fp_status)
2514         & (float_flag_invalid | float_flag_overflow)) {
2515         dt2 = FP_TO_INT64_OVERFLOW;
2516     }
2517     update_fcr31(env, GETPC());
2518     return dt2;
2519 }
2520
2521 uint64_t helper_float_cvtl_s(CPUMIPSState *env, uint32_t fst0)
2522 {
2523     uint64_t dt2;
2524
2525     dt2 = float32_to_int64(fst0, &env->active_fpu.fp_status);
2526     if (get_float_exception_flags(&env->active_fpu.fp_status)
2527         & (float_flag_invalid | float_flag_overflow)) {
2528         dt2 = FP_TO_INT64_OVERFLOW;
2529     }
2530     update_fcr31(env, GETPC());
2531     return dt2;
2532 }
2533
2534 uint64_t helper_float_cvtps_pw(CPUMIPSState *env, uint64_t dt0)
2535 {
2536     uint32_t fst2;
2537     uint32_t fsth2;
2538
2539     fst2 = int32_to_float32(dt0 & 0XFFFFFFFF, &env->active_fpu.fp_status);
2540     fsth2 = int32_to_float32(dt0 >> 32, &env->active_fpu.fp_status);
2541     update_fcr31(env, GETPC());
2542     return ((uint64_t)fsth2 << 32) | fst2;
2543 }
2544
2545 uint64_t helper_float_cvtpw_ps(CPUMIPSState *env, uint64_t fdt0)
2546 {
2547     uint32_t wt2;
2548     uint32_t wth2;
2549     int excp, excph;
2550
2551     wt2 = float32_to_int32(fdt0 & 0XFFFFFFFF, &env->active_fpu.fp_status);
2552     excp = get_float_exception_flags(&env->active_fpu.fp_status);
2553     if (excp & (float_flag_overflow | float_flag_invalid)) {
2554         wt2 = FP_TO_INT32_OVERFLOW;
2555     }
2556
2557     set_float_exception_flags(0, &env->active_fpu.fp_status);
2558     wth2 = float32_to_int32(fdt0 >> 32, &env->active_fpu.fp_status);
2559     excph = get_float_exception_flags(&env->active_fpu.fp_status);
2560     if (excph & (float_flag_overflow | float_flag_invalid)) {
2561         wth2 = FP_TO_INT32_OVERFLOW;
2562     }
2563
2564     set_float_exception_flags(excp | excph, &env->active_fpu.fp_status);
2565     update_fcr31(env, GETPC());
2566
2567     return ((uint64_t)wth2 << 32) | wt2;
2568 }
2569
2570 uint32_t helper_float_cvts_d(CPUMIPSState *env, uint64_t fdt0)
2571 {
2572     uint32_t fst2;
2573
2574     fst2 = float64_to_float32(fdt0, &env->active_fpu.fp_status);
2575     update_fcr31(env, GETPC());
2576     return fst2;
2577 }
2578
2579 uint32_t helper_float_cvts_w(CPUMIPSState *env, uint32_t wt0)
2580 {
2581     uint32_t fst2;
2582
2583     fst2 = int32_to_float32(wt0, &env->active_fpu.fp_status);
2584     update_fcr31(env, GETPC());
2585     return fst2;
2586 }
2587
2588 uint32_t helper_float_cvts_l(CPUMIPSState *env, uint64_t dt0)
2589 {
2590     uint32_t fst2;
2591
2592     fst2 = int64_to_float32(dt0, &env->active_fpu.fp_status);
2593     update_fcr31(env, GETPC());
2594     return fst2;
2595 }
2596
2597 uint32_t helper_float_cvts_pl(CPUMIPSState *env, uint32_t wt0)
2598 {
2599     uint32_t wt2;
2600
2601     wt2 = wt0;
2602     update_fcr31(env, GETPC());
2603     return wt2;
2604 }
2605
2606 uint32_t helper_float_cvts_pu(CPUMIPSState *env, uint32_t wth0)
2607 {
2608     uint32_t wt2;
2609
2610     wt2 = wth0;
2611     update_fcr31(env, GETPC());
2612     return wt2;
2613 }
2614
2615 uint32_t helper_float_cvtw_s(CPUMIPSState *env, uint32_t fst0)
2616 {
2617     uint32_t wt2;
2618
2619     wt2 = float32_to_int32(fst0, &env->active_fpu.fp_status);
2620     update_fcr31(env, GETPC());
2621     if (get_float_exception_flags(&env->active_fpu.fp_status)
2622         & (float_flag_invalid | float_flag_overflow)) {
2623         wt2 = FP_TO_INT32_OVERFLOW;
2624     }
2625     return wt2;
2626 }
2627
2628 uint32_t helper_float_cvtw_d(CPUMIPSState *env, uint64_t fdt0)
2629 {
2630     uint32_t wt2;
2631
2632     wt2 = float64_to_int32(fdt0, &env->active_fpu.fp_status);
2633     if (get_float_exception_flags(&env->active_fpu.fp_status)
2634         & (float_flag_invalid | float_flag_overflow)) {
2635         wt2 = FP_TO_INT32_OVERFLOW;
2636     }
2637     update_fcr31(env, GETPC());
2638     return wt2;
2639 }
2640
2641 uint64_t helper_float_roundl_d(CPUMIPSState *env, uint64_t fdt0)
2642 {
2643     uint64_t dt2;
2644
2645     set_float_rounding_mode(float_round_nearest_even, &env->active_fpu.fp_status);
2646     dt2 = float64_to_int64(fdt0, &env->active_fpu.fp_status);
2647     RESTORE_ROUNDING_MODE;
2648     if (get_float_exception_flags(&env->active_fpu.fp_status)
2649         & (float_flag_invalid | float_flag_overflow)) {
2650         dt2 = FP_TO_INT64_OVERFLOW;
2651     }
2652     update_fcr31(env, GETPC());
2653     return dt2;
2654 }
2655
2656 uint64_t helper_float_roundl_s(CPUMIPSState *env, uint32_t fst0)
2657 {
2658     uint64_t dt2;
2659
2660     set_float_rounding_mode(float_round_nearest_even, &env->active_fpu.fp_status);
2661     dt2 = float32_to_int64(fst0, &env->active_fpu.fp_status);
2662     RESTORE_ROUNDING_MODE;
2663     if (get_float_exception_flags(&env->active_fpu.fp_status)
2664         & (float_flag_invalid | float_flag_overflow)) {
2665         dt2 = FP_TO_INT64_OVERFLOW;
2666     }
2667     update_fcr31(env, GETPC());
2668     return dt2;
2669 }
2670
2671 uint32_t helper_float_roundw_d(CPUMIPSState *env, uint64_t fdt0)
2672 {
2673     uint32_t wt2;
2674
2675     set_float_rounding_mode(float_round_nearest_even, &env->active_fpu.fp_status);
2676     wt2 = float64_to_int32(fdt0, &env->active_fpu.fp_status);
2677     RESTORE_ROUNDING_MODE;
2678     if (get_float_exception_flags(&env->active_fpu.fp_status)
2679         & (float_flag_invalid | float_flag_overflow)) {
2680         wt2 = FP_TO_INT32_OVERFLOW;
2681     }
2682     update_fcr31(env, GETPC());
2683     return wt2;
2684 }
2685
2686 uint32_t helper_float_roundw_s(CPUMIPSState *env, uint32_t fst0)
2687 {
2688     uint32_t wt2;
2689
2690     set_float_rounding_mode(float_round_nearest_even, &env->active_fpu.fp_status);
2691     wt2 = float32_to_int32(fst0, &env->active_fpu.fp_status);
2692     RESTORE_ROUNDING_MODE;
2693     if (get_float_exception_flags(&env->active_fpu.fp_status)
2694         & (float_flag_invalid | float_flag_overflow)) {
2695         wt2 = FP_TO_INT32_OVERFLOW;
2696     }
2697     update_fcr31(env, GETPC());
2698     return wt2;
2699 }
2700
2701 uint64_t helper_float_truncl_d(CPUMIPSState *env, uint64_t fdt0)
2702 {
2703     uint64_t dt2;
2704
2705     dt2 = float64_to_int64_round_to_zero(fdt0, &env->active_fpu.fp_status);
2706     if (get_float_exception_flags(&env->active_fpu.fp_status)
2707         & (float_flag_invalid | float_flag_overflow)) {
2708         dt2 = FP_TO_INT64_OVERFLOW;
2709     }
2710     update_fcr31(env, GETPC());
2711     return dt2;
2712 }
2713
2714 uint64_t helper_float_truncl_s(CPUMIPSState *env, uint32_t fst0)
2715 {
2716     uint64_t dt2;
2717
2718     dt2 = float32_to_int64_round_to_zero(fst0, &env->active_fpu.fp_status);
2719     if (get_float_exception_flags(&env->active_fpu.fp_status)
2720         & (float_flag_invalid | float_flag_overflow)) {
2721         dt2 = FP_TO_INT64_OVERFLOW;
2722     }
2723     update_fcr31(env, GETPC());
2724     return dt2;
2725 }
2726
2727 uint32_t helper_float_truncw_d(CPUMIPSState *env, uint64_t fdt0)
2728 {
2729     uint32_t wt2;
2730
2731     wt2 = float64_to_int32_round_to_zero(fdt0, &env->active_fpu.fp_status);
2732     if (get_float_exception_flags(&env->active_fpu.fp_status)
2733         & (float_flag_invalid | float_flag_overflow)) {
2734         wt2 = FP_TO_INT32_OVERFLOW;
2735     }
2736     update_fcr31(env, GETPC());
2737     return wt2;
2738 }
2739
2740 uint32_t helper_float_truncw_s(CPUMIPSState *env, uint32_t fst0)
2741 {
2742     uint32_t wt2;
2743
2744     wt2 = float32_to_int32_round_to_zero(fst0, &env->active_fpu.fp_status);
2745     if (get_float_exception_flags(&env->active_fpu.fp_status)
2746         & (float_flag_invalid | float_flag_overflow)) {
2747         wt2 = FP_TO_INT32_OVERFLOW;
2748     }
2749     update_fcr31(env, GETPC());
2750     return wt2;
2751 }
2752
2753 uint64_t helper_float_ceill_d(CPUMIPSState *env, uint64_t fdt0)
2754 {
2755     uint64_t dt2;
2756
2757     set_float_rounding_mode(float_round_up, &env->active_fpu.fp_status);
2758     dt2 = float64_to_int64(fdt0, &env->active_fpu.fp_status);
2759     RESTORE_ROUNDING_MODE;
2760     if (get_float_exception_flags(&env->active_fpu.fp_status)
2761         & (float_flag_invalid | float_flag_overflow)) {
2762         dt2 = FP_TO_INT64_OVERFLOW;
2763     }
2764     update_fcr31(env, GETPC());
2765     return dt2;
2766 }
2767
2768 uint64_t helper_float_ceill_s(CPUMIPSState *env, uint32_t fst0)
2769 {
2770     uint64_t dt2;
2771
2772     set_float_rounding_mode(float_round_up, &env->active_fpu.fp_status);
2773     dt2 = float32_to_int64(fst0, &env->active_fpu.fp_status);
2774     RESTORE_ROUNDING_MODE;
2775     if (get_float_exception_flags(&env->active_fpu.fp_status)
2776         & (float_flag_invalid | float_flag_overflow)) {
2777         dt2 = FP_TO_INT64_OVERFLOW;
2778     }
2779     update_fcr31(env, GETPC());
2780     return dt2;
2781 }
2782
2783 uint32_t helper_float_ceilw_d(CPUMIPSState *env, uint64_t fdt0)
2784 {
2785     uint32_t wt2;
2786
2787     set_float_rounding_mode(float_round_up, &env->active_fpu.fp_status);
2788     wt2 = float64_to_int32(fdt0, &env->active_fpu.fp_status);
2789     RESTORE_ROUNDING_MODE;
2790     if (get_float_exception_flags(&env->active_fpu.fp_status)
2791         & (float_flag_invalid | float_flag_overflow)) {
2792         wt2 = FP_TO_INT32_OVERFLOW;
2793     }
2794     update_fcr31(env, GETPC());
2795     return wt2;
2796 }
2797
2798 uint32_t helper_float_ceilw_s(CPUMIPSState *env, uint32_t fst0)
2799 {
2800     uint32_t wt2;
2801
2802     set_float_rounding_mode(float_round_up, &env->active_fpu.fp_status);
2803     wt2 = float32_to_int32(fst0, &env->active_fpu.fp_status);
2804     RESTORE_ROUNDING_MODE;
2805     if (get_float_exception_flags(&env->active_fpu.fp_status)
2806         & (float_flag_invalid | float_flag_overflow)) {
2807         wt2 = FP_TO_INT32_OVERFLOW;
2808     }
2809     update_fcr31(env, GETPC());
2810     return wt2;
2811 }
2812
2813 uint64_t helper_float_floorl_d(CPUMIPSState *env, uint64_t fdt0)
2814 {
2815     uint64_t dt2;
2816
2817     set_float_rounding_mode(float_round_down, &env->active_fpu.fp_status);
2818     dt2 = float64_to_int64(fdt0, &env->active_fpu.fp_status);
2819     RESTORE_ROUNDING_MODE;
2820     if (get_float_exception_flags(&env->active_fpu.fp_status)
2821         & (float_flag_invalid | float_flag_overflow)) {
2822         dt2 = FP_TO_INT64_OVERFLOW;
2823     }
2824     update_fcr31(env, GETPC());
2825     return dt2;
2826 }
2827
2828 uint64_t helper_float_floorl_s(CPUMIPSState *env, uint32_t fst0)
2829 {
2830     uint64_t dt2;
2831
2832     set_float_rounding_mode(float_round_down, &env->active_fpu.fp_status);
2833     dt2 = float32_to_int64(fst0, &env->active_fpu.fp_status);
2834     RESTORE_ROUNDING_MODE;
2835     if (get_float_exception_flags(&env->active_fpu.fp_status)
2836         & (float_flag_invalid | float_flag_overflow)) {
2837         dt2 = FP_TO_INT64_OVERFLOW;
2838     }
2839     update_fcr31(env, GETPC());
2840     return dt2;
2841 }
2842
2843 uint32_t helper_float_floorw_d(CPUMIPSState *env, uint64_t fdt0)
2844 {
2845     uint32_t wt2;
2846
2847     set_float_rounding_mode(float_round_down, &env->active_fpu.fp_status);
2848     wt2 = float64_to_int32(fdt0, &env->active_fpu.fp_status);
2849     RESTORE_ROUNDING_MODE;
2850     if (get_float_exception_flags(&env->active_fpu.fp_status)
2851         & (float_flag_invalid | float_flag_overflow)) {
2852         wt2 = FP_TO_INT32_OVERFLOW;
2853     }
2854     update_fcr31(env, GETPC());
2855     return wt2;
2856 }
2857
2858 uint32_t helper_float_floorw_s(CPUMIPSState *env, uint32_t fst0)
2859 {
2860     uint32_t wt2;
2861
2862     set_float_rounding_mode(float_round_down, &env->active_fpu.fp_status);
2863     wt2 = float32_to_int32(fst0, &env->active_fpu.fp_status);
2864     RESTORE_ROUNDING_MODE;
2865     if (get_float_exception_flags(&env->active_fpu.fp_status)
2866         & (float_flag_invalid | float_flag_overflow)) {
2867         wt2 = FP_TO_INT32_OVERFLOW;
2868     }
2869     update_fcr31(env, GETPC());
2870     return wt2;
2871 }
2872
2873 /* unary operations, not modifying fp status  */
2874 #define FLOAT_UNOP(name)                                       \
2875 uint64_t helper_float_ ## name ## _d(uint64_t fdt0)                \
2876 {                                                              \
2877     return float64_ ## name(fdt0);                             \
2878 }                                                              \
2879 uint32_t helper_float_ ## name ## _s(uint32_t fst0)                \
2880 {                                                              \
2881     return float32_ ## name(fst0);                             \
2882 }                                                              \
2883 uint64_t helper_float_ ## name ## _ps(uint64_t fdt0)               \
2884 {                                                              \
2885     uint32_t wt0;                                              \
2886     uint32_t wth0;                                             \
2887                                                                \
2888     wt0 = float32_ ## name(fdt0 & 0XFFFFFFFF);                 \
2889     wth0 = float32_ ## name(fdt0 >> 32);                       \
2890     return ((uint64_t)wth0 << 32) | wt0;                       \
2891 }
2892 FLOAT_UNOP(abs)
2893 FLOAT_UNOP(chs)
2894 #undef FLOAT_UNOP
2895
2896 /* MIPS specific unary operations */
2897 uint64_t helper_float_recip_d(CPUMIPSState *env, uint64_t fdt0)
2898 {
2899     uint64_t fdt2;
2900
2901     fdt2 = float64_div(float64_one, fdt0, &env->active_fpu.fp_status);
2902     update_fcr31(env, GETPC());
2903     return fdt2;
2904 }
2905
2906 uint32_t helper_float_recip_s(CPUMIPSState *env, uint32_t fst0)
2907 {
2908     uint32_t fst2;
2909
2910     fst2 = float32_div(float32_one, fst0, &env->active_fpu.fp_status);
2911     update_fcr31(env, GETPC());
2912     return fst2;
2913 }
2914
2915 uint64_t helper_float_rsqrt_d(CPUMIPSState *env, uint64_t fdt0)
2916 {
2917     uint64_t fdt2;
2918
2919     fdt2 = float64_sqrt(fdt0, &env->active_fpu.fp_status);
2920     fdt2 = float64_div(float64_one, fdt2, &env->active_fpu.fp_status);
2921     update_fcr31(env, GETPC());
2922     return fdt2;
2923 }
2924
2925 uint32_t helper_float_rsqrt_s(CPUMIPSState *env, uint32_t fst0)
2926 {
2927     uint32_t fst2;
2928
2929     fst2 = float32_sqrt(fst0, &env->active_fpu.fp_status);
2930     fst2 = float32_div(float32_one, fst2, &env->active_fpu.fp_status);
2931     update_fcr31(env, GETPC());
2932     return fst2;
2933 }
2934
2935 uint64_t helper_float_recip1_d(CPUMIPSState *env, uint64_t fdt0)
2936 {
2937     uint64_t fdt2;
2938
2939     fdt2 = float64_div(float64_one, fdt0, &env->active_fpu.fp_status);
2940     update_fcr31(env, GETPC());
2941     return fdt2;
2942 }
2943
2944 uint32_t helper_float_recip1_s(CPUMIPSState *env, uint32_t fst0)
2945 {
2946     uint32_t fst2;
2947
2948     fst2 = float32_div(float32_one, fst0, &env->active_fpu.fp_status);
2949     update_fcr31(env, GETPC());
2950     return fst2;
2951 }
2952
2953 uint64_t helper_float_recip1_ps(CPUMIPSState *env, uint64_t fdt0)
2954 {
2955     uint32_t fst2;
2956     uint32_t fsth2;
2957
2958     fst2 = float32_div(float32_one, fdt0 & 0XFFFFFFFF, &env->active_fpu.fp_status);
2959     fsth2 = float32_div(float32_one, fdt0 >> 32, &env->active_fpu.fp_status);
2960     update_fcr31(env, GETPC());
2961     return ((uint64_t)fsth2 << 32) | fst2;
2962 }
2963
2964 uint64_t helper_float_rsqrt1_d(CPUMIPSState *env, uint64_t fdt0)
2965 {
2966     uint64_t fdt2;
2967
2968     fdt2 = float64_sqrt(fdt0, &env->active_fpu.fp_status);
2969     fdt2 = float64_div(float64_one, fdt2, &env->active_fpu.fp_status);
2970     update_fcr31(env, GETPC());
2971     return fdt2;
2972 }
2973
2974 uint32_t helper_float_rsqrt1_s(CPUMIPSState *env, uint32_t fst0)
2975 {
2976     uint32_t fst2;
2977
2978     fst2 = float32_sqrt(fst0, &env->active_fpu.fp_status);
2979     fst2 = float32_div(float32_one, fst2, &env->active_fpu.fp_status);
2980     update_fcr31(env, GETPC());
2981     return fst2;
2982 }
2983
2984 uint64_t helper_float_rsqrt1_ps(CPUMIPSState *env, uint64_t fdt0)
2985 {
2986     uint32_t fst2;
2987     uint32_t fsth2;
2988
2989     fst2 = float32_sqrt(fdt0 & 0XFFFFFFFF, &env->active_fpu.fp_status);
2990     fsth2 = float32_sqrt(fdt0 >> 32, &env->active_fpu.fp_status);
2991     fst2 = float32_div(float32_one, fst2, &env->active_fpu.fp_status);
2992     fsth2 = float32_div(float32_one, fsth2, &env->active_fpu.fp_status);
2993     update_fcr31(env, GETPC());
2994     return ((uint64_t)fsth2 << 32) | fst2;
2995 }
2996
2997 #define FLOAT_OP(name, p) void helper_float_##name##_##p(CPUMIPSState *env)
2998
2999 /* binary operations */
3000 #define FLOAT_BINOP(name)                                          \
3001 uint64_t helper_float_ ## name ## _d(CPUMIPSState *env,            \
3002                                      uint64_t fdt0, uint64_t fdt1) \
3003 {                                                                  \
3004     uint64_t dt2;                                                  \
3005                                                                    \
3006     dt2 = float64_ ## name (fdt0, fdt1, &env->active_fpu.fp_status);     \
3007     update_fcr31(env, GETPC());                                    \
3008     return dt2;                                                    \
3009 }                                                                  \
3010                                                                    \
3011 uint32_t helper_float_ ## name ## _s(CPUMIPSState *env,            \
3012                                      uint32_t fst0, uint32_t fst1) \
3013 {                                                                  \
3014     uint32_t wt2;                                                  \
3015                                                                    \
3016     wt2 = float32_ ## name (fst0, fst1, &env->active_fpu.fp_status);     \
3017     update_fcr31(env, GETPC());                                    \
3018     return wt2;                                                    \
3019 }                                                                  \
3020                                                                    \
3021 uint64_t helper_float_ ## name ## _ps(CPUMIPSState *env,           \
3022                                       uint64_t fdt0,               \
3023                                       uint64_t fdt1)               \
3024 {                                                                  \
3025     uint32_t fst0 = fdt0 & 0XFFFFFFFF;                             \
3026     uint32_t fsth0 = fdt0 >> 32;                                   \
3027     uint32_t fst1 = fdt1 & 0XFFFFFFFF;                             \
3028     uint32_t fsth1 = fdt1 >> 32;                                   \
3029     uint32_t wt2;                                                  \
3030     uint32_t wth2;                                                 \
3031                                                                    \
3032     wt2 = float32_ ## name (fst0, fst1, &env->active_fpu.fp_status);     \
3033     wth2 = float32_ ## name (fsth0, fsth1, &env->active_fpu.fp_status);  \
3034     update_fcr31(env, GETPC());                                    \
3035     return ((uint64_t)wth2 << 32) | wt2;                           \
3036 }
3037
3038 FLOAT_BINOP(add)
3039 FLOAT_BINOP(sub)
3040 FLOAT_BINOP(mul)
3041 FLOAT_BINOP(div)
3042 #undef FLOAT_BINOP
3043
3044 /* FMA based operations */
3045 #define FLOAT_FMA(name, type)                                        \
3046 uint64_t helper_float_ ## name ## _d(CPUMIPSState *env,              \
3047                                      uint64_t fdt0, uint64_t fdt1,   \
3048                                      uint64_t fdt2)                  \
3049 {                                                                    \
3050     fdt0 = float64_muladd(fdt0, fdt1, fdt2, type,                    \
3051                          &env->active_fpu.fp_status);                \
3052     update_fcr31(env, GETPC());                                      \
3053     return fdt0;                                                     \
3054 }                                                                    \
3055                                                                      \
3056 uint32_t helper_float_ ## name ## _s(CPUMIPSState *env,              \
3057                                      uint32_t fst0, uint32_t fst1,   \
3058                                      uint32_t fst2)                  \
3059 {                                                                    \
3060     fst0 = float32_muladd(fst0, fst1, fst2, type,                    \
3061                          &env->active_fpu.fp_status);                \
3062     update_fcr31(env, GETPC());                                      \
3063     return fst0;                                                     \
3064 }                                                                    \
3065                                                                      \
3066 uint64_t helper_float_ ## name ## _ps(CPUMIPSState *env,             \
3067                                       uint64_t fdt0, uint64_t fdt1,  \
3068                                       uint64_t fdt2)                 \
3069 {                                                                    \
3070     uint32_t fst0 = fdt0 & 0XFFFFFFFF;                               \
3071     uint32_t fsth0 = fdt0 >> 32;                                     \
3072     uint32_t fst1 = fdt1 & 0XFFFFFFFF;                               \
3073     uint32_t fsth1 = fdt1 >> 32;                                     \
3074     uint32_t fst2 = fdt2 & 0XFFFFFFFF;                               \
3075     uint32_t fsth2 = fdt2 >> 32;                                     \
3076                                                                      \
3077     fst0 = float32_muladd(fst0, fst1, fst2, type,                    \
3078                           &env->active_fpu.fp_status);               \
3079     fsth0 = float32_muladd(fsth0, fsth1, fsth2, type,                \
3080                            &env->active_fpu.fp_status);              \
3081     update_fcr31(env, GETPC());                                      \
3082     return ((uint64_t)fsth0 << 32) | fst0;                           \
3083 }
3084 FLOAT_FMA(madd, 0)
3085 FLOAT_FMA(msub, float_muladd_negate_c)
3086 FLOAT_FMA(nmadd, float_muladd_negate_result)
3087 FLOAT_FMA(nmsub, float_muladd_negate_result | float_muladd_negate_c)
3088 #undef FLOAT_FMA
3089
3090 /* MIPS specific binary operations */
3091 uint64_t helper_float_recip2_d(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt2)
3092 {
3093     fdt2 = float64_mul(fdt0, fdt2, &env->active_fpu.fp_status);
3094     fdt2 = float64_chs(float64_sub(fdt2, float64_one, &env->active_fpu.fp_status));
3095     update_fcr31(env, GETPC());
3096     return fdt2;
3097 }
3098
3099 uint32_t helper_float_recip2_s(CPUMIPSState *env, uint32_t fst0, uint32_t fst2)
3100 {
3101     fst2 = float32_mul(fst0, fst2, &env->active_fpu.fp_status);
3102     fst2 = float32_chs(float32_sub(fst2, float32_one, &env->active_fpu.fp_status));
3103     update_fcr31(env, GETPC());
3104     return fst2;
3105 }
3106
3107 uint64_t helper_float_recip2_ps(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt2)
3108 {
3109     uint32_t fst0 = fdt0 & 0XFFFFFFFF;
3110     uint32_t fsth0 = fdt0 >> 32;
3111     uint32_t fst2 = fdt2 & 0XFFFFFFFF;
3112     uint32_t fsth2 = fdt2 >> 32;
3113
3114     fst2 = float32_mul(fst0, fst2, &env->active_fpu.fp_status);
3115     fsth2 = float32_mul(fsth0, fsth2, &env->active_fpu.fp_status);
3116     fst2 = float32_chs(float32_sub(fst2, float32_one, &env->active_fpu.fp_status));
3117     fsth2 = float32_chs(float32_sub(fsth2, float32_one, &env->active_fpu.fp_status));
3118     update_fcr31(env, GETPC());
3119     return ((uint64_t)fsth2 << 32) | fst2;
3120 }
3121
3122 uint64_t helper_float_rsqrt2_d(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt2)
3123 {
3124     fdt2 = float64_mul(fdt0, fdt2, &env->active_fpu.fp_status);
3125     fdt2 = float64_sub(fdt2, float64_one, &env->active_fpu.fp_status);
3126     fdt2 = float64_chs(float64_div(fdt2, FLOAT_TWO64, &env->active_fpu.fp_status));
3127     update_fcr31(env, GETPC());
3128     return fdt2;
3129 }
3130
3131 uint32_t helper_float_rsqrt2_s(CPUMIPSState *env, uint32_t fst0, uint32_t fst2)
3132 {
3133     fst2 = float32_mul(fst0, fst2, &env->active_fpu.fp_status);
3134     fst2 = float32_sub(fst2, float32_one, &env->active_fpu.fp_status);
3135     fst2 = float32_chs(float32_div(fst2, FLOAT_TWO32, &env->active_fpu.fp_status));
3136     update_fcr31(env, GETPC());
3137     return fst2;
3138 }
3139
3140 uint64_t helper_float_rsqrt2_ps(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt2)
3141 {
3142     uint32_t fst0 = fdt0 & 0XFFFFFFFF;
3143     uint32_t fsth0 = fdt0 >> 32;
3144     uint32_t fst2 = fdt2 & 0XFFFFFFFF;
3145     uint32_t fsth2 = fdt2 >> 32;
3146
3147     fst2 = float32_mul(fst0, fst2, &env->active_fpu.fp_status);
3148     fsth2 = float32_mul(fsth0, fsth2, &env->active_fpu.fp_status);
3149     fst2 = float32_sub(fst2, float32_one, &env->active_fpu.fp_status);
3150     fsth2 = float32_sub(fsth2, float32_one, &env->active_fpu.fp_status);
3151     fst2 = float32_chs(float32_div(fst2, FLOAT_TWO32, &env->active_fpu.fp_status));
3152     fsth2 = float32_chs(float32_div(fsth2, FLOAT_TWO32, &env->active_fpu.fp_status));
3153     update_fcr31(env, GETPC());
3154     return ((uint64_t)fsth2 << 32) | fst2;
3155 }
3156
3157 uint64_t helper_float_addr_ps(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt1)
3158 {
3159     uint32_t fst0 = fdt0 & 0XFFFFFFFF;
3160     uint32_t fsth0 = fdt0 >> 32;
3161     uint32_t fst1 = fdt1 & 0XFFFFFFFF;
3162     uint32_t fsth1 = fdt1 >> 32;
3163     uint32_t fst2;
3164     uint32_t fsth2;
3165
3166     fst2 = float32_add (fst0, fsth0, &env->active_fpu.fp_status);
3167     fsth2 = float32_add (fst1, fsth1, &env->active_fpu.fp_status);
3168     update_fcr31(env, GETPC());
3169     return ((uint64_t)fsth2 << 32) | fst2;
3170 }
3171
3172 uint64_t helper_float_mulr_ps(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt1)
3173 {
3174     uint32_t fst0 = fdt0 & 0XFFFFFFFF;
3175     uint32_t fsth0 = fdt0 >> 32;
3176     uint32_t fst1 = fdt1 & 0XFFFFFFFF;
3177     uint32_t fsth1 = fdt1 >> 32;
3178     uint32_t fst2;
3179     uint32_t fsth2;
3180
3181     fst2 = float32_mul (fst0, fsth0, &env->active_fpu.fp_status);
3182     fsth2 = float32_mul (fst1, fsth1, &env->active_fpu.fp_status);
3183     update_fcr31(env, GETPC());
3184     return ((uint64_t)fsth2 << 32) | fst2;
3185 }
3186
3187 /* compare operations */
3188 #define FOP_COND_D(op, cond)                                   \
3189 void helper_cmp_d_ ## op(CPUMIPSState *env, uint64_t fdt0,     \
3190                          uint64_t fdt1, int cc)                \
3191 {                                                              \
3192     int c;                                                     \
3193     c = cond;                                                  \
3194     update_fcr31(env, GETPC());                                \
3195     if (c)                                                     \
3196         SET_FP_COND(cc, env->active_fpu);                      \
3197     else                                                       \
3198         CLEAR_FP_COND(cc, env->active_fpu);                    \
3199 }                                                              \
3200 void helper_cmpabs_d_ ## op(CPUMIPSState *env, uint64_t fdt0,  \
3201                             uint64_t fdt1, int cc)             \
3202 {                                                              \
3203     int c;                                                     \
3204     fdt0 = float64_abs(fdt0);                                  \
3205     fdt1 = float64_abs(fdt1);                                  \
3206     c = cond;                                                  \
3207     update_fcr31(env, GETPC());                                \
3208     if (c)                                                     \
3209         SET_FP_COND(cc, env->active_fpu);                      \
3210     else                                                       \
3211         CLEAR_FP_COND(cc, env->active_fpu);                    \
3212 }
3213
3214 /* NOTE: the comma operator will make "cond" to eval to false,
3215  * but float64_unordered_quiet() is still called. */
3216 FOP_COND_D(f,   (float64_unordered_quiet(fdt1, fdt0, &env->active_fpu.fp_status), 0))
3217 FOP_COND_D(un,  float64_unordered_quiet(fdt1, fdt0, &env->active_fpu.fp_status))
3218 FOP_COND_D(eq,  float64_eq_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3219 FOP_COND_D(ueq, float64_unordered_quiet(fdt1, fdt0, &env->active_fpu.fp_status)  || float64_eq_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3220 FOP_COND_D(olt, float64_lt_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3221 FOP_COND_D(ult, float64_unordered_quiet(fdt1, fdt0, &env->active_fpu.fp_status)  || float64_lt_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3222 FOP_COND_D(ole, float64_le_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3223 FOP_COND_D(ule, float64_unordered_quiet(fdt1, fdt0, &env->active_fpu.fp_status)  || float64_le_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3224 /* NOTE: the comma operator will make "cond" to eval to false,
3225  * but float64_unordered() is still called. */
3226 FOP_COND_D(sf,  (float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status), 0))
3227 FOP_COND_D(ngle,float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status))
3228 FOP_COND_D(seq, float64_eq(fdt0, fdt1, &env->active_fpu.fp_status))
3229 FOP_COND_D(ngl, float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status)  || float64_eq(fdt0, fdt1, &env->active_fpu.fp_status))
3230 FOP_COND_D(lt,  float64_lt(fdt0, fdt1, &env->active_fpu.fp_status))
3231 FOP_COND_D(nge, float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status)  || float64_lt(fdt0, fdt1, &env->active_fpu.fp_status))
3232 FOP_COND_D(le,  float64_le(fdt0, fdt1, &env->active_fpu.fp_status))
3233 FOP_COND_D(ngt, float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status)  || float64_le(fdt0, fdt1, &env->active_fpu.fp_status))
3234
3235 #define FOP_COND_S(op, cond)                                   \
3236 void helper_cmp_s_ ## op(CPUMIPSState *env, uint32_t fst0,     \
3237                          uint32_t fst1, int cc)                \
3238 {                                                              \
3239     int c;                                                     \
3240     c = cond;                                                  \
3241     update_fcr31(env, GETPC());                                \
3242     if (c)                                                     \
3243         SET_FP_COND(cc, env->active_fpu);                      \
3244     else                                                       \
3245         CLEAR_FP_COND(cc, env->active_fpu);                    \
3246 }                                                              \
3247 void helper_cmpabs_s_ ## op(CPUMIPSState *env, uint32_t fst0,  \
3248                             uint32_t fst1, int cc)             \
3249 {                                                              \
3250     int c;                                                     \
3251     fst0 = float32_abs(fst0);                                  \
3252     fst1 = float32_abs(fst1);                                  \
3253     c = cond;                                                  \
3254     update_fcr31(env, GETPC());                                \
3255     if (c)                                                     \
3256         SET_FP_COND(cc, env->active_fpu);                      \
3257     else                                                       \
3258         CLEAR_FP_COND(cc, env->active_fpu);                    \
3259 }
3260
3261 /* NOTE: the comma operator will make "cond" to eval to false,
3262  * but float32_unordered_quiet() is still called. */
3263 FOP_COND_S(f,   (float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status), 0))
3264 FOP_COND_S(un,  float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status))
3265 FOP_COND_S(eq,  float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status))
3266 FOP_COND_S(ueq, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status)  || float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status))
3267 FOP_COND_S(olt, float32_lt_quiet(fst0, fst1, &env->active_fpu.fp_status))
3268 FOP_COND_S(ult, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status)  || float32_lt_quiet(fst0, fst1, &env->active_fpu.fp_status))
3269 FOP_COND_S(ole, float32_le_quiet(fst0, fst1, &env->active_fpu.fp_status))
3270 FOP_COND_S(ule, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status)  || float32_le_quiet(fst0, fst1, &env->active_fpu.fp_status))
3271 /* NOTE: the comma operator will make "cond" to eval to false,
3272  * but float32_unordered() is still called. */
3273 FOP_COND_S(sf,  (float32_unordered(fst1, fst0, &env->active_fpu.fp_status), 0))
3274 FOP_COND_S(ngle,float32_unordered(fst1, fst0, &env->active_fpu.fp_status))
3275 FOP_COND_S(seq, float32_eq(fst0, fst1, &env->active_fpu.fp_status))
3276 FOP_COND_S(ngl, float32_unordered(fst1, fst0, &env->active_fpu.fp_status)  || float32_eq(fst0, fst1, &env->active_fpu.fp_status))
3277 FOP_COND_S(lt,  float32_lt(fst0, fst1, &env->active_fpu.fp_status))
3278 FOP_COND_S(nge, float32_unordered(fst1, fst0, &env->active_fpu.fp_status)  || float32_lt(fst0, fst1, &env->active_fpu.fp_status))
3279 FOP_COND_S(le,  float32_le(fst0, fst1, &env->active_fpu.fp_status))
3280 FOP_COND_S(ngt, float32_unordered(fst1, fst0, &env->active_fpu.fp_status)  || float32_le(fst0, fst1, &env->active_fpu.fp_status))
3281
3282 #define FOP_COND_PS(op, condl, condh)                           \
3283 void helper_cmp_ps_ ## op(CPUMIPSState *env, uint64_t fdt0,     \
3284                           uint64_t fdt1, int cc)                \
3285 {                                                               \
3286     uint32_t fst0, fsth0, fst1, fsth1;                          \
3287     int ch, cl;                                                 \
3288     fst0 = fdt0 & 0XFFFFFFFF;                                   \
3289     fsth0 = fdt0 >> 32;                                         \
3290     fst1 = fdt1 & 0XFFFFFFFF;                                   \
3291     fsth1 = fdt1 >> 32;                                         \
3292     cl = condl;                                                 \
3293     ch = condh;                                                 \
3294     update_fcr31(env, GETPC());                                 \
3295     if (cl)                                                     \
3296         SET_FP_COND(cc, env->active_fpu);                       \
3297     else                                                        \
3298         CLEAR_FP_COND(cc, env->active_fpu);                     \
3299     if (ch)                                                     \
3300         SET_FP_COND(cc + 1, env->active_fpu);                   \
3301     else                                                        \
3302         CLEAR_FP_COND(cc + 1, env->active_fpu);                 \
3303 }                                                               \
3304 void helper_cmpabs_ps_ ## op(CPUMIPSState *env, uint64_t fdt0,  \
3305                              uint64_t fdt1, int cc)             \
3306 {                                                               \
3307     uint32_t fst0, fsth0, fst1, fsth1;                          \
3308     int ch, cl;                                                 \
3309     fst0 = float32_abs(fdt0 & 0XFFFFFFFF);                      \
3310     fsth0 = float32_abs(fdt0 >> 32);                            \
3311     fst1 = float32_abs(fdt1 & 0XFFFFFFFF);                      \
3312     fsth1 = float32_abs(fdt1 >> 32);                            \
3313     cl = condl;                                                 \
3314     ch = condh;                                                 \
3315     update_fcr31(env, GETPC());                                 \
3316     if (cl)                                                     \
3317         SET_FP_COND(cc, env->active_fpu);                       \
3318     else                                                        \
3319         CLEAR_FP_COND(cc, env->active_fpu);                     \
3320     if (ch)                                                     \
3321         SET_FP_COND(cc + 1, env->active_fpu);                   \
3322     else                                                        \
3323         CLEAR_FP_COND(cc + 1, env->active_fpu);                 \
3324 }
3325
3326 /* NOTE: the comma operator will make "cond" to eval to false,
3327  * but float32_unordered_quiet() is still called. */
3328 FOP_COND_PS(f,   (float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status), 0),
3329                  (float32_unordered_quiet(fsth1, fsth0, &env->active_fpu.fp_status), 0))
3330 FOP_COND_PS(un,  float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status),
3331                  float32_unordered_quiet(fsth1, fsth0, &env->active_fpu.fp_status))
3332 FOP_COND_PS(eq,  float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status),
3333                  float32_eq_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3334 FOP_COND_PS(ueq, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status)    || float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status),
3335                  float32_unordered_quiet(fsth1, fsth0, &env->active_fpu.fp_status)  || float32_eq_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3336 FOP_COND_PS(olt, float32_lt_quiet(fst0, fst1, &env->active_fpu.fp_status),
3337                  float32_lt_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3338 FOP_COND_PS(ult, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status)    || float32_lt_quiet(fst0, fst1, &env->active_fpu.fp_status),
3339                  float32_unordered_quiet(fsth1, fsth0, &env->active_fpu.fp_status)  || float32_lt_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3340 FOP_COND_PS(ole, float32_le_quiet(fst0, fst1, &env->active_fpu.fp_status),
3341                  float32_le_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3342 FOP_COND_PS(ule, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status)    || float32_le_quiet(fst0, fst1, &env->active_fpu.fp_status),
3343                  float32_unordered_quiet(fsth1, fsth0, &env->active_fpu.fp_status)  || float32_le_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3344 /* NOTE: the comma operator will make "cond" to eval to false,
3345  * but float32_unordered() is still called. */
3346 FOP_COND_PS(sf,  (float32_unordered(fst1, fst0, &env->active_fpu.fp_status), 0),
3347                  (float32_unordered(fsth1, fsth0, &env->active_fpu.fp_status), 0))
3348 FOP_COND_PS(ngle,float32_unordered(fst1, fst0, &env->active_fpu.fp_status),
3349                  float32_unordered(fsth1, fsth0, &env->active_fpu.fp_status))
3350 FOP_COND_PS(seq, float32_eq(fst0, fst1, &env->active_fpu.fp_status),
3351                  float32_eq(fsth0, fsth1, &env->active_fpu.fp_status))
3352 FOP_COND_PS(ngl, float32_unordered(fst1, fst0, &env->active_fpu.fp_status)    || float32_eq(fst0, fst1, &env->active_fpu.fp_status),
3353                  float32_unordered(fsth1, fsth0, &env->active_fpu.fp_status)  || float32_eq(fsth0, fsth1, &env->active_fpu.fp_status))
3354 FOP_COND_PS(lt,  float32_lt(fst0, fst1, &env->active_fpu.fp_status),
3355                  float32_lt(fsth0, fsth1, &env->active_fpu.fp_status))
3356 FOP_COND_PS(nge, float32_unordered(fst1, fst0, &env->active_fpu.fp_status)    || float32_lt(fst0, fst1, &env->active_fpu.fp_status),
3357                  float32_unordered(fsth1, fsth0, &env->active_fpu.fp_status)  || float32_lt(fsth0, fsth1, &env->active_fpu.fp_status))
3358 FOP_COND_PS(le,  float32_le(fst0, fst1, &env->active_fpu.fp_status),
3359                  float32_le(fsth0, fsth1, &env->active_fpu.fp_status))
3360 FOP_COND_PS(ngt, float32_unordered(fst1, fst0, &env->active_fpu.fp_status)    || float32_le(fst0, fst1, &env->active_fpu.fp_status),
3361                  float32_unordered(fsth1, fsth0, &env->active_fpu.fp_status)  || float32_le(fsth0, fsth1, &env->active_fpu.fp_status))