target-alpha/translate.c

   1 /*
   2  *  Alpha emulation cpu translation for qemu.
   3  *
   4  *  Copyright (c) 2007 Jocelyn Mayer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "cpu.h"
  21 #include "disas.h"
  22 #include "host-utils.h"
  23 #include "tcg-op.h"
  24
  25 #include "helper.h"
  26 #define GEN_HELPER 1
  27 #include "helper.h"
  28
  29 #undef ALPHA_DEBUG_DISAS
  30 #define CONFIG_SOFTFLOAT_INLINE
  31
  32 #ifdef ALPHA_DEBUG_DISAS
  33 #  define LOG_DISAS(...) qemu_log_mask(CPU_LOG_TB_IN_ASM, ## __VA_ARGS__)
  34 #else
  35 #  define LOG_DISAS(...) do { } while (0)
  36 #endif
  37
  38 typedef struct DisasContext DisasContext;
  39 struct DisasContext {
  40     struct TranslationBlock *tb;
  41     CPUAlphaState *env;
  42     uint64_t pc;
  43     int mem_idx;
  44
  45     /* Current rounding mode for this TB.  */
  46     int tb_rm;
  47     /* Current flush-to-zero setting for this TB.  */
  48     int tb_ftz;
  49 };
  50
  51 /* Return values from translate_one, indicating the state of the TB.
  52    Note that zero indicates that we are not exiting the TB.  */
  53
  54 typedef enum {
  55     NO_EXIT,
  56
  57     /* We have emitted one or more goto_tb.  No fixup required.  */
  58     EXIT_GOTO_TB,
  59
  60     /* We are not using a goto_tb (for whatever reason), but have updated
  61        the PC (for whatever reason), so there's no need to do it again on
  62        exiting the TB.  */
  63     EXIT_PC_UPDATED,
  64
  65     /* We are exiting the TB, but have neither emitted a goto_tb, nor
  66        updated the PC for the next instruction to be executed.  */
  67     EXIT_PC_STALE,
  68
  69     /* We are ending the TB with a noreturn function call, e.g. longjmp.
  70        No following code will be executed.  */
  71     EXIT_NORETURN,
  72 } ExitStatus;
  73
  74 /* global register indexes */
  75 static TCGv_ptr cpu_env;
  76 static TCGv cpu_ir[31];
  77 static TCGv cpu_fir[31];
  78 static TCGv cpu_pc;
  79 static TCGv cpu_lock_addr;
  80 static TCGv cpu_lock_st_addr;
  81 static TCGv cpu_lock_value;
  82 static TCGv cpu_unique;
  83 #ifndef CONFIG_USER_ONLY
  84 static TCGv cpu_sysval;
  85 static TCGv cpu_usp;
  86 #endif
  87
  88 /* register names */
  89 static char cpu_reg_names[10*4+21*5 + 10*5+21*6];
  90
  91 #include "gen-icount.h"
  92
  93 static void alpha_translate_init(void)
  94 {
  95     int i;
  96     char *p;
  97     static int done_init = 0;
  98
  99     if (done_init)
 100         return;
 101
 102     cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
 103
 104     p = cpu_reg_names;
 105     for (i = 0; i < 31; i++) {
 106         sprintf(p, "ir%d", i);
 107         cpu_ir[i] = tcg_global_mem_new_i64(TCG_AREG0,
 108                                            offsetof(CPUAlphaState, ir[i]), p);
 109         p += (i < 10) ? 4 : 5;
 110
 111         sprintf(p, "fir%d", i);
 112         cpu_fir[i] = tcg_global_mem_new_i64(TCG_AREG0,
 113                                             offsetof(CPUAlphaState, fir[i]), p);
 114         p += (i < 10) ? 5 : 6;
 115     }
 116
 117     cpu_pc = tcg_global_mem_new_i64(TCG_AREG0,
 118                                     offsetof(CPUAlphaState, pc), "pc");
 119
 120     cpu_lock_addr = tcg_global_mem_new_i64(TCG_AREG0,
 121                                            offsetof(CPUAlphaState, lock_addr),
 122                                            "lock_addr");
 123     cpu_lock_st_addr = tcg_global_mem_new_i64(TCG_AREG0,
 124                                               offsetof(CPUAlphaState, lock_st_addr),
 125                                               "lock_st_addr");
 126     cpu_lock_value = tcg_global_mem_new_i64(TCG_AREG0,
 127                                             offsetof(CPUAlphaState, lock_value),
 128                                             "lock_value");
 129
 130     cpu_unique = tcg_global_mem_new_i64(TCG_AREG0,
 131                                         offsetof(CPUAlphaState, unique), "unique");
 132 #ifndef CONFIG_USER_ONLY
 133     cpu_sysval = tcg_global_mem_new_i64(TCG_AREG0,
 134                                         offsetof(CPUAlphaState, sysval), "sysval");
 135     cpu_usp = tcg_global_mem_new_i64(TCG_AREG0,
 136                                      offsetof(CPUAlphaState, usp), "usp");
 137 #endif
 138
 139     /* register helpers */
 140 #define GEN_HELPER 2
 141 #include "helper.h"
 142
 143     done_init = 1;
 144 }
 145
 146 static void gen_excp_1(int exception, int error_code)
 147 {
 148     TCGv_i32 tmp1, tmp2;
 149
 150     tmp1 = tcg_const_i32(exception);
 151     tmp2 = tcg_const_i32(error_code);
 152     gen_helper_excp(cpu_env, tmp1, tmp2);
 153     tcg_temp_free_i32(tmp2);
 154     tcg_temp_free_i32(tmp1);
 155 }
 156
 157 static ExitStatus gen_excp(DisasContext *ctx, int exception, int error_code)
 158 {
 159     tcg_gen_movi_i64(cpu_pc, ctx->pc);
 160     gen_excp_1(exception, error_code);
 161     return EXIT_NORETURN;
 162 }
 163
 164 static inline ExitStatus gen_invalid(DisasContext *ctx)
 165 {
 166     return gen_excp(ctx, EXCP_OPCDEC, 0);
 167 }
 168
 169 static inline void gen_qemu_ldf(TCGv t0, TCGv t1, int flags)
 170 {
 171     TCGv tmp = tcg_temp_new();
 172     TCGv_i32 tmp32 = tcg_temp_new_i32();
 173     tcg_gen_qemu_ld32u(tmp, t1, flags);
 174     tcg_gen_trunc_i64_i32(tmp32, tmp);
 175     gen_helper_memory_to_f(t0, tmp32);
 176     tcg_temp_free_i32(tmp32);
 177     tcg_temp_free(tmp);
 178 }
 179
 180 static inline void gen_qemu_ldg(TCGv t0, TCGv t1, int flags)
 181 {
 182     TCGv tmp = tcg_temp_new();
 183     tcg_gen_qemu_ld64(tmp, t1, flags);
 184     gen_helper_memory_to_g(t0, tmp);
 185     tcg_temp_free(tmp);
 186 }
 187
 188 static inline void gen_qemu_lds(TCGv t0, TCGv t1, int flags)
 189 {
 190     TCGv tmp = tcg_temp_new();
 191     TCGv_i32 tmp32 = tcg_temp_new_i32();
 192     tcg_gen_qemu_ld32u(tmp, t1, flags);
 193     tcg_gen_trunc_i64_i32(tmp32, tmp);
 194     gen_helper_memory_to_s(t0, tmp32);
 195     tcg_temp_free_i32(tmp32);
 196     tcg_temp_free(tmp);
 197 }
 198
 199 static inline void gen_qemu_ldl_l(TCGv t0, TCGv t1, int flags)
 200 {
 201     tcg_gen_qemu_ld32s(t0, t1, flags);
 202     tcg_gen_mov_i64(cpu_lock_addr, t1);
 203     tcg_gen_mov_i64(cpu_lock_value, t0);
 204 }
 205
 206 static inline void gen_qemu_ldq_l(TCGv t0, TCGv t1, int flags)
 207 {
 208     tcg_gen_qemu_ld64(t0, t1, flags);
 209     tcg_gen_mov_i64(cpu_lock_addr, t1);
 210     tcg_gen_mov_i64(cpu_lock_value, t0);
 211 }
 212
 213 static inline void gen_load_mem(DisasContext *ctx,
 214                                 void (*tcg_gen_qemu_load)(TCGv t0, TCGv t1,
 215                                                           int flags),
 216                                 int ra, int rb, int32_t disp16, int fp,
 217                                 int clear)
 218 {
 219     TCGv addr, va;
 220
 221     /* LDQ_U with ra $31 is UNOP.  Other various loads are forms of
 222        prefetches, which we can treat as nops.  No worries about
 223        missed exceptions here.  */
 224     if (unlikely(ra == 31)) {
 225         return;
 226     }
 227
 228     addr = tcg_temp_new();
 229     if (rb != 31) {
 230         tcg_gen_addi_i64(addr, cpu_ir[rb], disp16);
 231         if (clear) {
 232             tcg_gen_andi_i64(addr, addr, ~0x7);
 233         }
 234     } else {
 235         if (clear) {
 236             disp16 &= ~0x7;
 237         }
 238         tcg_gen_movi_i64(addr, disp16);
 239     }
 240
 241     va = (fp ? cpu_fir[ra] : cpu_ir[ra]);
 242     tcg_gen_qemu_load(va, addr, ctx->mem_idx);
 243
 244     tcg_temp_free(addr);
 245 }
 246
 247 static inline void gen_qemu_stf(TCGv t0, TCGv t1, int flags)
 248 {
 249     TCGv_i32 tmp32 = tcg_temp_new_i32();
 250     TCGv tmp = tcg_temp_new();
 251     gen_helper_f_to_memory(tmp32, t0);
 252     tcg_gen_extu_i32_i64(tmp, tmp32);
 253     tcg_gen_qemu_st32(tmp, t1, flags);
 254     tcg_temp_free(tmp);
 255     tcg_temp_free_i32(tmp32);
 256 }
 257
 258 static inline void gen_qemu_stg(TCGv t0, TCGv t1, int flags)
 259 {
 260     TCGv tmp = tcg_temp_new();
 261     gen_helper_g_to_memory(tmp, t0);
 262     tcg_gen_qemu_st64(tmp, t1, flags);
 263     tcg_temp_free(tmp);
 264 }
 265
 266 static inline void gen_qemu_sts(TCGv t0, TCGv t1, int flags)
 267 {
 268     TCGv_i32 tmp32 = tcg_temp_new_i32();
 269     TCGv tmp = tcg_temp_new();
 270     gen_helper_s_to_memory(tmp32, t0);
 271     tcg_gen_extu_i32_i64(tmp, tmp32);
 272     tcg_gen_qemu_st32(tmp, t1, flags);
 273     tcg_temp_free(tmp);
 274     tcg_temp_free_i32(tmp32);
 275 }
 276
 277 static inline void gen_store_mem(DisasContext *ctx,
 278                                  void (*tcg_gen_qemu_store)(TCGv t0, TCGv t1,
 279                                                             int flags),
 280                                  int ra, int rb, int32_t disp16, int fp,
 281                                  int clear)
 282 {
 283     TCGv addr, va;
 284
 285     addr = tcg_temp_new();
 286     if (rb != 31) {
 287         tcg_gen_addi_i64(addr, cpu_ir[rb], disp16);
 288         if (clear) {
 289             tcg_gen_andi_i64(addr, addr, ~0x7);
 290         }
 291     } else {
 292         if (clear) {
 293             disp16 &= ~0x7;
 294         }
 295         tcg_gen_movi_i64(addr, disp16);
 296     }
 297
 298     if (ra == 31) {
 299         va = tcg_const_i64(0);
 300     } else {
 301         va = (fp ? cpu_fir[ra] : cpu_ir[ra]);
 302     }
 303     tcg_gen_qemu_store(va, addr, ctx->mem_idx);
 304
 305     tcg_temp_free(addr);
 306     if (ra == 31) {
 307         tcg_temp_free(va);
 308     }
 309 }
 310
 311 static ExitStatus gen_store_conditional(DisasContext *ctx, int ra, int rb,
 312                                         int32_t disp16, int quad)
 313 {
 314     TCGv addr;
 315
 316     if (ra == 31) {
 317         /* ??? Don't bother storing anything.  The user can't tell
 318            the difference, since the zero register always reads zero.  */
 319         return NO_EXIT;
 320     }
 321
 322 #if defined(CONFIG_USER_ONLY)
 323     addr = cpu_lock_st_addr;
 324 #else
 325     addr = tcg_temp_local_new();
 326 #endif
 327
 328     if (rb != 31) {
 329         tcg_gen_addi_i64(addr, cpu_ir[rb], disp16);
 330     } else {
 331         tcg_gen_movi_i64(addr, disp16);
 332     }
 333
 334 #if defined(CONFIG_USER_ONLY)
 335     /* ??? This is handled via a complicated version of compare-and-swap
 336        in the cpu_loop.  Hopefully one day we'll have a real CAS opcode
 337        in TCG so that this isn't necessary.  */
 338     return gen_excp(ctx, quad ? EXCP_STQ_C : EXCP_STL_C, ra);
 339 #else
 340     /* ??? In system mode we are never multi-threaded, so CAS can be
 341        implemented via a non-atomic load-compare-store sequence.  */
 342     {
 343         int lab_fail, lab_done;
 344         TCGv val;
 345
 346         lab_fail = gen_new_label();
 347         lab_done = gen_new_label();
 348         tcg_gen_brcond_i64(TCG_COND_NE, addr, cpu_lock_addr, lab_fail);
 349
 350         val = tcg_temp_new();
 351         if (quad) {
 352             tcg_gen_qemu_ld64(val, addr, ctx->mem_idx);
 353         } else {
 354             tcg_gen_qemu_ld32s(val, addr, ctx->mem_idx);
 355         }
 356         tcg_gen_brcond_i64(TCG_COND_NE, val, cpu_lock_value, lab_fail);
 357
 358         if (quad) {
 359             tcg_gen_qemu_st64(cpu_ir[ra], addr, ctx->mem_idx);
 360         } else {
 361             tcg_gen_qemu_st32(cpu_ir[ra], addr, ctx->mem_idx);
 362         }
 363         tcg_gen_movi_i64(cpu_ir[ra], 1);
 364         tcg_gen_br(lab_done);
 365
 366         gen_set_label(lab_fail);
 367         tcg_gen_movi_i64(cpu_ir[ra], 0);
 368
 369         gen_set_label(lab_done);
 370         tcg_gen_movi_i64(cpu_lock_addr, -1);
 371
 372         tcg_temp_free(addr);
 373         return NO_EXIT;
 374     }
 375 #endif
 376 }
 377
 378 static int use_goto_tb(DisasContext *ctx, uint64_t dest)
 379 {
 380     /* Check for the dest on the same page as the start of the TB.  We
 381        also want to suppress goto_tb in the case of single-steping and IO.  */
 382     return (((ctx->tb->pc ^ dest) & TARGET_PAGE_MASK) == 0
 383             && !ctx->env->singlestep_enabled
 384             && !(ctx->tb->cflags & CF_LAST_IO));
 385 }
 386
 387 static ExitStatus gen_bdirect(DisasContext *ctx, int ra, int32_t disp)
 388 {
 389     uint64_t dest = ctx->pc + (disp << 2);
 390
 391     if (ra != 31) {
 392         tcg_gen_movi_i64(cpu_ir[ra], ctx->pc);
 393     }
 394
 395     /* Notice branch-to-next; used to initialize RA with the PC.  */
 396     if (disp == 0) {
 397         return 0;
 398     } else if (use_goto_tb(ctx, dest)) {
 399         tcg_gen_goto_tb(0);
 400         tcg_gen_movi_i64(cpu_pc, dest);
 401         tcg_gen_exit_tb((tcg_target_long)ctx->tb);
 402         return EXIT_GOTO_TB;
 403     } else {
 404         tcg_gen_movi_i64(cpu_pc, dest);
 405         return EXIT_PC_UPDATED;
 406     }
 407 }
 408
 409 static ExitStatus gen_bcond_internal(DisasContext *ctx, TCGCond cond,
 410                                      TCGv cmp, int32_t disp)
 411 {
 412     uint64_t dest = ctx->pc + (disp << 2);
 413     int lab_true = gen_new_label();
 414
 415     if (use_goto_tb(ctx, dest)) {
 416         tcg_gen_brcondi_i64(cond, cmp, 0, lab_true);
 417
 418         tcg_gen_goto_tb(0);
 419         tcg_gen_movi_i64(cpu_pc, ctx->pc);
 420         tcg_gen_exit_tb((tcg_target_long)ctx->tb);
 421
 422         gen_set_label(lab_true);
 423         tcg_gen_goto_tb(1);
 424         tcg_gen_movi_i64(cpu_pc, dest);
 425         tcg_gen_exit_tb((tcg_target_long)ctx->tb + 1);
 426
 427         return EXIT_GOTO_TB;
 428     } else {
 429         int lab_over = gen_new_label();
 430
 431         /* ??? Consider using either
 432              movi pc, next
 433              addi tmp, pc, disp
 434              movcond pc, cond, 0, tmp, pc
 435            or
 436              setcond tmp, cond, 0
 437              movi pc, next
 438              neg tmp, tmp
 439              andi tmp, tmp, disp
 440              add pc, pc, tmp
 441            The current diamond subgraph surely isn't efficient.  */
 442
 443         tcg_gen_brcondi_i64(cond, cmp, 0, lab_true);
 444         tcg_gen_movi_i64(cpu_pc, ctx->pc);
 445         tcg_gen_br(lab_over);
 446         gen_set_label(lab_true);
 447         tcg_gen_movi_i64(cpu_pc, dest);
 448         gen_set_label(lab_over);
 449
 450         return EXIT_PC_UPDATED;
 451     }
 452 }
 453
 454 static ExitStatus gen_bcond(DisasContext *ctx, TCGCond cond, int ra,
 455                             int32_t disp, int mask)
 456 {
 457     TCGv cmp_tmp;
 458
 459     if (unlikely(ra == 31)) {
 460         cmp_tmp = tcg_const_i64(0);
 461     } else {
 462         cmp_tmp = tcg_temp_new();
 463         if (mask) {
 464             tcg_gen_andi_i64(cmp_tmp, cpu_ir[ra], 1);
 465         } else {
 466             tcg_gen_mov_i64(cmp_tmp, cpu_ir[ra]);
 467         }
 468     }
 469
 470     return gen_bcond_internal(ctx, cond, cmp_tmp, disp);
 471 }
 472
 473 /* Fold -0.0 for comparison with COND.  */
 474
 475 static void gen_fold_mzero(TCGCond cond, TCGv dest, TCGv src)
 476 {
 477     uint64_t mzero = 1ull << 63;
 478
 479     switch (cond) {
 480     case TCG_COND_LE:
 481     case TCG_COND_GT:
 482         /* For <= or >, the -0.0 value directly compares the way we want.  */
 483         tcg_gen_mov_i64(dest, src);
 484         break;
 485
 486     case TCG_COND_EQ:
 487     case TCG_COND_NE:
 488         /* For == or !=, we can simply mask off the sign bit and compare.  */
 489         tcg_gen_andi_i64(dest, src, mzero - 1);
 490         break;
 491
 492     case TCG_COND_GE:
 493     case TCG_COND_LT:
 494         /* For >= or <, map -0.0 to +0.0 via comparison and mask.  */
 495         tcg_gen_setcondi_i64(TCG_COND_NE, dest, src, mzero);
 496         tcg_gen_neg_i64(dest, dest);
 497         tcg_gen_and_i64(dest, dest, src);
 498         break;
 499
 500     default:
 501         abort();
 502     }
 503 }
 504
 505 static ExitStatus gen_fbcond(DisasContext *ctx, TCGCond cond, int ra,
 506                              int32_t disp)
 507 {
 508     TCGv cmp_tmp;
 509
 510     if (unlikely(ra == 31)) {
 511         /* Very uncommon case, but easier to optimize it to an integer
 512            comparison than continuing with the floating point comparison.  */
 513         return gen_bcond(ctx, cond, ra, disp, 0);
 514     }
 515
 516     cmp_tmp = tcg_temp_new();
 517     gen_fold_mzero(cond, cmp_tmp, cpu_fir[ra]);
 518     return gen_bcond_internal(ctx, cond, cmp_tmp, disp);
 519 }
 520
 521 static void gen_cmov(TCGCond cond, int ra, int rb, int rc,
 522                      int islit, uint8_t lit, int mask)
 523 {
 524     TCGCond inv_cond = tcg_invert_cond(cond);
 525     int l1;
 526
 527     if (unlikely(rc == 31))
 528         return;
 529
 530     l1 = gen_new_label();
 531
 532     if (ra != 31) {
 533         if (mask) {
 534             TCGv tmp = tcg_temp_new();
 535             tcg_gen_andi_i64(tmp, cpu_ir[ra], 1);
 536             tcg_gen_brcondi_i64(inv_cond, tmp, 0, l1);
 537             tcg_temp_free(tmp);
 538         } else
 539             tcg_gen_brcondi_i64(inv_cond, cpu_ir[ra], 0, l1);
 540     } else {
 541         /* Very uncommon case - Do not bother to optimize.  */
 542         TCGv tmp = tcg_const_i64(0);
 543         tcg_gen_brcondi_i64(inv_cond, tmp, 0, l1);
 544         tcg_temp_free(tmp);
 545     }
 546
 547     if (islit)
 548         tcg_gen_movi_i64(cpu_ir[rc], lit);
 549     else
 550         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
 551     gen_set_label(l1);
 552 }
 553
 554 static void gen_fcmov(TCGCond cond, int ra, int rb, int rc)
 555 {
 556     TCGv cmp_tmp;
 557     int l1;
 558
 559     if (unlikely(rc == 31)) {
 560         return;
 561     }
 562
 563     cmp_tmp = tcg_temp_new();
 564     if (unlikely(ra == 31)) {
 565         tcg_gen_movi_i64(cmp_tmp, 0);
 566     } else {
 567         gen_fold_mzero(cond, cmp_tmp, cpu_fir[ra]);
 568     }
 569
 570     l1 = gen_new_label();
 571     tcg_gen_brcondi_i64(tcg_invert_cond(cond), cmp_tmp, 0, l1);
 572     tcg_temp_free(cmp_tmp);
 573
 574     if (rb != 31)
 575         tcg_gen_mov_i64(cpu_fir[rc], cpu_fir[rb]);
 576     else
 577         tcg_gen_movi_i64(cpu_fir[rc], 0);
 578     gen_set_label(l1);
 579 }
 580
 581 #define QUAL_RM_N       0x080   /* Round mode nearest even */
 582 #define QUAL_RM_C       0x000   /* Round mode chopped */
 583 #define QUAL_RM_M       0x040   /* Round mode minus infinity */
 584 #define QUAL_RM_D       0x0c0   /* Round mode dynamic */
 585 #define QUAL_RM_MASK    0x0c0
 586
 587 #define QUAL_U          0x100   /* Underflow enable (fp output) */
 588 #define QUAL_V          0x100   /* Overflow enable (int output) */
 589 #define QUAL_S          0x400   /* Software completion enable */
 590 #define QUAL_I          0x200   /* Inexact detection enable */
 591
 592 static void gen_qual_roundmode(DisasContext *ctx, int fn11)
 593 {
 594     TCGv_i32 tmp;
 595
 596     fn11 &= QUAL_RM_MASK;
 597     if (fn11 == ctx->tb_rm) {
 598         return;
 599     }
 600     ctx->tb_rm = fn11;
 601
 602     tmp = tcg_temp_new_i32();
 603     switch (fn11) {
 604     case QUAL_RM_N:
 605         tcg_gen_movi_i32(tmp, float_round_nearest_even);
 606         break;
 607     case QUAL_RM_C:
 608         tcg_gen_movi_i32(tmp, float_round_to_zero);
 609         break;
 610     case QUAL_RM_M:
 611         tcg_gen_movi_i32(tmp, float_round_down);
 612         break;
 613     case QUAL_RM_D:
 614         tcg_gen_ld8u_i32(tmp, cpu_env,
 615                          offsetof(CPUAlphaState, fpcr_dyn_round));
 616         break;
 617     }
 618
 619 #if defined(CONFIG_SOFTFLOAT_INLINE)
 620     /* ??? The "softfloat.h" interface is to call set_float_rounding_mode.
 621        With CONFIG_SOFTFLOAT that expands to an out-of-line call that just
 622        sets the one field.  */
 623     tcg_gen_st8_i32(tmp, cpu_env,
 624                     offsetof(CPUAlphaState, fp_status.float_rounding_mode));
 625 #else
 626     gen_helper_setroundmode(tmp);
 627 #endif
 628
 629     tcg_temp_free_i32(tmp);
 630 }
 631
 632 static void gen_qual_flushzero(DisasContext *ctx, int fn11)
 633 {
 634     TCGv_i32 tmp;
 635
 636     fn11 &= QUAL_U;
 637     if (fn11 == ctx->tb_ftz) {
 638         return;
 639     }
 640     ctx->tb_ftz = fn11;
 641
 642     tmp = tcg_temp_new_i32();
 643     if (fn11) {
 644         /* Underflow is enabled, use the FPCR setting.  */
 645         tcg_gen_ld8u_i32(tmp, cpu_env,
 646                          offsetof(CPUAlphaState, fpcr_flush_to_zero));
 647     } else {
 648         /* Underflow is disabled, force flush-to-zero.  */
 649         tcg_gen_movi_i32(tmp, 1);
 650     }
 651
 652 #if defined(CONFIG_SOFTFLOAT_INLINE)
 653     tcg_gen_st8_i32(tmp, cpu_env,
 654                     offsetof(CPUAlphaState, fp_status.flush_to_zero));
 655 #else
 656     gen_helper_setflushzero(tmp);
 657 #endif
 658
 659     tcg_temp_free_i32(tmp);
 660 }
 661
 662 static TCGv gen_ieee_input(int reg, int fn11, int is_cmp)
 663 {
 664     TCGv val;
 665     if (reg == 31) {
 666         val = tcg_const_i64(0);
 667     } else {
 668         if ((fn11 & QUAL_S) == 0) {
 669             if (is_cmp) {
 670                 gen_helper_ieee_input_cmp(cpu_env, cpu_fir[reg]);
 671             } else {
 672                 gen_helper_ieee_input(cpu_env, cpu_fir[reg]);
 673             }
 674         }
 675         val = tcg_temp_new();
 676         tcg_gen_mov_i64(val, cpu_fir[reg]);
 677     }
 678     return val;
 679 }
 680
 681 static void gen_fp_exc_clear(void)
 682 {
 683 #if defined(CONFIG_SOFTFLOAT_INLINE)
 684     TCGv_i32 zero = tcg_const_i32(0);
 685     tcg_gen_st8_i32(zero, cpu_env,
 686                     offsetof(CPUAlphaState, fp_status.float_exception_flags));
 687     tcg_temp_free_i32(zero);
 688 #else
 689     gen_helper_fp_exc_clear(cpu_env);
 690 #endif
 691 }
 692
 693 static void gen_fp_exc_raise_ignore(int rc, int fn11, int ignore)
 694 {
 695     /* ??? We ought to be able to do something with imprecise exceptions.
 696        E.g. notice we're still in the trap shadow of something within the
 697        TB and do not generate the code to signal the exception; end the TB
 698        when an exception is forced to arrive, either by consumption of a
 699        register value or TRAPB or EXCB.  */
 700     TCGv_i32 exc = tcg_temp_new_i32();
 701     TCGv_i32 reg;
 702
 703 #if defined(CONFIG_SOFTFLOAT_INLINE)
 704     tcg_gen_ld8u_i32(exc, cpu_env,
 705                      offsetof(CPUAlphaState, fp_status.float_exception_flags));
 706 #else
 707     gen_helper_fp_exc_get(exc, cpu_env);
 708 #endif
 709
 710     if (ignore) {
 711         tcg_gen_andi_i32(exc, exc, ~ignore);
 712     }
 713
 714     /* ??? Pass in the regno of the destination so that the helper can
 715        set EXC_MASK, which contains a bitmask of destination registers
 716        that have caused arithmetic traps.  A simple userspace emulation
 717        does not require this.  We do need it for a guest kernel's entArith,
 718        or if we were to do something clever with imprecise exceptions.  */
 719     reg = tcg_const_i32(rc + 32);
 720
 721     if (fn11 & QUAL_S) {
 722         gen_helper_fp_exc_raise_s(cpu_env, exc, reg);
 723     } else {
 724         gen_helper_fp_exc_raise(cpu_env, exc, reg);
 725     }
 726
 727     tcg_temp_free_i32(reg);
 728     tcg_temp_free_i32(exc);
 729 }
 730
 731 static inline void gen_fp_exc_raise(int rc, int fn11)
 732 {
 733     gen_fp_exc_raise_ignore(rc, fn11, fn11 & QUAL_I ? 0 : float_flag_inexact);
 734 }
 735
 736 static void gen_fcvtlq(int rb, int rc)
 737 {
 738     if (unlikely(rc == 31)) {
 739         return;
 740     }
 741     if (unlikely(rb == 31)) {
 742         tcg_gen_movi_i64(cpu_fir[rc], 0);
 743     } else {
 744         TCGv tmp = tcg_temp_new();
 745
 746         /* The arithmetic right shift here, plus the sign-extended mask below
 747            yields a sign-extended result without an explicit ext32s_i64.  */
 748         tcg_gen_sari_i64(tmp, cpu_fir[rb], 32);
 749         tcg_gen_shri_i64(cpu_fir[rc], cpu_fir[rb], 29);
 750         tcg_gen_andi_i64(tmp, tmp, (int32_t)0xc0000000);
 751         tcg_gen_andi_i64(cpu_fir[rc], cpu_fir[rc], 0x3fffffff);
 752         tcg_gen_or_i64(cpu_fir[rc], cpu_fir[rc], tmp);
 753
 754         tcg_temp_free(tmp);
 755     }
 756 }
 757
 758 static void gen_fcvtql(int rb, int rc)
 759 {
 760     if (unlikely(rc == 31)) {
 761         return;
 762     }
 763     if (unlikely(rb == 31)) {
 764         tcg_gen_movi_i64(cpu_fir[rc], 0);
 765     } else {
 766         TCGv tmp = tcg_temp_new();
 767
 768         tcg_gen_andi_i64(tmp, cpu_fir[rb], 0xC0000000);
 769         tcg_gen_andi_i64(cpu_fir[rc], cpu_fir[rb], 0x3FFFFFFF);
 770         tcg_gen_shli_i64(tmp, tmp, 32);
 771         tcg_gen_shli_i64(cpu_fir[rc], cpu_fir[rc], 29);
 772         tcg_gen_or_i64(cpu_fir[rc], cpu_fir[rc], tmp);
 773
 774         tcg_temp_free(tmp);
 775     }
 776 }
 777
 778 static void gen_fcvtql_v(DisasContext *ctx, int rb, int rc)
 779 {
 780     if (rb != 31) {
 781         int lab = gen_new_label();
 782         TCGv tmp = tcg_temp_new();
 783
 784         tcg_gen_ext32s_i64(tmp, cpu_fir[rb]);
 785         tcg_gen_brcond_i64(TCG_COND_EQ, tmp, cpu_fir[rb], lab);
 786         gen_excp(ctx, EXCP_ARITH, EXC_M_IOV);
 787
 788         gen_set_label(lab);
 789     }
 790     gen_fcvtql(rb, rc);
 791 }
 792
 793 #define FARITH2(name)                                                   \
 794     static inline void glue(gen_f, name)(int rb, int rc)                \
 795     {                                                                   \
 796         if (unlikely(rc == 31)) {                                       \
 797             return;                                                     \
 798         }                                                               \
 799         if (rb != 31) {                                                 \
 800             gen_helper_ ## name(cpu_fir[rc], cpu_env, cpu_fir[rb]);     \
 801         } else {                                                        \
 802             TCGv tmp = tcg_const_i64(0);                                \
 803             gen_helper_ ## name(cpu_fir[rc], cpu_env, tmp);             \
 804             tcg_temp_free(tmp);                                         \
 805         }                                                               \
 806     }
 807
 808 /* ??? VAX instruction qualifiers ignored.  */
 809 FARITH2(sqrtf)
 810 FARITH2(sqrtg)
 811 FARITH2(cvtgf)
 812 FARITH2(cvtgq)
 813 FARITH2(cvtqf)
 814 FARITH2(cvtqg)
 815
 816 static void gen_ieee_arith2(DisasContext *ctx,
 817                             void (*helper)(TCGv, TCGv_ptr, TCGv),
 818                             int rb, int rc, int fn11)
 819 {
 820     TCGv vb;
 821
 822     /* ??? This is wrong: the instruction is not a nop, it still may
 823        raise exceptions.  */
 824     if (unlikely(rc == 31)) {
 825         return;
 826     }
 827
 828     gen_qual_roundmode(ctx, fn11);
 829     gen_qual_flushzero(ctx, fn11);
 830     gen_fp_exc_clear();
 831
 832     vb = gen_ieee_input(rb, fn11, 0);
 833     helper(cpu_fir[rc], cpu_env, vb);
 834     tcg_temp_free(vb);
 835
 836     gen_fp_exc_raise(rc, fn11);
 837 }
 838
 839 #define IEEE_ARITH2(name)                                       \
 840 static inline void glue(gen_f, name)(DisasContext *ctx,         \
 841                                      int rb, int rc, int fn11)  \
 842 {                                                               \
 843     gen_ieee_arith2(ctx, gen_helper_##name, rb, rc, fn11);      \
 844 }
 845 IEEE_ARITH2(sqrts)
 846 IEEE_ARITH2(sqrtt)
 847 IEEE_ARITH2(cvtst)
 848 IEEE_ARITH2(cvtts)
 849
 850 static void gen_fcvttq(DisasContext *ctx, int rb, int rc, int fn11)
 851 {
 852     TCGv vb;
 853     int ignore = 0;
 854
 855     /* ??? This is wrong: the instruction is not a nop, it still may
 856        raise exceptions.  */
 857     if (unlikely(rc == 31)) {
 858         return;
 859     }
 860
 861     /* No need to set flushzero, since we have an integer output.  */
 862     gen_fp_exc_clear();
 863     vb = gen_ieee_input(rb, fn11, 0);
 864
 865     /* Almost all integer conversions use cropped rounding, and most
 866        also do not have integer overflow enabled.  Special case that.  */
 867     switch (fn11) {
 868     case QUAL_RM_C:
 869         gen_helper_cvttq_c(cpu_fir[rc], cpu_env, vb);
 870         break;
 871     case QUAL_V | QUAL_RM_C:
 872     case QUAL_S | QUAL_V | QUAL_RM_C:
 873         ignore = float_flag_inexact;
 874         /* FALLTHRU */
 875     case QUAL_S | QUAL_V | QUAL_I | QUAL_RM_C:
 876         gen_helper_cvttq_svic(cpu_fir[rc], cpu_env, vb);
 877         break;
 878     default:
 879         gen_qual_roundmode(ctx, fn11);
 880         gen_helper_cvttq(cpu_fir[rc], cpu_env, vb);
 881         ignore |= (fn11 & QUAL_V ? 0 : float_flag_overflow);
 882         ignore |= (fn11 & QUAL_I ? 0 : float_flag_inexact);
 883         break;
 884     }
 885     tcg_temp_free(vb);
 886
 887     gen_fp_exc_raise_ignore(rc, fn11, ignore);
 888 }
 889
 890 static void gen_ieee_intcvt(DisasContext *ctx,
 891                             void (*helper)(TCGv, TCGv_ptr, TCGv),
 892                             int rb, int rc, int fn11)
 893 {
 894     TCGv vb;
 895
 896     /* ??? This is wrong: the instruction is not a nop, it still may
 897        raise exceptions.  */
 898     if (unlikely(rc == 31)) {
 899         return;
 900     }
 901
 902     gen_qual_roundmode(ctx, fn11);
 903
 904     if (rb == 31) {
 905         vb = tcg_const_i64(0);
 906     } else {
 907         vb = cpu_fir[rb];
 908     }
 909
 910     /* The only exception that can be raised by integer conversion
 911        is inexact.  Thus we only need to worry about exceptions when
 912        inexact handling is requested.  */
 913     if (fn11 & QUAL_I) {
 914         gen_fp_exc_clear();
 915         helper(cpu_fir[rc], cpu_env, vb);
 916         gen_fp_exc_raise(rc, fn11);
 917     } else {
 918         helper(cpu_fir[rc], cpu_env, vb);
 919     }
 920
 921     if (rb == 31) {
 922         tcg_temp_free(vb);
 923     }
 924 }
 925
 926 #define IEEE_INTCVT(name)                                       \
 927 static inline void glue(gen_f, name)(DisasContext *ctx,         \
 928                                      int rb, int rc, int fn11)  \
 929 {                                                               \
 930     gen_ieee_intcvt(ctx, gen_helper_##name, rb, rc, fn11);      \
 931 }
 932 IEEE_INTCVT(cvtqs)
 933 IEEE_INTCVT(cvtqt)
 934
 935 static void gen_cpys_internal(int ra, int rb, int rc, int inv_a, uint64_t mask)
 936 {
 937     TCGv va, vb, vmask;
 938     int za = 0, zb = 0;
 939
 940     if (unlikely(rc == 31)) {
 941         return;
 942     }
 943
 944     vmask = tcg_const_i64(mask);
 945
 946     TCGV_UNUSED_I64(va);
 947     if (ra == 31) {
 948         if (inv_a) {
 949             va = vmask;
 950         } else {
 951             za = 1;
 952         }
 953     } else {
 954         va = tcg_temp_new_i64();
 955         tcg_gen_mov_i64(va, cpu_fir[ra]);
 956         if (inv_a) {
 957             tcg_gen_andc_i64(va, vmask, va);
 958         } else {
 959             tcg_gen_and_i64(va, va, vmask);
 960         }
 961     }
 962
 963     TCGV_UNUSED_I64(vb);
 964     if (rb == 31) {
 965         zb = 1;
 966     } else {
 967         vb = tcg_temp_new_i64();
 968         tcg_gen_andc_i64(vb, cpu_fir[rb], vmask);
 969     }
 970
 971     switch (za << 1 | zb) {
 972     case 0 | 0:
 973         tcg_gen_or_i64(cpu_fir[rc], va, vb);
 974         break;
 975     case 0 | 1:
 976         tcg_gen_mov_i64(cpu_fir[rc], va);
 977         break;
 978     case 2 | 0:
 979         tcg_gen_mov_i64(cpu_fir[rc], vb);
 980         break;
 981     case 2 | 1:
 982         tcg_gen_movi_i64(cpu_fir[rc], 0);
 983         break;
 984     }
 985
 986     tcg_temp_free(vmask);
 987     if (ra != 31) {
 988         tcg_temp_free(va);
 989     }
 990     if (rb != 31) {
 991         tcg_temp_free(vb);
 992     }
 993 }
 994
 995 static inline void gen_fcpys(int ra, int rb, int rc)
 996 {
 997     gen_cpys_internal(ra, rb, rc, 0, 0x8000000000000000ULL);
 998 }
 999
1000 static inline void gen_fcpysn(int ra, int rb, int rc)
1001 {
1002     gen_cpys_internal(ra, rb, rc, 1, 0x8000000000000000ULL);
1003 }
1004
1005 static inline void gen_fcpyse(int ra, int rb, int rc)
1006 {
1007     gen_cpys_internal(ra, rb, rc, 0, 0xFFF0000000000000ULL);
1008 }
1009
1010 #define FARITH3(name)                                                   \
1011     static inline void glue(gen_f, name)(int ra, int rb, int rc)        \
1012     {                                                                   \
1013         TCGv va, vb;                                                    \
1014                                                                         \
1015         if (unlikely(rc == 31)) {                                       \
1016             return;                                                     \
1017         }                                                               \
1018         if (ra == 31) {                                                 \
1019             va = tcg_const_i64(0);                                      \
1020         } else {                                                        \
1021             va = cpu_fir[ra];                                           \
1022         }                                                               \
1023         if (rb == 31) {                                                 \
1024             vb = tcg_const_i64(0);                                      \
1025         } else {                                                        \
1026             vb = cpu_fir[rb];                                           \
1027         }                                                               \
1028                                                                         \
1029         gen_helper_ ## name(cpu_fir[rc], cpu_env, va, vb);              \
1030                                                                         \
1031         if (ra == 31) {                                                 \
1032             tcg_temp_free(va);                                          \
1033         }                                                               \
1034         if (rb == 31) {                                                 \
1035             tcg_temp_free(vb);                                          \
1036         }                                                               \
1037     }
1038
1039 /* ??? VAX instruction qualifiers ignored.  */
1040 FARITH3(addf)
1041 FARITH3(subf)
1042 FARITH3(mulf)
1043 FARITH3(divf)
1044 FARITH3(addg)
1045 FARITH3(subg)
1046 FARITH3(mulg)
1047 FARITH3(divg)
1048 FARITH3(cmpgeq)
1049 FARITH3(cmpglt)
1050 FARITH3(cmpgle)
1051
1052 static void gen_ieee_arith3(DisasContext *ctx,
1053                             void (*helper)(TCGv, TCGv_ptr, TCGv, TCGv),
1054                             int ra, int rb, int rc, int fn11)
1055 {
1056     TCGv va, vb;
1057
1058     /* ??? This is wrong: the instruction is not a nop, it still may
1059        raise exceptions.  */
1060     if (unlikely(rc == 31)) {
1061         return;
1062     }
1063
1064     gen_qual_roundmode(ctx, fn11);
1065     gen_qual_flushzero(ctx, fn11);
1066     gen_fp_exc_clear();
1067
1068     va = gen_ieee_input(ra, fn11, 0);
1069     vb = gen_ieee_input(rb, fn11, 0);
1070     helper(cpu_fir[rc], cpu_env, va, vb);
1071     tcg_temp_free(va);
1072     tcg_temp_free(vb);
1073
1074     gen_fp_exc_raise(rc, fn11);
1075 }
1076
1077 #define IEEE_ARITH3(name)                                               \
1078 static inline void glue(gen_f, name)(DisasContext *ctx,                 \
1079                                      int ra, int rb, int rc, int fn11)  \
1080 {                                                                       \
1081     gen_ieee_arith3(ctx, gen_helper_##name, ra, rb, rc, fn11);          \
1082 }
1083 IEEE_ARITH3(adds)
1084 IEEE_ARITH3(subs)
1085 IEEE_ARITH3(muls)
1086 IEEE_ARITH3(divs)
1087 IEEE_ARITH3(addt)
1088 IEEE_ARITH3(subt)
1089 IEEE_ARITH3(mult)
1090 IEEE_ARITH3(divt)
1091
1092 static void gen_ieee_compare(DisasContext *ctx,
1093                              void (*helper)(TCGv, TCGv_ptr, TCGv, TCGv),
1094                              int ra, int rb, int rc, int fn11)
1095 {
1096     TCGv va, vb;
1097
1098     /* ??? This is wrong: the instruction is not a nop, it still may
1099        raise exceptions.  */
1100     if (unlikely(rc == 31)) {
1101         return;
1102     }
1103
1104     gen_fp_exc_clear();
1105
1106     va = gen_ieee_input(ra, fn11, 1);
1107     vb = gen_ieee_input(rb, fn11, 1);
1108     helper(cpu_fir[rc], cpu_env, va, vb);
1109     tcg_temp_free(va);
1110     tcg_temp_free(vb);
1111
1112     gen_fp_exc_raise(rc, fn11);
1113 }
1114
1115 #define IEEE_CMP3(name)                                                 \
1116 static inline void glue(gen_f, name)(DisasContext *ctx,                 \
1117                                      int ra, int rb, int rc, int fn11)  \
1118 {                                                                       \
1119     gen_ieee_compare(ctx, gen_helper_##name, ra, rb, rc, fn11);         \
1120 }
1121 IEEE_CMP3(cmptun)
1122 IEEE_CMP3(cmpteq)
1123 IEEE_CMP3(cmptlt)
1124 IEEE_CMP3(cmptle)
1125
1126 static inline uint64_t zapnot_mask(uint8_t lit)
1127 {
1128     uint64_t mask = 0;
1129     int i;
1130
1131     for (i = 0; i < 8; ++i) {
1132         if ((lit >> i) & 1)
1133             mask |= 0xffull << (i * 8);
1134     }
1135     return mask;
1136 }
1137
1138 /* Implement zapnot with an immediate operand, which expands to some
1139    form of immediate AND.  This is a basic building block in the
1140    definition of many of the other byte manipulation instructions.  */
1141 static void gen_zapnoti(TCGv dest, TCGv src, uint8_t lit)
1142 {
1143     switch (lit) {
1144     case 0x00:
1145         tcg_gen_movi_i64(dest, 0);
1146         break;
1147     case 0x01:
1148         tcg_gen_ext8u_i64(dest, src);
1149         break;
1150     case 0x03:
1151         tcg_gen_ext16u_i64(dest, src);
1152         break;
1153     case 0x0f:
1154         tcg_gen_ext32u_i64(dest, src);
1155         break;
1156     case 0xff:
1157         tcg_gen_mov_i64(dest, src);
1158         break;
1159     default:
1160         tcg_gen_andi_i64 (dest, src, zapnot_mask (lit));
1161         break;
1162     }
1163 }
1164
1165 static inline void gen_zapnot(int ra, int rb, int rc, int islit, uint8_t lit)
1166 {
1167     if (unlikely(rc == 31))
1168         return;
1169     else if (unlikely(ra == 31))
1170         tcg_gen_movi_i64(cpu_ir[rc], 0);
1171     else if (islit)
1172         gen_zapnoti(cpu_ir[rc], cpu_ir[ra], lit);
1173     else
1174         gen_helper_zapnot (cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1175 }
1176
1177 static inline void gen_zap(int ra, int rb, int rc, int islit, uint8_t lit)
1178 {
1179     if (unlikely(rc == 31))
1180         return;
1181     else if (unlikely(ra == 31))
1182         tcg_gen_movi_i64(cpu_ir[rc], 0);
1183     else if (islit)
1184         gen_zapnoti(cpu_ir[rc], cpu_ir[ra], ~lit);
1185     else
1186         gen_helper_zap (cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1187 }
1188
1189
1190 /* EXTWH, EXTLH, EXTQH */
1191 static void gen_ext_h(int ra, int rb, int rc, int islit,
1192                       uint8_t lit, uint8_t byte_mask)
1193 {
1194     if (unlikely(rc == 31))
1195         return;
1196     else if (unlikely(ra == 31))
1197         tcg_gen_movi_i64(cpu_ir[rc], 0);
1198     else {
1199         if (islit) {
1200             lit = (64 - (lit & 7) * 8) & 0x3f;
1201             tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], lit);
1202         } else {
1203             TCGv tmp1 = tcg_temp_new();
1204             tcg_gen_andi_i64(tmp1, cpu_ir[rb], 7);
1205             tcg_gen_shli_i64(tmp1, tmp1, 3);
1206             tcg_gen_neg_i64(tmp1, tmp1);
1207             tcg_gen_andi_i64(tmp1, tmp1, 0x3f);
1208             tcg_gen_shl_i64(cpu_ir[rc], cpu_ir[ra], tmp1);
1209             tcg_temp_free(tmp1);
1210         }
1211         gen_zapnoti(cpu_ir[rc], cpu_ir[rc], byte_mask);
1212     }
1213 }
1214
1215 /* EXTBL, EXTWL, EXTLL, EXTQL */
1216 static void gen_ext_l(int ra, int rb, int rc, int islit,
1217                       uint8_t lit, uint8_t byte_mask)
1218 {
1219     if (unlikely(rc == 31))
1220         return;
1221     else if (unlikely(ra == 31))
1222         tcg_gen_movi_i64(cpu_ir[rc], 0);
1223     else {
1224         if (islit) {
1225             tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[ra], (lit & 7) * 8);
1226         } else {
1227             TCGv tmp = tcg_temp_new();
1228             tcg_gen_andi_i64(tmp, cpu_ir[rb], 7);
1229             tcg_gen_shli_i64(tmp, tmp, 3);
1230             tcg_gen_shr_i64(cpu_ir[rc], cpu_ir[ra], tmp);
1231             tcg_temp_free(tmp);
1232         }
1233         gen_zapnoti(cpu_ir[rc], cpu_ir[rc], byte_mask);
1234     }
1235 }
1236
1237 /* INSWH, INSLH, INSQH */
1238 static void gen_ins_h(int ra, int rb, int rc, int islit,
1239                       uint8_t lit, uint8_t byte_mask)
1240 {
1241     if (unlikely(rc == 31))
1242         return;
1243     else if (unlikely(ra == 31) || (islit && (lit & 7) == 0))
1244         tcg_gen_movi_i64(cpu_ir[rc], 0);
1245     else {
1246         TCGv tmp = tcg_temp_new();
1247
1248         /* The instruction description has us left-shift the byte mask
1249            and extract bits <15:8> and apply that zap at the end.  This
1250            is equivalent to simply performing the zap first and shifting
1251            afterward.  */
1252         gen_zapnoti (tmp, cpu_ir[ra], byte_mask);
1253
1254         if (islit) {
1255             /* Note that we have handled the lit==0 case above.  */
1256             tcg_gen_shri_i64 (cpu_ir[rc], tmp, 64 - (lit & 7) * 8);
1257         } else {
1258             TCGv shift = tcg_temp_new();
1259
1260             /* If (B & 7) == 0, we need to shift by 64 and leave a zero.
1261                Do this portably by splitting the shift into two parts:
1262                shift_count-1 and 1.  Arrange for the -1 by using
1263                ones-complement instead of twos-complement in the negation:
1264                ~((B & 7) * 8) & 63.  */
1265
1266             tcg_gen_andi_i64(shift, cpu_ir[rb], 7);
1267             tcg_gen_shli_i64(shift, shift, 3);
1268             tcg_gen_not_i64(shift, shift);
1269             tcg_gen_andi_i64(shift, shift, 0x3f);
1270
1271             tcg_gen_shr_i64(cpu_ir[rc], tmp, shift);
1272             tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[rc], 1);
1273             tcg_temp_free(shift);
1274         }
1275         tcg_temp_free(tmp);
1276     }
1277 }
1278
1279 /* INSBL, INSWL, INSLL, INSQL */
1280 static void gen_ins_l(int ra, int rb, int rc, int islit,
1281                       uint8_t lit, uint8_t byte_mask)
1282 {
1283     if (unlikely(rc == 31))
1284         return;
1285     else if (unlikely(ra == 31))
1286         tcg_gen_movi_i64(cpu_ir[rc], 0);
1287     else {
1288         TCGv tmp = tcg_temp_new();
1289
1290         /* The instruction description has us left-shift the byte mask
1291            the same number of byte slots as the data and apply the zap
1292            at the end.  This is equivalent to simply performing the zap
1293            first and shifting afterward.  */
1294         gen_zapnoti (tmp, cpu_ir[ra], byte_mask);
1295
1296         if (islit) {
1297             tcg_gen_shli_i64(cpu_ir[rc], tmp, (lit & 7) * 8);
1298         } else {
1299             TCGv shift = tcg_temp_new();
1300             tcg_gen_andi_i64(shift, cpu_ir[rb], 7);
1301             tcg_gen_shli_i64(shift, shift, 3);
1302             tcg_gen_shl_i64(cpu_ir[rc], tmp, shift);
1303             tcg_temp_free(shift);
1304         }
1305         tcg_temp_free(tmp);
1306     }
1307 }
1308
1309 /* MSKWH, MSKLH, MSKQH */
1310 static void gen_msk_h(int ra, int rb, int rc, int islit,
1311                       uint8_t lit, uint8_t byte_mask)
1312 {
1313     if (unlikely(rc == 31))
1314         return;
1315     else if (unlikely(ra == 31))
1316         tcg_gen_movi_i64(cpu_ir[rc], 0);
1317     else if (islit) {
1318         gen_zapnoti (cpu_ir[rc], cpu_ir[ra], ~((byte_mask << (lit & 7)) >> 8));
1319     } else {
1320         TCGv shift = tcg_temp_new();
1321         TCGv mask = tcg_temp_new();
1322
1323         /* The instruction description is as above, where the byte_mask
1324            is shifted left, and then we extract bits <15:8>.  This can be
1325            emulated with a right-shift on the expanded byte mask.  This
1326            requires extra care because for an input <2:0> == 0 we need a
1327            shift of 64 bits in order to generate a zero.  This is done by
1328            splitting the shift into two parts, the variable shift - 1
1329            followed by a constant 1 shift.  The code we expand below is
1330            equivalent to ~((B & 7) * 8) & 63.  */
1331
1332         tcg_gen_andi_i64(shift, cpu_ir[rb], 7);
1333         tcg_gen_shli_i64(shift, shift, 3);
1334         tcg_gen_not_i64(shift, shift);
1335         tcg_gen_andi_i64(shift, shift, 0x3f);
1336         tcg_gen_movi_i64(mask, zapnot_mask (byte_mask));
1337         tcg_gen_shr_i64(mask, mask, shift);
1338         tcg_gen_shri_i64(mask, mask, 1);
1339
1340         tcg_gen_andc_i64(cpu_ir[rc], cpu_ir[ra], mask);
1341
1342         tcg_temp_free(mask);
1343         tcg_temp_free(shift);
1344     }
1345 }
1346
1347 /* MSKBL, MSKWL, MSKLL, MSKQL */
1348 static void gen_msk_l(int ra, int rb, int rc, int islit,
1349                       uint8_t lit, uint8_t byte_mask)
1350 {
1351     if (unlikely(rc == 31))
1352         return;
1353     else if (unlikely(ra == 31))
1354         tcg_gen_movi_i64(cpu_ir[rc], 0);
1355     else if (islit) {
1356         gen_zapnoti (cpu_ir[rc], cpu_ir[ra], ~(byte_mask << (lit & 7)));
1357     } else {
1358         TCGv shift = tcg_temp_new();
1359         TCGv mask = tcg_temp_new();
1360
1361         tcg_gen_andi_i64(shift, cpu_ir[rb], 7);
1362         tcg_gen_shli_i64(shift, shift, 3);
1363         tcg_gen_movi_i64(mask, zapnot_mask (byte_mask));
1364         tcg_gen_shl_i64(mask, mask, shift);
1365
1366         tcg_gen_andc_i64(cpu_ir[rc], cpu_ir[ra], mask);
1367
1368         tcg_temp_free(mask);
1369         tcg_temp_free(shift);
1370     }
1371 }
1372
1373 /* Code to call arith3 helpers */
1374 #define ARITH3(name)                                                  \
1375 static inline void glue(gen_, name)(int ra, int rb, int rc, int islit,\
1376                                     uint8_t lit)                      \
1377 {                                                                     \
1378     if (unlikely(rc == 31))                                           \
1379         return;                                                       \
1380                                                                       \
1381     if (ra != 31) {                                                   \
1382         if (islit) {                                                  \
1383             TCGv tmp = tcg_const_i64(lit);                            \
1384             gen_helper_ ## name(cpu_ir[rc], cpu_ir[ra], tmp);         \
1385             tcg_temp_free(tmp);                                       \
1386         } else                                                        \
1387             gen_helper_ ## name (cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]); \
1388     } else {                                                          \
1389         TCGv tmp1 = tcg_const_i64(0);                                 \
1390         if (islit) {                                                  \
1391             TCGv tmp2 = tcg_const_i64(lit);                           \
1392             gen_helper_ ## name (cpu_ir[rc], tmp1, tmp2);             \
1393             tcg_temp_free(tmp2);                                      \
1394         } else                                                        \
1395             gen_helper_ ## name (cpu_ir[rc], tmp1, cpu_ir[rb]);       \
1396         tcg_temp_free(tmp1);                                          \
1397     }                                                                 \
1398 }
1399 ARITH3(umulh)
1400 ARITH3(cmpbge)
1401 ARITH3(minub8)
1402 ARITH3(minsb8)
1403 ARITH3(minuw4)
1404 ARITH3(minsw4)
1405 ARITH3(maxub8)
1406 ARITH3(maxsb8)
1407 ARITH3(maxuw4)
1408 ARITH3(maxsw4)
1409 ARITH3(perr)
1410
1411 /* Code to call arith3 helpers */
1412 #define ARITH3_EX(name)                                                 \
1413     static inline void glue(gen_, name)(int ra, int rb, int rc,         \
1414                                         int islit, uint8_t lit)         \
1415     {                                                                   \
1416         if (unlikely(rc == 31)) {                                       \
1417             return;                                                     \
1418         }                                                               \
1419         if (ra != 31) {                                                 \
1420             if (islit) {                                                \
1421                 TCGv tmp = tcg_const_i64(lit);                          \
1422                 gen_helper_ ## name(cpu_ir[rc], cpu_env,                \
1423                                     cpu_ir[ra], tmp);                   \
1424                 tcg_temp_free(tmp);                                     \
1425             } else {                                                    \
1426                 gen_helper_ ## name(cpu_ir[rc], cpu_env,                \
1427                                     cpu_ir[ra], cpu_ir[rb]);            \
1428             }                                                           \
1429         } else {                                                        \
1430             TCGv tmp1 = tcg_const_i64(0);                               \
1431             if (islit) {                                                \
1432                 TCGv tmp2 = tcg_const_i64(lit);                         \
1433                 gen_helper_ ## name(cpu_ir[rc], cpu_env, tmp1, tmp2);   \
1434                 tcg_temp_free(tmp2);                                    \
1435             } else {                                                    \
1436                 gen_helper_ ## name(cpu_ir[rc], cpu_env, tmp1, cpu_ir[rb]); \
1437             }                                                           \
1438             tcg_temp_free(tmp1);                                        \
1439         }                                                               \
1440     }
1441 ARITH3_EX(addlv)
1442 ARITH3_EX(sublv)
1443 ARITH3_EX(addqv)
1444 ARITH3_EX(subqv)
1445 ARITH3_EX(mullv)
1446 ARITH3_EX(mulqv)
1447
1448 #define MVIOP2(name)                                    \
1449 static inline void glue(gen_, name)(int rb, int rc)     \
1450 {                                                       \
1451     if (unlikely(rc == 31))                             \
1452         return;                                         \
1453     if (unlikely(rb == 31))                             \
1454         tcg_gen_movi_i64(cpu_ir[rc], 0);                \
1455     else                                                \
1456         gen_helper_ ## name (cpu_ir[rc], cpu_ir[rb]);   \
1457 }
1458 MVIOP2(pklb)
1459 MVIOP2(pkwb)
1460 MVIOP2(unpkbl)
1461 MVIOP2(unpkbw)
1462
1463 static void gen_cmp(TCGCond cond, int ra, int rb, int rc,
1464                     int islit, uint8_t lit)
1465 {
1466     TCGv va, vb;
1467
1468     if (unlikely(rc == 31)) {
1469         return;
1470     }
1471
1472     if (ra == 31) {
1473         va = tcg_const_i64(0);
1474     } else {
1475         va = cpu_ir[ra];
1476     }
1477     if (islit) {
1478         vb = tcg_const_i64(lit);
1479     } else {
1480         vb = cpu_ir[rb];
1481     }
1482
1483     tcg_gen_setcond_i64(cond, cpu_ir[rc], va, vb);
1484
1485     if (ra == 31) {
1486         tcg_temp_free(va);
1487     }
1488     if (islit) {
1489         tcg_temp_free(vb);
1490     }
1491 }
1492
1493 static void gen_rx(int ra, int set)
1494 {
1495     TCGv_i32 tmp;
1496
1497     if (ra != 31) {
1498         tcg_gen_ld8u_i64(cpu_ir[ra], cpu_env, offsetof(CPUAlphaState, intr_flag));
1499     }
1500
1501     tmp = tcg_const_i32(set);
1502     tcg_gen_st8_i32(tmp, cpu_env, offsetof(CPUAlphaState, intr_flag));
1503     tcg_temp_free_i32(tmp);
1504 }
1505
1506 static ExitStatus gen_call_pal(DisasContext *ctx, int palcode)
1507 {
1508     /* We're emulating OSF/1 PALcode.  Many of these are trivial access
1509        to internal cpu registers.  */
1510
1511     /* Unprivileged PAL call */
1512     if (palcode >= 0x80 && palcode < 0xC0) {
1513         switch (palcode) {
1514         case 0x86:
1515             /* IMB */
1516             /* No-op inside QEMU.  */
1517             break;
1518         case 0x9E:
1519             /* RDUNIQUE */
1520             tcg_gen_mov_i64(cpu_ir[IR_V0], cpu_unique);
1521             break;
1522         case 0x9F:
1523             /* WRUNIQUE */
1524             tcg_gen_mov_i64(cpu_unique, cpu_ir[IR_A0]);
1525             break;
1526         default:
1527             return gen_excp(ctx, EXCP_CALL_PAL, palcode & 0xbf);
1528         }
1529         return NO_EXIT;
1530     }
1531
1532 #ifndef CONFIG_USER_ONLY
1533     /* Privileged PAL code */
1534     if (palcode < 0x40 && (ctx->tb->flags & TB_FLAGS_USER_MODE) == 0) {
1535         switch (palcode) {
1536         case 0x01:
1537             /* CFLUSH */
1538             /* No-op inside QEMU.  */
1539             break;
1540         case 0x02:
1541             /* DRAINA */
1542             /* No-op inside QEMU.  */
1543             break;
1544         case 0x2D:
1545             /* WRVPTPTR */
1546             tcg_gen_st_i64(cpu_ir[IR_A0], cpu_env, offsetof(CPUAlphaState, vptptr));
1547             break;
1548         case 0x31:
1549             /* WRVAL */
1550             tcg_gen_mov_i64(cpu_sysval, cpu_ir[IR_A0]);
1551             break;
1552         case 0x32:
1553             /* RDVAL */
1554             tcg_gen_mov_i64(cpu_ir[IR_V0], cpu_sysval);
1555             break;
1556
1557         case 0x35: {
1558             /* SWPIPL */
1559             TCGv tmp;
1560
1561             /* Note that we already know we're in kernel mode, so we know
1562                that PS only contains the 3 IPL bits.  */
1563             tcg_gen_ld8u_i64(cpu_ir[IR_V0], cpu_env, offsetof(CPUAlphaState, ps));
1564
1565             /* But make sure and store only the 3 IPL bits from the user.  */
1566             tmp = tcg_temp_new();
1567             tcg_gen_andi_i64(tmp, cpu_ir[IR_A0], PS_INT_MASK);
1568             tcg_gen_st8_i64(tmp, cpu_env, offsetof(CPUAlphaState, ps));
1569             tcg_temp_free(tmp);
1570             break;
1571         }
1572
1573         case 0x36:
1574             /* RDPS */
1575             tcg_gen_ld8u_i64(cpu_ir[IR_V0], cpu_env, offsetof(CPUAlphaState, ps));
1576             break;
1577         case 0x38:
1578             /* WRUSP */
1579             tcg_gen_mov_i64(cpu_usp, cpu_ir[IR_A0]);
1580             break;
1581         case 0x3A:
1582             /* RDUSP */
1583             tcg_gen_mov_i64(cpu_ir[IR_V0], cpu_usp);
1584             break;
1585         case 0x3C:
1586             /* WHAMI */
1587             tcg_gen_ld32s_i64(cpu_ir[IR_V0], cpu_env,
1588                               offsetof(CPUAlphaState, cpu_index));
1589             break;
1590
1591         default:
1592             return gen_excp(ctx, EXCP_CALL_PAL, palcode & 0x3f);
1593         }
1594         return NO_EXIT;
1595     }
1596 #endif
1597
1598     return gen_invalid(ctx);
1599 }
1600
1601 #ifndef CONFIG_USER_ONLY
1602
1603 #define PR_BYTE         0x100000
1604 #define PR_LONG         0x200000
1605
1606 static int cpu_pr_data(int pr)
1607 {
1608     switch (pr) {
1609     case  0: return offsetof(CPUAlphaState, ps) | PR_BYTE;
1610     case  1: return offsetof(CPUAlphaState, fen) | PR_BYTE;
1611     case  2: return offsetof(CPUAlphaState, pcc_ofs) | PR_LONG;
1612     case  3: return offsetof(CPUAlphaState, trap_arg0);
1613     case  4: return offsetof(CPUAlphaState, trap_arg1);
1614     case  5: return offsetof(CPUAlphaState, trap_arg2);
1615     case  6: return offsetof(CPUAlphaState, exc_addr);
1616     case  7: return offsetof(CPUAlphaState, palbr);
1617     case  8: return offsetof(CPUAlphaState, ptbr);
1618     case  9: return offsetof(CPUAlphaState, vptptr);
1619     case 10: return offsetof(CPUAlphaState, unique);
1620     case 11: return offsetof(CPUAlphaState, sysval);
1621     case 12: return offsetof(CPUAlphaState, usp);
1622
1623     case 32 ... 39:
1624         return offsetof(CPUAlphaState, shadow[pr - 32]);
1625     case 40 ... 63:
1626         return offsetof(CPUAlphaState, scratch[pr - 40]);
1627
1628     case 251:
1629         return offsetof(CPUAlphaState, alarm_expire);
1630     }
1631     return 0;
1632 }
1633
1634 static ExitStatus gen_mfpr(int ra, int regno)
1635 {
1636     int data = cpu_pr_data(regno);
1637
1638     /* In our emulated PALcode, these processor registers have no
1639        side effects from reading.  */
1640     if (ra == 31) {
1641         return NO_EXIT;
1642     }
1643
1644     if (regno == 250) {
1645         /* WALL_TIME */
1646         if (use_icount) {
1647             gen_io_start();
1648             gen_helper_get_time(cpu_ir[ra]);
1649             gen_io_end();
1650             return EXIT_PC_STALE;
1651         } else {
1652             gen_helper_get_time(cpu_ir[ra]);
1653             return NO_EXIT;
1654         }
1655     }
1656
1657     /* The basic registers are data only, and unknown registers
1658        are read-zero, write-ignore.  */
1659     if (data == 0) {
1660         tcg_gen_movi_i64(cpu_ir[ra], 0);
1661     } else if (data & PR_BYTE) {
1662         tcg_gen_ld8u_i64(cpu_ir[ra], cpu_env, data & ~PR_BYTE);
1663     } else if (data & PR_LONG) {
1664         tcg_gen_ld32s_i64(cpu_ir[ra], cpu_env, data & ~PR_LONG);
1665     } else {
1666         tcg_gen_ld_i64(cpu_ir[ra], cpu_env, data);
1667     }
1668     return NO_EXIT;
1669 }
1670
1671 static ExitStatus gen_mtpr(DisasContext *ctx, int rb, int regno)
1672 {
1673     TCGv tmp;
1674     int data;
1675
1676     if (rb == 31) {
1677         tmp = tcg_const_i64(0);
1678     } else {
1679         tmp = cpu_ir[rb];
1680     }
1681
1682     switch (regno) {
1683     case 255:
1684         /* TBIA */
1685         gen_helper_tbia(cpu_env);
1686         break;
1687
1688     case 254:
1689         /* TBIS */
1690         gen_helper_tbis(cpu_env, tmp);
1691         break;
1692
1693     case 253:
1694         /* WAIT */
1695         tmp = tcg_const_i64(1);
1696         tcg_gen_st32_i64(tmp, cpu_env, offsetof(CPUAlphaState, halted));
1697         return gen_excp(ctx, EXCP_HLT, 0);
1698
1699     case 252:
1700         /* HALT */
1701         gen_helper_halt(tmp);
1702         return EXIT_PC_STALE;
1703
1704     case 251:
1705         /* ALARM */
1706         gen_helper_set_alarm(cpu_env, tmp);
1707         break;
1708
1709     default:
1710         /* The basic registers are data only, and unknown registers
1711            are read-zero, write-ignore.  */
1712         data = cpu_pr_data(regno);
1713         if (data != 0) {
1714             if (data & PR_BYTE) {
1715                 tcg_gen_st8_i64(tmp, cpu_env, data & ~PR_BYTE);
1716             } else if (data & PR_LONG) {
1717                 tcg_gen_st32_i64(tmp, cpu_env, data & ~PR_LONG);
1718             } else {
1719                 tcg_gen_st_i64(tmp, cpu_env, data);
1720             }
1721         }
1722         break;
1723     }
1724
1725     if (rb == 31) {
1726         tcg_temp_free(tmp);
1727     }
1728
1729     return NO_EXIT;
1730 }
1731 #endif /* !USER_ONLY*/
1732
1733 static ExitStatus translate_one(DisasContext *ctx, uint32_t insn)
1734 {
1735     uint32_t palcode;
1736     int32_t disp21, disp16;
1737 #ifndef CONFIG_USER_ONLY
1738     int32_t disp12;
1739 #endif
1740     uint16_t fn11;
1741     uint8_t opc, ra, rb, rc, fpfn, fn7, islit, real_islit;
1742     uint8_t lit;
1743     ExitStatus ret;
1744
1745     /* Decode all instruction fields */
1746     opc = insn >> 26;
1747     ra = (insn >> 21) & 0x1F;
1748     rb = (insn >> 16) & 0x1F;
1749     rc = insn & 0x1F;
1750     real_islit = islit = (insn >> 12) & 1;
1751     if (rb == 31 && !islit) {
1752         islit = 1;
1753         lit = 0;
1754     } else
1755         lit = (insn >> 13) & 0xFF;
1756     palcode = insn & 0x03FFFFFF;
1757     disp21 = ((int32_t)((insn & 0x001FFFFF) << 11)) >> 11;
1758     disp16 = (int16_t)(insn & 0x0000FFFF);
1759 #ifndef CONFIG_USER_ONLY
1760     disp12 = (int32_t)((insn & 0x00000FFF) << 20) >> 20;
1761 #endif
1762     fn11 = (insn >> 5) & 0x000007FF;
1763     fpfn = fn11 & 0x3F;
1764     fn7 = (insn >> 5) & 0x0000007F;
1765     LOG_DISAS("opc %02x ra %2d rb %2d rc %2d disp16 %6d\n",
1766               opc, ra, rb, rc, disp16);
1767
1768     ret = NO_EXIT;
1769     switch (opc) {
1770     case 0x00:
1771         /* CALL_PAL */
1772         ret = gen_call_pal(ctx, palcode);
1773         break;
1774     case 0x01:
1775         /* OPC01 */
1776         goto invalid_opc;
1777     case 0x02:
1778         /* OPC02 */
1779         goto invalid_opc;
1780     case 0x03:
1781         /* OPC03 */
1782         goto invalid_opc;
1783     case 0x04:
1784         /* OPC04 */
1785         goto invalid_opc;
1786     case 0x05:
1787         /* OPC05 */
1788         goto invalid_opc;
1789     case 0x06:
1790         /* OPC06 */
1791         goto invalid_opc;
1792     case 0x07:
1793         /* OPC07 */
1794         goto invalid_opc;
1795     case 0x08:
1796         /* LDA */
1797         if (likely(ra != 31)) {
1798             if (rb != 31)
1799                 tcg_gen_addi_i64(cpu_ir[ra], cpu_ir[rb], disp16);
1800             else
1801                 tcg_gen_movi_i64(cpu_ir[ra], disp16);
1802         }
1803         break;
1804     case 0x09:
1805         /* LDAH */
1806         if (likely(ra != 31)) {
1807             if (rb != 31)
1808                 tcg_gen_addi_i64(cpu_ir[ra], cpu_ir[rb], disp16 << 16);
1809             else
1810                 tcg_gen_movi_i64(cpu_ir[ra], disp16 << 16);
1811         }
1812         break;
1813     case 0x0A:
1814         /* LDBU */
1815         if (ctx->tb->flags & TB_FLAGS_AMASK_BWX) {
1816             gen_load_mem(ctx, &tcg_gen_qemu_ld8u, ra, rb, disp16, 0, 0);
1817             break;
1818         }
1819         goto invalid_opc;
1820     case 0x0B:
1821         /* LDQ_U */
1822         gen_load_mem(ctx, &tcg_gen_qemu_ld64, ra, rb, disp16, 0, 1);
1823         break;
1824     case 0x0C:
1825         /* LDWU */
1826         if (ctx->tb->flags & TB_FLAGS_AMASK_BWX) {
1827             gen_load_mem(ctx, &tcg_gen_qemu_ld16u, ra, rb, disp16, 0, 0);
1828             break;
1829         }
1830         goto invalid_opc;
1831     case 0x0D:
1832         /* STW */
1833         gen_store_mem(ctx, &tcg_gen_qemu_st16, ra, rb, disp16, 0, 0);
1834         break;
1835     case 0x0E:
1836         /* STB */
1837         gen_store_mem(ctx, &tcg_gen_qemu_st8, ra, rb, disp16, 0, 0);
1838         break;
1839     case 0x0F:
1840         /* STQ_U */
1841         gen_store_mem(ctx, &tcg_gen_qemu_st64, ra, rb, disp16, 0, 1);
1842         break;
1843     case 0x10:
1844         switch (fn7) {
1845         case 0x00:
1846             /* ADDL */
1847             if (likely(rc != 31)) {
1848                 if (ra != 31) {
1849                     if (islit) {
1850                         tcg_gen_addi_i64(cpu_ir[rc], cpu_ir[ra], lit);
1851                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1852                     } else {
1853                         tcg_gen_add_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1854                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1855                     }
1856                 } else {
1857                     if (islit)
1858                         tcg_gen_movi_i64(cpu_ir[rc], lit);
1859                     else
1860                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
1861                 }
1862             }
1863             break;
1864         case 0x02:
1865             /* S4ADDL */
1866             if (likely(rc != 31)) {
1867                 if (ra != 31) {
1868                     TCGv tmp = tcg_temp_new();
1869                     tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
1870                     if (islit)
1871                         tcg_gen_addi_i64(tmp, tmp, lit);
1872                     else
1873                         tcg_gen_add_i64(tmp, tmp, cpu_ir[rb]);
1874                     tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
1875                     tcg_temp_free(tmp);
1876                 } else {
1877                     if (islit)
1878                         tcg_gen_movi_i64(cpu_ir[rc], lit);
1879                     else
1880                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
1881                 }
1882             }
1883             break;
1884         case 0x09:
1885             /* SUBL */
1886             if (likely(rc != 31)) {
1887                 if (ra != 31) {
1888                     if (islit)
1889                         tcg_gen_subi_i64(cpu_ir[rc], cpu_ir[ra], lit);
1890                     else
1891                         tcg_gen_sub_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1892                     tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1893                 } else {
1894                     if (islit)
1895                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
1896                     else {
1897                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
1898                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1899                 }
1900             }
1901             break;
1902         case 0x0B:
1903             /* S4SUBL */
1904             if (likely(rc != 31)) {
1905                 if (ra != 31) {
1906                     TCGv tmp = tcg_temp_new();
1907                     tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
1908                     if (islit)
1909                         tcg_gen_subi_i64(tmp, tmp, lit);
1910                     else
1911                         tcg_gen_sub_i64(tmp, tmp, cpu_ir[rb]);
1912                     tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
1913                     tcg_temp_free(tmp);
1914                 } else {
1915                     if (islit)
1916                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
1917                     else {
1918                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
1919                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1920                     }
1921                 }
1922             }
1923             break;
1924         case 0x0F:
1925             /* CMPBGE */
1926             gen_cmpbge(ra, rb, rc, islit, lit);
1927             break;
1928         case 0x12:
1929             /* S8ADDL */
1930             if (likely(rc != 31)) {
1931                 if (ra != 31) {
1932                     TCGv tmp = tcg_temp_new();
1933                     tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
1934                     if (islit)
1935                         tcg_gen_addi_i64(tmp, tmp, lit);
1936                     else
1937                         tcg_gen_add_i64(tmp, tmp, cpu_ir[rb]);
1938                     tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
1939                     tcg_temp_free(tmp);
1940                 } else {
1941                     if (islit)
1942                         tcg_gen_movi_i64(cpu_ir[rc], lit);
1943                     else
1944                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
1945                 }
1946             }
1947             break;
1948         case 0x1B:
1949             /* S8SUBL */
1950             if (likely(rc != 31)) {
1951                 if (ra != 31) {
1952                     TCGv tmp = tcg_temp_new();
1953                     tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
1954                     if (islit)
1955                         tcg_gen_subi_i64(tmp, tmp, lit);
1956                     else
1957                        tcg_gen_sub_i64(tmp, tmp, cpu_ir[rb]);
1958                     tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
1959                     tcg_temp_free(tmp);
1960                 } else {
1961                     if (islit)
1962                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
1963                     else
1964                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
1965                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1966                     }
1967                 }
1968             }
1969             break;
1970         case 0x1D:
1971             /* CMPULT */
1972             gen_cmp(TCG_COND_LTU, ra, rb, rc, islit, lit);
1973             break;
1974         case 0x20:
1975             /* ADDQ */
1976             if (likely(rc != 31)) {
1977                 if (ra != 31) {
1978                     if (islit)
1979                         tcg_gen_addi_i64(cpu_ir[rc], cpu_ir[ra], lit);
1980                     else
1981                         tcg_gen_add_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1982                 } else {
1983                     if (islit)
1984                         tcg_gen_movi_i64(cpu_ir[rc], lit);
1985                     else
1986                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
1987                 }
1988             }
1989             break;
1990         case 0x22:
1991             /* S4ADDQ */
1992             if (likely(rc != 31)) {
1993                 if (ra != 31) {
1994                     TCGv tmp = tcg_temp_new();
1995                     tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
1996                     if (islit)
1997                         tcg_gen_addi_i64(cpu_ir[rc], tmp, lit);
1998                     else
1999                         tcg_gen_add_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
2000                     tcg_temp_free(tmp);
2001                 } else {
2002                     if (islit)
2003                         tcg_gen_movi_i64(cpu_ir[rc], lit);
2004                     else
2005                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
2006                 }
2007             }
2008             break;
2009         case 0x29:
2010             /* SUBQ */
2011             if (likely(rc != 31)) {
2012                 if (ra != 31) {
2013                     if (islit)
2014                         tcg_gen_subi_i64(cpu_ir[rc], cpu_ir[ra], lit);
2015                     else
2016                         tcg_gen_sub_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2017                 } else {
2018                     if (islit)
2019                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
2020                     else
2021                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
2022                 }
2023             }
2024             break;
2025         case 0x2B:
2026             /* S4SUBQ */
2027             if (likely(rc != 31)) {
2028                 if (ra != 31) {
2029                     TCGv tmp = tcg_temp_new();
2030                     tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
2031                     if (islit)
2032                         tcg_gen_subi_i64(cpu_ir[rc], tmp, lit);
2033                     else
2034                         tcg_gen_sub_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
2035                     tcg_temp_free(tmp);
2036                 } else {
2037                     if (islit)
2038                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
2039                     else
2040                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
2041                 }
2042             }
2043             break;
2044         case 0x2D:
2045             /* CMPEQ */
2046             gen_cmp(TCG_COND_EQ, ra, rb, rc, islit, lit);
2047             break;
2048         case 0x32:
2049             /* S8ADDQ */
2050             if (likely(rc != 31)) {
2051                 if (ra != 31) {
2052                     TCGv tmp = tcg_temp_new();
2053                     tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
2054                     if (islit)
2055                         tcg_gen_addi_i64(cpu_ir[rc], tmp, lit);
2056                     else
2057                         tcg_gen_add_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
2058                     tcg_temp_free(tmp);
2059                 } else {
2060                     if (islit)
2061                         tcg_gen_movi_i64(cpu_ir[rc], lit);
2062                     else
2063                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
2064                 }
2065             }
2066             break;
2067         case 0x3B:
2068             /* S8SUBQ */
2069             if (likely(rc != 31)) {
2070                 if (ra != 31) {
2071                     TCGv tmp = tcg_temp_new();
2072                     tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
2073                     if (islit)
2074                         tcg_gen_subi_i64(cpu_ir[rc], tmp, lit);
2075                     else
2076                         tcg_gen_sub_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
2077                     tcg_temp_free(tmp);
2078                 } else {
2079                     if (islit)
2080                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
2081                     else
2082                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
2083                 }
2084             }
2085             break;
2086         case 0x3D:
2087             /* CMPULE */
2088             gen_cmp(TCG_COND_LEU, ra, rb, rc, islit, lit);
2089             break;
2090         case 0x40:
2091             /* ADDL/V */
2092             gen_addlv(ra, rb, rc, islit, lit);
2093             break;
2094         case 0x49:
2095             /* SUBL/V */
2096             gen_sublv(ra, rb, rc, islit, lit);
2097             break;
2098         case 0x4D:
2099             /* CMPLT */
2100             gen_cmp(TCG_COND_LT, ra, rb, rc, islit, lit);
2101             break;
2102         case 0x60:
2103             /* ADDQ/V */
2104             gen_addqv(ra, rb, rc, islit, lit);
2105             break;
2106         case 0x69:
2107             /* SUBQ/V */
2108             gen_subqv(ra, rb, rc, islit, lit);
2109             break;
2110         case 0x6D:
2111             /* CMPLE */
2112             gen_cmp(TCG_COND_LE, ra, rb, rc, islit, lit);
2113             break;
2114         default:
2115             goto invalid_opc;
2116         }
2117         break;
2118     case 0x11:
2119         switch (fn7) {
2120         case 0x00:
2121             /* AND */
2122             if (likely(rc != 31)) {
2123                 if (ra == 31)
2124                     tcg_gen_movi_i64(cpu_ir[rc], 0);
2125                 else if (islit)
2126                     tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[ra], lit);
2127                 else
2128                     tcg_gen_and_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2129             }
2130             break;
2131         case 0x08:
2132             /* BIC */
2133             if (likely(rc != 31)) {
2134                 if (ra != 31) {
2135                     if (islit)
2136                         tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
2137                     else
2138                         tcg_gen_andc_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2139                 } else
2140                     tcg_gen_movi_i64(cpu_ir[rc], 0);
2141             }
2142             break;
2143         case 0x14:
2144             /* CMOVLBS */
2145             gen_cmov(TCG_COND_NE, ra, rb, rc, islit, lit, 1);
2146             break;
2147         case 0x16:
2148             /* CMOVLBC */
2149             gen_cmov(TCG_COND_EQ, ra, rb, rc, islit, lit, 1);
2150             break;
2151         case 0x20:
2152             /* BIS */
2153             if (likely(rc != 31)) {
2154                 if (ra != 31) {
2155                     if (islit)
2156                         tcg_gen_ori_i64(cpu_ir[rc], cpu_ir[ra], lit);
2157                     else
2158                         tcg_gen_or_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2159                 } else {
2160                     if (islit)
2161                         tcg_gen_movi_i64(cpu_ir[rc], lit);
2162                     else
2163                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
2164                 }
2165             }
2166             break;
2167         case 0x24:
2168             /* CMOVEQ */
2169             gen_cmov(TCG_COND_EQ, ra, rb, rc, islit, lit, 0);
2170             break;
2171         case 0x26:
2172             /* CMOVNE */
2173             gen_cmov(TCG_COND_NE, ra, rb, rc, islit, lit, 0);
2174             break;
2175         case 0x28:
2176             /* ORNOT */
2177             if (likely(rc != 31)) {
2178                 if (ra != 31) {
2179                     if (islit)
2180                         tcg_gen_ori_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
2181                     else
2182                         tcg_gen_orc_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2183                 } else {
2184                     if (islit)
2185                         tcg_gen_movi_i64(cpu_ir[rc], ~lit);
2186                     else
2187                         tcg_gen_not_i64(cpu_ir[rc], cpu_ir[rb]);
2188                 }
2189             }
2190             break;
2191         case 0x40:
2192             /* XOR */
2193             if (likely(rc != 31)) {
2194                 if (ra != 31) {
2195                     if (islit)
2196                         tcg_gen_xori_i64(cpu_ir[rc], cpu_ir[ra], lit);
2197                     else
2198                         tcg_gen_xor_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2199                 } else {
2200                     if (islit)
2201                         tcg_gen_movi_i64(cpu_ir[rc], lit);
2202                     else
2203                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
2204                 }
2205             }
2206             break;
2207         case 0x44:
2208             /* CMOVLT */
2209             gen_cmov(TCG_COND_LT, ra, rb, rc, islit, lit, 0);
2210             break;
2211         case 0x46:
2212             /* CMOVGE */
2213             gen_cmov(TCG_COND_GE, ra, rb, rc, islit, lit, 0);
2214             break;
2215         case 0x48:
2216             /* EQV */
2217             if (likely(rc != 31)) {
2218                 if (ra != 31) {
2219                     if (islit)
2220                         tcg_gen_xori_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
2221                     else
2222                         tcg_gen_eqv_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2223                 } else {
2224                     if (islit)
2225                         tcg_gen_movi_i64(cpu_ir[rc], ~lit);
2226                     else
2227                         tcg_gen_not_i64(cpu_ir[rc], cpu_ir[rb]);
2228                 }
2229             }
2230             break;
2231         case 0x61:
2232             /* AMASK */
2233             if (likely(rc != 31)) {
2234                 uint64_t amask = ctx->tb->flags >> TB_FLAGS_AMASK_SHIFT;
2235
2236                 if (islit) {
2237                     tcg_gen_movi_i64(cpu_ir[rc], lit & ~amask);
2238                 } else {
2239                     tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[rb], ~amask);
2240                 }
2241             }
2242             break;
2243         case 0x64:
2244             /* CMOVLE */
2245             gen_cmov(TCG_COND_LE, ra, rb, rc, islit, lit, 0);
2246             break;
2247         case 0x66:
2248             /* CMOVGT */
2249             gen_cmov(TCG_COND_GT, ra, rb, rc, islit, lit, 0);
2250             break;
2251         case 0x6C:
2252             /* IMPLVER */
2253             if (rc != 31)
2254                 tcg_gen_movi_i64(cpu_ir[rc], ctx->env->implver);
2255             break;
2256         default:
2257             goto invalid_opc;
2258         }
2259         break;
2260     case 0x12:
2261         switch (fn7) {
2262         case 0x02:
2263             /* MSKBL */
2264             gen_msk_l(ra, rb, rc, islit, lit, 0x01);
2265             break;
2266         case 0x06:
2267             /* EXTBL */
2268             gen_ext_l(ra, rb, rc, islit, lit, 0x01);
2269             break;
2270         case 0x0B:
2271             /* INSBL */
2272             gen_ins_l(ra, rb, rc, islit, lit, 0x01);
2273             break;
2274         case 0x12:
2275             /* MSKWL */
2276             gen_msk_l(ra, rb, rc, islit, lit, 0x03);
2277             break;
2278         case 0x16:
2279             /* EXTWL */
2280             gen_ext_l(ra, rb, rc, islit, lit, 0x03);
2281             break;
2282         case 0x1B:
2283             /* INSWL */
2284             gen_ins_l(ra, rb, rc, islit, lit, 0x03);
2285             break;
2286         case 0x22:
2287             /* MSKLL */
2288             gen_msk_l(ra, rb, rc, islit, lit, 0x0f);
2289             break;
2290         case 0x26:
2291             /* EXTLL */
2292             gen_ext_l(ra, rb, rc, islit, lit, 0x0f);
2293             break;
2294         case 0x2B:
2295             /* INSLL */
2296             gen_ins_l(ra, rb, rc, islit, lit, 0x0f);
2297             break;
2298         case 0x30:
2299             /* ZAP */
2300             gen_zap(ra, rb, rc, islit, lit);
2301             break;
2302         case 0x31:
2303             /* ZAPNOT */
2304             gen_zapnot(ra, rb, rc, islit, lit);
2305             break;
2306         case 0x32:
2307             /* MSKQL */
2308             gen_msk_l(ra, rb, rc, islit, lit, 0xff);
2309             break;
2310         case 0x34:
2311             /* SRL */
2312             if (likely(rc != 31)) {
2313                 if (ra != 31) {
2314                     if (islit)
2315                         tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
2316                     else {
2317                         TCGv shift = tcg_temp_new();
2318                         tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
2319                         tcg_gen_shr_i64(cpu_ir[rc], cpu_ir[ra], shift);
2320                         tcg_temp_free(shift);
2321                     }
2322                 } else
2323                     tcg_gen_movi_i64(cpu_ir[rc], 0);
2324             }
2325             break;
2326         case 0x36:
2327             /* EXTQL */
2328             gen_ext_l(ra, rb, rc, islit, lit, 0xff);
2329             break;
2330         case 0x39:
2331             /* SLL */
2332             if (likely(rc != 31)) {
2333                 if (ra != 31) {
2334                     if (islit)
2335                         tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
2336                     else {
2337                         TCGv shift = tcg_temp_new();
2338                         tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
2339                         tcg_gen_shl_i64(cpu_ir[rc], cpu_ir[ra], shift);
2340                         tcg_temp_free(shift);
2341                     }
2342                 } else
2343                     tcg_gen_movi_i64(cpu_ir[rc], 0);
2344             }
2345             break;
2346         case 0x3B:
2347             /* INSQL */
2348             gen_ins_l(ra, rb, rc, islit, lit, 0xff);
2349             break;
2350         case 0x3C:
2351             /* SRA */
2352             if (likely(rc != 31)) {
2353                 if (ra != 31) {
2354                     if (islit)
2355                         tcg_gen_sari_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
2356                     else {
2357                         TCGv shift = tcg_temp_new();
2358                         tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
2359                         tcg_gen_sar_i64(cpu_ir[rc], cpu_ir[ra], shift);
2360                         tcg_temp_free(shift);
2361                     }
2362                 } else
2363                     tcg_gen_movi_i64(cpu_ir[rc], 0);
2364             }
2365             break;
2366         case 0x52:
2367             /* MSKWH */
2368             gen_msk_h(ra, rb, rc, islit, lit, 0x03);
2369             break;
2370         case 0x57:
2371             /* INSWH */
2372             gen_ins_h(ra, rb, rc, islit, lit, 0x03);
2373             break;
2374         case 0x5A:
2375             /* EXTWH */
2376             gen_ext_h(ra, rb, rc, islit, lit, 0x03);
2377             break;
2378         case 0x62:
2379             /* MSKLH */
2380             gen_msk_h(ra, rb, rc, islit, lit, 0x0f);
2381             break;
2382         case 0x67:
2383             /* INSLH */
2384             gen_ins_h(ra, rb, rc, islit, lit, 0x0f);
2385             break;
2386         case 0x6A:
2387             /* EXTLH */
2388             gen_ext_h(ra, rb, rc, islit, lit, 0x0f);
2389             break;
2390         case 0x72:
2391             /* MSKQH */
2392             gen_msk_h(ra, rb, rc, islit, lit, 0xff);
2393             break;
2394         case 0x77:
2395             /* INSQH */
2396             gen_ins_h(ra, rb, rc, islit, lit, 0xff);
2397             break;
2398         case 0x7A:
2399             /* EXTQH */
2400             gen_ext_h(ra, rb, rc, islit, lit, 0xff);
2401             break;
2402         default:
2403             goto invalid_opc;
2404         }
2405         break;
2406     case 0x13:
2407         switch (fn7) {
2408         case 0x00:
2409             /* MULL */
2410             if (likely(rc != 31)) {
2411                 if (ra == 31)
2412                     tcg_gen_movi_i64(cpu_ir[rc], 0);
2413                 else {
2414                     if (islit)
2415                         tcg_gen_muli_i64(cpu_ir[rc], cpu_ir[ra], lit);
2416                     else
2417                         tcg_gen_mul_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2418                     tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
2419                 }
2420             }
2421             break;
2422         case 0x20:
2423             /* MULQ */
2424             if (likely(rc != 31)) {
2425                 if (ra == 31)
2426                     tcg_gen_movi_i64(cpu_ir[rc], 0);
2427                 else if (islit)
2428                     tcg_gen_muli_i64(cpu_ir[rc], cpu_ir[ra], lit);
2429                 else
2430                     tcg_gen_mul_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
2431             }
2432             break;
2433         case 0x30:
2434             /* UMULH */
2435             gen_umulh(ra, rb, rc, islit, lit);
2436             break;
2437         case 0x40:
2438             /* MULL/V */
2439             gen_mullv(ra, rb, rc, islit, lit);
2440             break;
2441         case 0x60:
2442             /* MULQ/V */
2443             gen_mulqv(ra, rb, rc, islit, lit);
2444             break;
2445         default:
2446             goto invalid_opc;
2447         }
2448         break;
2449     case 0x14:
2450         switch (fpfn) { /* fn11 & 0x3F */
2451         case 0x04:
2452             /* ITOFS */
2453             if ((ctx->tb->flags & TB_FLAGS_AMASK_FIX) == 0) {
2454                 goto invalid_opc;
2455             }
2456             if (likely(rc != 31)) {
2457                 if (ra != 31) {
2458                     TCGv_i32 tmp = tcg_temp_new_i32();
2459                     tcg_gen_trunc_i64_i32(tmp, cpu_ir[ra]);
2460                     gen_helper_memory_to_s(cpu_fir[rc], tmp);
2461                     tcg_temp_free_i32(tmp);
2462                 } else
2463                     tcg_gen_movi_i64(cpu_fir[rc], 0);
2464             }
2465             break;
2466         case 0x0A:
2467             /* SQRTF */
2468             if (ctx->tb->flags & TB_FLAGS_AMASK_FIX) {
2469                 gen_fsqrtf(rb, rc);
2470                 break;
2471             }
2472             goto invalid_opc;
2473         case 0x0B:
2474             /* SQRTS */
2475             if (ctx->tb->flags & TB_FLAGS_AMASK_FIX) {
2476                 gen_fsqrts(ctx, rb, rc, fn11);
2477                 break;
2478             }
2479             goto invalid_opc;
2480         case 0x14:
2481             /* ITOFF */
2482             if ((ctx->tb->flags & TB_FLAGS_AMASK_FIX) == 0) {
2483                 goto invalid_opc;
2484             }
2485             if (likely(rc != 31)) {
2486                 if (ra != 31) {
2487                     TCGv_i32 tmp = tcg_temp_new_i32();
2488                     tcg_gen_trunc_i64_i32(tmp, cpu_ir[ra]);
2489                     gen_helper_memory_to_f(cpu_fir[rc], tmp);
2490                     tcg_temp_free_i32(tmp);
2491                 } else
2492                     tcg_gen_movi_i64(cpu_fir[rc], 0);
2493             }
2494             break;
2495         case 0x24:
2496             /* ITOFT */
2497             if ((ctx->tb->flags & TB_FLAGS_AMASK_FIX) == 0) {
2498                 goto invalid_opc;
2499             }
2500             if (likely(rc != 31)) {
2501                 if (ra != 31)
2502                     tcg_gen_mov_i64(cpu_fir[rc], cpu_ir[ra]);
2503                 else
2504                     tcg_gen_movi_i64(cpu_fir[rc], 0);
2505             }
2506             break;
2507         case 0x2A:
2508             /* SQRTG */
2509             if (ctx->tb->flags & TB_FLAGS_AMASK_FIX) {
2510                 gen_fsqrtg(rb, rc);
2511                 break;
2512             }
2513             goto invalid_opc;
2514         case 0x02B:
2515             /* SQRTT */
2516             if (ctx->tb->flags & TB_FLAGS_AMASK_FIX) {
2517                 gen_fsqrtt(ctx, rb, rc, fn11);
2518                 break;
2519             }
2520             goto invalid_opc;
2521         default:
2522             goto invalid_opc;
2523         }
2524         break;
2525     case 0x15:
2526         /* VAX floating point */
2527         /* XXX: rounding mode and trap are ignored (!) */
2528         switch (fpfn) { /* fn11 & 0x3F */
2529         case 0x00:
2530             /* ADDF */
2531             gen_faddf(ra, rb, rc);
2532             break;
2533         case 0x01:
2534             /* SUBF */
2535             gen_fsubf(ra, rb, rc);
2536             break;
2537         case 0x02:
2538             /* MULF */
2539             gen_fmulf(ra, rb, rc);
2540             break;
2541         case 0x03:
2542             /* DIVF */
2543             gen_fdivf(ra, rb, rc);
2544             break;
2545         case 0x1E:
2546             /* CVTDG */
2547 #if 0 // TODO
2548             gen_fcvtdg(rb, rc);
2549 #else
2550             goto invalid_opc;
2551 #endif
2552             break;
2553         case 0x20:
2554             /* ADDG */
2555             gen_faddg(ra, rb, rc);
2556             break;
2557         case 0x21:
2558             /* SUBG */
2559             gen_fsubg(ra, rb, rc);
2560             break;
2561         case 0x22:
2562             /* MULG */
2563             gen_fmulg(ra, rb, rc);
2564             break;
2565         case 0x23:
2566             /* DIVG */
2567             gen_fdivg(ra, rb, rc);
2568             break;
2569         case 0x25:
2570             /* CMPGEQ */
2571             gen_fcmpgeq(ra, rb, rc);
2572             break;
2573         case 0x26:
2574             /* CMPGLT */
2575             gen_fcmpglt(ra, rb, rc);
2576             break;
2577         case 0x27:
2578             /* CMPGLE */
2579             gen_fcmpgle(ra, rb, rc);
2580             break;
2581         case 0x2C:
2582             /* CVTGF */
2583             gen_fcvtgf(rb, rc);
2584             break;
2585         case 0x2D:
2586             /* CVTGD */
2587 #if 0 // TODO
2588             gen_fcvtgd(rb, rc);
2589 #else
2590             goto invalid_opc;
2591 #endif
2592             break;
2593         case 0x2F:
2594             /* CVTGQ */
2595             gen_fcvtgq(rb, rc);
2596             break;
2597         case 0x3C:
2598             /* CVTQF */
2599             gen_fcvtqf(rb, rc);
2600             break;
2601         case 0x3E:
2602             /* CVTQG */
2603             gen_fcvtqg(rb, rc);
2604             break;
2605         default:
2606             goto invalid_opc;
2607         }
2608         break;
2609     case 0x16:
2610         /* IEEE floating-point */
2611         switch (fpfn) { /* fn11 & 0x3F */
2612         case 0x00:
2613             /* ADDS */
2614             gen_fadds(ctx, ra, rb, rc, fn11);
2615             break;
2616         case 0x01:
2617             /* SUBS */
2618             gen_fsubs(ctx, ra, rb, rc, fn11);
2619             break;
2620         case 0x02:
2621             /* MULS */
2622             gen_fmuls(ctx, ra, rb, rc, fn11);
2623             break;
2624         case 0x03:
2625             /* DIVS */
2626             gen_fdivs(ctx, ra, rb, rc, fn11);
2627             break;
2628         case 0x20:
2629             /* ADDT */
2630             gen_faddt(ctx, ra, rb, rc, fn11);
2631             break;
2632         case 0x21:
2633             /* SUBT */
2634             gen_fsubt(ctx, ra, rb, rc, fn11);
2635             break;
2636         case 0x22:
2637             /* MULT */
2638             gen_fmult(ctx, ra, rb, rc, fn11);
2639             break;
2640         case 0x23:
2641             /* DIVT */
2642             gen_fdivt(ctx, ra, rb, rc, fn11);
2643             break;
2644         case 0x24:
2645             /* CMPTUN */
2646             gen_fcmptun(ctx, ra, rb, rc, fn11);
2647             break;
2648         case 0x25:
2649             /* CMPTEQ */
2650             gen_fcmpteq(ctx, ra, rb, rc, fn11);
2651             break;
2652         case 0x26:
2653             /* CMPTLT */
2654             gen_fcmptlt(ctx, ra, rb, rc, fn11);
2655             break;
2656         case 0x27:
2657             /* CMPTLE */
2658             gen_fcmptle(ctx, ra, rb, rc, fn11);
2659             break;
2660         case 0x2C:
2661             if (fn11 == 0x2AC || fn11 == 0x6AC) {
2662                 /* CVTST */
2663                 gen_fcvtst(ctx, rb, rc, fn11);
2664             } else {
2665                 /* CVTTS */
2666                 gen_fcvtts(ctx, rb, rc, fn11);
2667             }
2668             break;
2669         case 0x2F:
2670             /* CVTTQ */
2671             gen_fcvttq(ctx, rb, rc, fn11);
2672             break;
2673         case 0x3C:
2674             /* CVTQS */
2675             gen_fcvtqs(ctx, rb, rc, fn11);
2676             break;
2677         case 0x3E:
2678             /* CVTQT */
2679             gen_fcvtqt(ctx, rb, rc, fn11);
2680             break;
2681         default:
2682             goto invalid_opc;
2683         }
2684         break;
2685     case 0x17:
2686         switch (fn11) {
2687         case 0x010:
2688             /* CVTLQ */
2689             gen_fcvtlq(rb, rc);
2690             break;
2691         case 0x020:
2692             if (likely(rc != 31)) {
2693                 if (ra == rb) {
2694                     /* FMOV */
2695                     if (ra == 31)
2696                         tcg_gen_movi_i64(cpu_fir[rc], 0);
2697                     else
2698                         tcg_gen_mov_i64(cpu_fir[rc], cpu_fir[ra]);
2699                 } else {
2700                     /* CPYS */
2701                     gen_fcpys(ra, rb, rc);
2702                 }
2703             }
2704             break;
2705         case 0x021:
2706             /* CPYSN */
2707             gen_fcpysn(ra, rb, rc);
2708             break;
2709         case 0x022:
2710             /* CPYSE */
2711             gen_fcpyse(ra, rb, rc);
2712             break;
2713         case 0x024:
2714             /* MT_FPCR */
2715             if (likely(ra != 31))
2716                 gen_helper_store_fpcr(cpu_env, cpu_fir[ra]);
2717             else {
2718                 TCGv tmp = tcg_const_i64(0);
2719                 gen_helper_store_fpcr(cpu_env, tmp);
2720                 tcg_temp_free(tmp);
2721             }
2722             break;
2723         case 0x025:
2724             /* MF_FPCR */
2725             if (likely(ra != 31))
2726                 gen_helper_load_fpcr(cpu_fir[ra], cpu_env);
2727             break;
2728         case 0x02A:
2729             /* FCMOVEQ */
2730             gen_fcmov(TCG_COND_EQ, ra, rb, rc);
2731             break;
2732         case 0x02B:
2733             /* FCMOVNE */
2734             gen_fcmov(TCG_COND_NE, ra, rb, rc);
2735             break;
2736         case 0x02C:
2737             /* FCMOVLT */
2738             gen_fcmov(TCG_COND_LT, ra, rb, rc);
2739             break;
2740         case 0x02D:
2741             /* FCMOVGE */
2742             gen_fcmov(TCG_COND_GE, ra, rb, rc);
2743             break;
2744         case 0x02E:
2745             /* FCMOVLE */
2746             gen_fcmov(TCG_COND_LE, ra, rb, rc);
2747             break;
2748         case 0x02F:
2749             /* FCMOVGT */
2750             gen_fcmov(TCG_COND_GT, ra, rb, rc);
2751             break;
2752         case 0x030:
2753             /* CVTQL */
2754             gen_fcvtql(rb, rc);
2755             break;
2756         case 0x130:
2757             /* CVTQL/V */
2758         case 0x530:
2759             /* CVTQL/SV */
2760             /* ??? I'm pretty sure there's nothing that /sv needs to do that
2761                /v doesn't do.  The only thing I can think is that /sv is a
2762                valid instruction merely for completeness in the ISA.  */
2763             gen_fcvtql_v(ctx, rb, rc);
2764             break;
2765         default:
2766             goto invalid_opc;
2767         }
2768         break;
2769     case 0x18:
2770         switch ((uint16_t)disp16) {
2771         case 0x0000:
2772             /* TRAPB */
2773             /* No-op.  */
2774             break;
2775         case 0x0400:
2776             /* EXCB */
2777             /* No-op.  */
2778             break;
2779         case 0x4000:
2780             /* MB */
2781             /* No-op */
2782             break;
2783         case 0x4400:
2784             /* WMB */
2785             /* No-op */
2786             break;
2787         case 0x8000:
2788             /* FETCH */
2789             /* No-op */
2790             break;
2791         case 0xA000:
2792             /* FETCH_M */
2793             /* No-op */
2794             break;
2795         case 0xC000:
2796             /* RPCC */
2797             if (ra != 31) {
2798                 if (use_icount) {
2799                     gen_io_start();
2800                     gen_helper_load_pcc(cpu_ir[ra], cpu_env);
2801                     gen_io_end();
2802                     ret = EXIT_PC_STALE;
2803                 } else {
2804                     gen_helper_load_pcc(cpu_ir[ra], cpu_env);
2805                 }
2806             }
2807             break;
2808         case 0xE000:
2809             /* RC */
2810             gen_rx(ra, 0);
2811             break;
2812         case 0xE800:
2813             /* ECB */
2814             break;
2815         case 0xF000:
2816             /* RS */
2817             gen_rx(ra, 1);
2818             break;
2819         case 0xF800:
2820             /* WH64 */
2821             /* No-op */
2822             break;
2823         default:
2824             goto invalid_opc;
2825         }
2826         break;
2827     case 0x19:
2828         /* HW_MFPR (PALcode) */
2829 #ifndef CONFIG_USER_ONLY
2830         if (ctx->tb->flags & TB_FLAGS_PAL_MODE) {
2831             return gen_mfpr(ra, insn & 0xffff);
2832         }
2833 #endif
2834         goto invalid_opc;
2835     case 0x1A:
2836         /* JMP, JSR, RET, JSR_COROUTINE.  These only differ by the branch
2837            prediction stack action, which of course we don't implement.  */
2838         if (rb != 31) {
2839             tcg_gen_andi_i64(cpu_pc, cpu_ir[rb], ~3);
2840         } else {
2841             tcg_gen_movi_i64(cpu_pc, 0);
2842         }
2843         if (ra != 31) {
2844             tcg_gen_movi_i64(cpu_ir[ra], ctx->pc);
2845         }
2846         ret = EXIT_PC_UPDATED;
2847         break;
2848     case 0x1B:
2849         /* HW_LD (PALcode) */
2850 #ifndef CONFIG_USER_ONLY
2851         if (ctx->tb->flags & TB_FLAGS_PAL_MODE) {
2852             TCGv addr;
2853
2854             if (ra == 31) {
2855                 break;
2856             }
2857
2858             addr = tcg_temp_new();
2859             if (rb != 31)
2860                 tcg_gen_addi_i64(addr, cpu_ir[rb], disp12);
2861             else
2862                 tcg_gen_movi_i64(addr, disp12);
2863             switch ((insn >> 12) & 0xF) {
2864             case 0x0:
2865                 /* Longword physical access (hw_ldl/p) */
2866                 gen_helper_ldl_phys(cpu_ir[ra], addr);
2867                 break;
2868             case 0x1:
2869                 /* Quadword physical access (hw_ldq/p) */
2870                 gen_helper_ldq_phys(cpu_ir[ra], addr);
2871                 break;
2872             case 0x2:
2873                 /* Longword physical access with lock (hw_ldl_l/p) */
2874                 gen_helper_ldl_l_phys(cpu_ir[ra], cpu_env, addr);
2875                 break;
2876             case 0x3:
2877                 /* Quadword physical access with lock (hw_ldq_l/p) */
2878                 gen_helper_ldq_l_phys(cpu_ir[ra], cpu_env, addr);
2879                 break;
2880             case 0x4:
2881                 /* Longword virtual PTE fetch (hw_ldl/v) */
2882                 goto invalid_opc;
2883             case 0x5:
2884                 /* Quadword virtual PTE fetch (hw_ldq/v) */
2885                 goto invalid_opc;
2886                 break;
2887             case 0x6:
2888                 /* Incpu_ir[ra]id */
2889                 goto invalid_opc;
2890             case 0x7:
2891                 /* Incpu_ir[ra]id */
2892                 goto invalid_opc;
2893             case 0x8:
2894                 /* Longword virtual access (hw_ldl) */
2895                 goto invalid_opc;
2896             case 0x9:
2897                 /* Quadword virtual access (hw_ldq) */
2898                 goto invalid_opc;
2899             case 0xA:
2900                 /* Longword virtual access with protection check (hw_ldl/w) */
2901                 tcg_gen_qemu_ld32s(cpu_ir[ra], addr, MMU_KERNEL_IDX);
2902                 break;
2903             case 0xB:
2904                 /* Quadword virtual access with protection check (hw_ldq/w) */
2905                 tcg_gen_qemu_ld64(cpu_ir[ra], addr, MMU_KERNEL_IDX);
2906                 break;
2907             case 0xC:
2908                 /* Longword virtual access with alt access mode (hw_ldl/a)*/
2909                 goto invalid_opc;
2910             case 0xD:
2911                 /* Quadword virtual access with alt access mode (hw_ldq/a) */
2912                 goto invalid_opc;
2913             case 0xE:
2914                 /* Longword virtual access with alternate access mode and
2915                    protection checks (hw_ldl/wa) */
2916                 tcg_gen_qemu_ld32s(cpu_ir[ra], addr, MMU_USER_IDX);
2917                 break;
2918             case 0xF:
2919                 /* Quadword virtual access with alternate access mode and
2920                    protection checks (hw_ldq/wa) */
2921                 tcg_gen_qemu_ld64(cpu_ir[ra], addr, MMU_USER_IDX);
2922                 break;
2923             }
2924             tcg_temp_free(addr);
2925             break;
2926         }
2927 #endif
2928         goto invalid_opc;
2929     case 0x1C:
2930         switch (fn7) {
2931         case 0x00:
2932             /* SEXTB */
2933             if ((ctx->tb->flags & TB_FLAGS_AMASK_BWX) == 0) {
2934                 goto invalid_opc;
2935             }
2936             if (likely(rc != 31)) {
2937                 if (islit)
2938                     tcg_gen_movi_i64(cpu_ir[rc], (int64_t)((int8_t)lit));
2939                 else
2940                     tcg_gen_ext8s_i64(cpu_ir[rc], cpu_ir[rb]);
2941             }
2942             break;
2943         case 0x01:
2944             /* SEXTW */
2945             if (ctx->tb->flags & TB_FLAGS_AMASK_BWX) {
2946                 if (likely(rc != 31)) {
2947                     if (islit) {
2948                         tcg_gen_movi_i64(cpu_ir[rc], (int64_t)((int16_t)lit));
2949                     } else {
2950                         tcg_gen_ext16s_i64(cpu_ir[rc], cpu_ir[rb]);
2951                     }
2952                 }
2953                 break;
2954             }
2955             goto invalid_opc;
2956         case 0x30:
2957             /* CTPOP */
2958             if (ctx->tb->flags & TB_FLAGS_AMASK_CIX) {
2959                 if (likely(rc != 31)) {
2960                     if (islit) {
2961                         tcg_gen_movi_i64(cpu_ir[rc], ctpop64(lit));
2962                     } else {
2963                         gen_helper_ctpop(cpu_ir[rc], cpu_ir[rb]);
2964                     }
2965                 }
2966                 break;
2967             }
2968             goto invalid_opc;
2969         case 0x31:
2970             /* PERR */
2971             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
2972                 gen_perr(ra, rb, rc, islit, lit);
2973                 break;
2974             }
2975             goto invalid_opc;
2976         case 0x32:
2977             /* CTLZ */
2978             if (ctx->tb->flags & TB_FLAGS_AMASK_CIX) {
2979                 if (likely(rc != 31)) {
2980                     if (islit) {
2981                         tcg_gen_movi_i64(cpu_ir[rc], clz64(lit));
2982                     } else {
2983                         gen_helper_ctlz(cpu_ir[rc], cpu_ir[rb]);
2984                     }
2985                 }
2986                 break;
2987             }
2988             goto invalid_opc;
2989         case 0x33:
2990             /* CTTZ */
2991             if (ctx->tb->flags & TB_FLAGS_AMASK_CIX) {
2992                 if (likely(rc != 31)) {
2993                     if (islit) {
2994                         tcg_gen_movi_i64(cpu_ir[rc], ctz64(lit));
2995                     } else {
2996                         gen_helper_cttz(cpu_ir[rc], cpu_ir[rb]);
2997                     }
2998                 }
2999                 break;
3000             }
3001             goto invalid_opc;
3002         case 0x34:
3003             /* UNPKBW */
3004             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3005                 if (real_islit || ra != 31) {
3006                     goto invalid_opc;
3007                 }
3008                 gen_unpkbw(rb, rc);
3009                 break;
3010             }
3011             goto invalid_opc;
3012         case 0x35:
3013             /* UNPKBL */
3014             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3015                 if (real_islit || ra != 31) {
3016                     goto invalid_opc;
3017                 }
3018                 gen_unpkbl(rb, rc);
3019                 break;
3020             }
3021             goto invalid_opc;
3022         case 0x36:
3023             /* PKWB */
3024             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3025                 if (real_islit || ra != 31) {
3026                     goto invalid_opc;
3027                 }
3028                 gen_pkwb(rb, rc);
3029                 break;
3030             }
3031             goto invalid_opc;
3032         case 0x37:
3033             /* PKLB */
3034             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3035                 if (real_islit || ra != 31) {
3036                     goto invalid_opc;
3037                 }
3038                 gen_pklb(rb, rc);
3039                 break;
3040             }
3041             goto invalid_opc;
3042         case 0x38:
3043             /* MINSB8 */
3044             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3045                 gen_minsb8(ra, rb, rc, islit, lit);
3046                 break;
3047             }
3048             goto invalid_opc;
3049         case 0x39:
3050             /* MINSW4 */
3051             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3052                 gen_minsw4(ra, rb, rc, islit, lit);
3053                 break;
3054             }
3055             goto invalid_opc;
3056         case 0x3A:
3057             /* MINUB8 */
3058             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3059                 gen_minub8(ra, rb, rc, islit, lit);
3060                 break;
3061             }
3062             goto invalid_opc;
3063         case 0x3B:
3064             /* MINUW4 */
3065             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3066                 gen_minuw4(ra, rb, rc, islit, lit);
3067                 break;
3068             }
3069             goto invalid_opc;
3070         case 0x3C:
3071             /* MAXUB8 */
3072             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3073                 gen_maxub8(ra, rb, rc, islit, lit);
3074                 break;
3075             }
3076             goto invalid_opc;
3077         case 0x3D:
3078             /* MAXUW4 */
3079             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3080                 gen_maxuw4(ra, rb, rc, islit, lit);
3081                 break;
3082             }
3083             goto invalid_opc;
3084         case 0x3E:
3085             /* MAXSB8 */
3086             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3087                 gen_maxsb8(ra, rb, rc, islit, lit);
3088                 break;
3089             }
3090             goto invalid_opc;
3091         case 0x3F:
3092             /* MAXSW4 */
3093             if (ctx->tb->flags & TB_FLAGS_AMASK_MVI) {
3094                 gen_maxsw4(ra, rb, rc, islit, lit);
3095                 break;
3096             }
3097             goto invalid_opc;
3098         case 0x70:
3099             /* FTOIT */
3100             if ((ctx->tb->flags & TB_FLAGS_AMASK_FIX) == 0) {
3101                 goto invalid_opc;
3102             }
3103             if (likely(rc != 31)) {
3104                 if (ra != 31)
3105                     tcg_gen_mov_i64(cpu_ir[rc], cpu_fir[ra]);
3106                 else
3107                     tcg_gen_movi_i64(cpu_ir[rc], 0);
3108             }
3109             break;
3110         case 0x78:
3111             /* FTOIS */
3112             if ((ctx->tb->flags & TB_FLAGS_AMASK_FIX) == 0) {
3113                 goto invalid_opc;
3114             }
3115             if (rc != 31) {
3116                 TCGv_i32 tmp1 = tcg_temp_new_i32();
3117                 if (ra != 31)
3118                     gen_helper_s_to_memory(tmp1, cpu_fir[ra]);
3119                 else {
3120                     TCGv tmp2 = tcg_const_i64(0);
3121                     gen_helper_s_to_memory(tmp1, tmp2);
3122                     tcg_temp_free(tmp2);
3123                 }
3124                 tcg_gen_ext_i32_i64(cpu_ir[rc], tmp1);
3125                 tcg_temp_free_i32(tmp1);
3126             }
3127             break;
3128         default:
3129             goto invalid_opc;
3130         }
3131         break;
3132     case 0x1D:
3133         /* HW_MTPR (PALcode) */
3134 #ifndef CONFIG_USER_ONLY
3135         if (ctx->tb->flags & TB_FLAGS_PAL_MODE) {
3136             return gen_mtpr(ctx, rb, insn & 0xffff);
3137         }
3138 #endif
3139         goto invalid_opc;
3140     case 0x1E:
3141         /* HW_RET (PALcode) */
3142 #ifndef CONFIG_USER_ONLY
3143         if (ctx->tb->flags & TB_FLAGS_PAL_MODE) {
3144             if (rb == 31) {
3145                 /* Pre-EV6 CPUs interpreted this as HW_REI, loading the return
3146                    address from EXC_ADDR.  This turns out to be useful for our
3147                    emulation PALcode, so continue to accept it.  */
3148                 TCGv tmp = tcg_temp_new();
3149                 tcg_gen_ld_i64(tmp, cpu_env, offsetof(CPUAlphaState, exc_addr));
3150                 gen_helper_hw_ret(cpu_env, tmp);
3151                 tcg_temp_free(tmp);
3152             } else {
3153                 gen_helper_hw_ret(cpu_env, cpu_ir[rb]);
3154             }
3155             ret = EXIT_PC_UPDATED;
3156             break;
3157         }
3158 #endif
3159         goto invalid_opc;
3160     case 0x1F:
3161         /* HW_ST (PALcode) */
3162 #ifndef CONFIG_USER_ONLY
3163         if (ctx->tb->flags & TB_FLAGS_PAL_MODE) {
3164             TCGv addr, val;
3165             addr = tcg_temp_new();
3166             if (rb != 31)
3167                 tcg_gen_addi_i64(addr, cpu_ir[rb], disp12);
3168             else
3169                 tcg_gen_movi_i64(addr, disp12);
3170             if (ra != 31)
3171                 val = cpu_ir[ra];
3172             else {
3173                 val = tcg_temp_new();
3174                 tcg_gen_movi_i64(val, 0);
3175             }
3176             switch ((insn >> 12) & 0xF) {
3177             case 0x0:
3178                 /* Longword physical access */
3179                 gen_helper_stl_phys(addr, val);
3180                 break;
3181             case 0x1:
3182                 /* Quadword physical access */
3183                 gen_helper_stq_phys(addr, val);
3184                 break;
3185             case 0x2:
3186                 /* Longword physical access with lock */
3187                 gen_helper_stl_c_phys(val, cpu_env, addr, val);
3188                 break;
3189             case 0x3:
3190                 /* Quadword physical access with lock */
3191                 gen_helper_stq_c_phys(val, cpu_env, addr, val);
3192                 break;
3193             case 0x4:
3194                 /* Longword virtual access */
3195                 goto invalid_opc;
3196             case 0x5:
3197                 /* Quadword virtual access */
3198                 goto invalid_opc;
3199             case 0x6:
3200                 /* Invalid */
3201                 goto invalid_opc;
3202             case 0x7:
3203                 /* Invalid */
3204                 goto invalid_opc;
3205             case 0x8:
3206                 /* Invalid */
3207                 goto invalid_opc;
3208             case 0x9:
3209                 /* Invalid */
3210                 goto invalid_opc;
3211             case 0xA:
3212                 /* Invalid */
3213                 goto invalid_opc;
3214             case 0xB:
3215                 /* Invalid */
3216                 goto invalid_opc;
3217             case 0xC:
3218                 /* Longword virtual access with alternate access mode */
3219                 goto invalid_opc;
3220             case 0xD:
3221                 /* Quadword virtual access with alternate access mode */
3222                 goto invalid_opc;
3223             case 0xE:
3224                 /* Invalid */
3225                 goto invalid_opc;
3226             case 0xF:
3227                 /* Invalid */
3228                 goto invalid_opc;
3229             }
3230             if (ra == 31)
3231                 tcg_temp_free(val);
3232             tcg_temp_free(addr);
3233             break;
3234         }
3235 #endif
3236         goto invalid_opc;
3237     case 0x20:
3238         /* LDF */
3239         gen_load_mem(ctx, &gen_qemu_ldf, ra, rb, disp16, 1, 0);
3240         break;
3241     case 0x21:
3242         /* LDG */
3243         gen_load_mem(ctx, &gen_qemu_ldg, ra, rb, disp16, 1, 0);
3244         break;
3245     case 0x22:
3246         /* LDS */
3247         gen_load_mem(ctx, &gen_qemu_lds, ra, rb, disp16, 1, 0);
3248         break;
3249     case 0x23:
3250         /* LDT */
3251         gen_load_mem(ctx, &tcg_gen_qemu_ld64, ra, rb, disp16, 1, 0);
3252         break;
3253     case 0x24:
3254         /* STF */
3255         gen_store_mem(ctx, &gen_qemu_stf, ra, rb, disp16, 1, 0);
3256         break;
3257     case 0x25:
3258         /* STG */
3259         gen_store_mem(ctx, &gen_qemu_stg, ra, rb, disp16, 1, 0);
3260         break;
3261     case 0x26:
3262         /* STS */
3263         gen_store_mem(ctx, &gen_qemu_sts, ra, rb, disp16, 1, 0);
3264         break;
3265     case 0x27:
3266         /* STT */
3267         gen_store_mem(ctx, &tcg_gen_qemu_st64, ra, rb, disp16, 1, 0);
3268         break;
3269     case 0x28:
3270         /* LDL */
3271         gen_load_mem(ctx, &tcg_gen_qemu_ld32s, ra, rb, disp16, 0, 0);
3272         break;
3273     case 0x29:
3274         /* LDQ */
3275         gen_load_mem(ctx, &tcg_gen_qemu_ld64, ra, rb, disp16, 0, 0);
3276         break;
3277     case 0x2A:
3278         /* LDL_L */
3279         gen_load_mem(ctx, &gen_qemu_ldl_l, ra, rb, disp16, 0, 0);
3280         break;
3281     case 0x2B:
3282         /* LDQ_L */
3283         gen_load_mem(ctx, &gen_qemu_ldq_l, ra, rb, disp16, 0, 0);
3284         break;
3285     case 0x2C:
3286         /* STL */
3287         gen_store_mem(ctx, &tcg_gen_qemu_st32, ra, rb, disp16, 0, 0);
3288         break;
3289     case 0x2D:
3290         /* STQ */
3291         gen_store_mem(ctx, &tcg_gen_qemu_st64, ra, rb, disp16, 0, 0);
3292         break;
3293     case 0x2E:
3294         /* STL_C */
3295         ret = gen_store_conditional(ctx, ra, rb, disp16, 0);
3296         break;
3297     case 0x2F:
3298         /* STQ_C */
3299         ret = gen_store_conditional(ctx, ra, rb, disp16, 1);
3300         break;
3301     case 0x30:
3302         /* BR */
3303         ret = gen_bdirect(ctx, ra, disp21);
3304         break;
3305     case 0x31: /* FBEQ */
3306         ret = gen_fbcond(ctx, TCG_COND_EQ, ra, disp21);
3307         break;
3308     case 0x32: /* FBLT */
3309         ret = gen_fbcond(ctx, TCG_COND_LT, ra, disp21);
3310         break;
3311     case 0x33: /* FBLE */
3312         ret = gen_fbcond(ctx, TCG_COND_LE, ra, disp21);
3313         break;
3314     case 0x34:
3315         /* BSR */
3316         ret = gen_bdirect(ctx, ra, disp21);
3317         break;
3318     case 0x35: /* FBNE */
3319         ret = gen_fbcond(ctx, TCG_COND_NE, ra, disp21);
3320         break;
3321     case 0x36: /* FBGE */
3322         ret = gen_fbcond(ctx, TCG_COND_GE, ra, disp21);
3323         break;
3324     case 0x37: /* FBGT */
3325         ret = gen_fbcond(ctx, TCG_COND_GT, ra, disp21);
3326         break;
3327     case 0x38:
3328         /* BLBC */
3329         ret = gen_bcond(ctx, TCG_COND_EQ, ra, disp21, 1);
3330         break;
3331     case 0x39:
3332         /* BEQ */
3333         ret = gen_bcond(ctx, TCG_COND_EQ, ra, disp21, 0);
3334         break;
3335     case 0x3A:
3336         /* BLT */
3337         ret = gen_bcond(ctx, TCG_COND_LT, ra, disp21, 0);
3338         break;
3339     case 0x3B:
3340         /* BLE */
3341         ret = gen_bcond(ctx, TCG_COND_LE, ra, disp21, 0);
3342         break;
3343     case 0x3C:
3344         /* BLBS */
3345         ret = gen_bcond(ctx, TCG_COND_NE, ra, disp21, 1);
3346         break;
3347     case 0x3D:
3348         /* BNE */
3349         ret = gen_bcond(ctx, TCG_COND_NE, ra, disp21, 0);
3350         break;
3351     case 0x3E:
3352         /* BGE */
3353         ret = gen_bcond(ctx, TCG_COND_GE, ra, disp21, 0);
3354         break;
3355     case 0x3F:
3356         /* BGT */
3357         ret = gen_bcond(ctx, TCG_COND_GT, ra, disp21, 0);
3358         break;
3359     invalid_opc:
3360         ret = gen_invalid(ctx);
3361         break;
3362     }
3363
3364     return ret;
3365 }
3366
3367 static inline void gen_intermediate_code_internal(CPUAlphaState *env,
3368                                                   TranslationBlock *tb,
3369                                                   int search_pc)
3370 {
3371     DisasContext ctx, *ctxp = &ctx;
3372     target_ulong pc_start;
3373     uint32_t insn;
3374     uint16_t *gen_opc_end;
3375     CPUBreakpoint *bp;
3376     int j, lj = -1;
3377     ExitStatus ret;
3378     int num_insns;
3379     int max_insns;
3380
3381     pc_start = tb->pc;
3382     gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
3383
3384     ctx.tb = tb;
3385     ctx.env = env;
3386     ctx.pc = pc_start;
3387     ctx.mem_idx = cpu_mmu_index(env);
3388
3389     /* ??? Every TB begins with unset rounding mode, to be initialized on
3390        the first fp insn of the TB.  Alternately we could define a proper
3391        default for every TB (e.g. QUAL_RM_N or QUAL_RM_D) and make sure
3392        to reset the FP_STATUS to that default at the end of any TB that
3393        changes the default.  We could even (gasp) dynamiclly figure out
3394        what default would be most efficient given the running program.  */
3395     ctx.tb_rm = -1;
3396     /* Similarly for flush-to-zero.  */
3397     ctx.tb_ftz = -1;
3398
3399     num_insns = 0;
3400     max_insns = tb->cflags & CF_COUNT_MASK;
3401     if (max_insns == 0)
3402         max_insns = CF_COUNT_MASK;
3403
3404     gen_icount_start();
3405     do {
3406         if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
3407             QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
3408                 if (bp->pc == ctx.pc) {
3409                     gen_excp(&ctx, EXCP_DEBUG, 0);
3410                     break;
3411                 }
3412             }
3413         }
3414         if (search_pc) {
3415             j = gen_opc_ptr - gen_opc_buf;
3416             if (lj < j) {
3417                 lj++;
3418                 while (lj < j)
3419                     gen_opc_instr_start[lj++] = 0;
3420             }
3421             gen_opc_pc[lj] = ctx.pc;
3422             gen_opc_instr_start[lj] = 1;
3423             gen_opc_icount[lj] = num_insns;
3424         }
3425         if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
3426             gen_io_start();
3427         insn = cpu_ldl_code(env, ctx.pc);
3428         num_insns++;
3429
3430         if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP))) {
3431             tcg_gen_debug_insn_start(ctx.pc);
3432         }
3433
3434         ctx.pc += 4;
3435         ret = translate_one(ctxp, insn);
3436
3437         /* If we reach a page boundary, are single stepping,
3438            or exhaust instruction count, stop generation.  */
3439         if (ret == NO_EXIT
3440             && ((ctx.pc & (TARGET_PAGE_SIZE - 1)) == 0
3441                 || gen_opc_ptr >= gen_opc_end
3442                 || num_insns >= max_insns
3443                 || singlestep
3444                 || env->singlestep_enabled)) {
3445             ret = EXIT_PC_STALE;
3446         }
3447     } while (ret == NO_EXIT);
3448
3449     if (tb->cflags & CF_LAST_IO) {
3450         gen_io_end();
3451     }
3452
3453     switch (ret) {
3454     case EXIT_GOTO_TB:
3455     case EXIT_NORETURN:
3456         break;
3457     case EXIT_PC_STALE:
3458         tcg_gen_movi_i64(cpu_pc, ctx.pc);
3459         /* FALLTHRU */
3460     case EXIT_PC_UPDATED:
3461         if (env->singlestep_enabled) {
3462             gen_excp_1(EXCP_DEBUG, 0);
3463         } else {
3464             tcg_gen_exit_tb(0);
3465         }
3466         break;
3467     default:
3468         abort();
3469     }
3470
3471     gen_icount_end(tb, num_insns);
3472     *gen_opc_ptr = INDEX_op_end;
3473     if (search_pc) {
3474         j = gen_opc_ptr - gen_opc_buf;
3475         lj++;
3476         while (lj <= j)
3477             gen_opc_instr_start[lj++] = 0;
3478     } else {
3479         tb->size = ctx.pc - pc_start;
3480         tb->icount = num_insns;
3481     }
3482
3483 #ifdef DEBUG_DISAS
3484     if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
3485         qemu_log("IN: %s\n", lookup_symbol(pc_start));
3486         log_target_disas(pc_start, ctx.pc - pc_start, 1);
3487         qemu_log("\n");
3488     }
3489 #endif
3490 }
3491
3492 void gen_intermediate_code (CPUAlphaState *env, struct TranslationBlock *tb)
3493 {
3494     gen_intermediate_code_internal(env, tb, 0);
3495 }
3496
3497 void gen_intermediate_code_pc (CPUAlphaState *env, struct TranslationBlock *tb)
3498 {
3499     gen_intermediate_code_internal(env, tb, 1);
3500 }
3501
3502 struct cpu_def_t {
3503     const char *name;
3504     int implver, amask;
3505 };
3506
3507 static const struct cpu_def_t cpu_defs[] = {
3508     { "ev4",   IMPLVER_2106x, 0 },
3509     { "ev5",   IMPLVER_21164, 0 },
3510     { "ev56",  IMPLVER_21164, AMASK_BWX },
3511     { "pca56", IMPLVER_21164, AMASK_BWX | AMASK_MVI },
3512     { "ev6",   IMPLVER_21264, AMASK_BWX | AMASK_FIX | AMASK_MVI | AMASK_TRAP },
3513     { "ev67",  IMPLVER_21264, (AMASK_BWX | AMASK_FIX | AMASK_CIX
3514                                | AMASK_MVI | AMASK_TRAP | AMASK_PREFETCH), },
3515     { "ev68",  IMPLVER_21264, (AMASK_BWX | AMASK_FIX | AMASK_CIX
3516                                | AMASK_MVI | AMASK_TRAP | AMASK_PREFETCH), },
3517     { "21064", IMPLVER_2106x, 0 },
3518     { "21164", IMPLVER_21164, 0 },
3519     { "21164a", IMPLVER_21164, AMASK_BWX },
3520     { "21164pc", IMPLVER_21164, AMASK_BWX | AMASK_MVI },
3521     { "21264", IMPLVER_21264, AMASK_BWX | AMASK_FIX | AMASK_MVI | AMASK_TRAP },
3522     { "21264a", IMPLVER_21264, (AMASK_BWX | AMASK_FIX | AMASK_CIX
3523                                 | AMASK_MVI | AMASK_TRAP | AMASK_PREFETCH), }
3524 };
3525
3526 CPUAlphaState * cpu_alpha_init (const char *cpu_model)
3527 {
3528     AlphaCPU *cpu;
3529     CPUAlphaState *env;
3530     int implver, amask, i, max;
3531
3532     cpu = ALPHA_CPU(object_new(TYPE_ALPHA_CPU));
3533     env = &cpu->env;
3534
3535     alpha_translate_init();
3536
3537     /* Default to ev67; no reason not to emulate insns by default.  */
3538     implver = IMPLVER_21264;
3539     amask = (AMASK_BWX | AMASK_FIX | AMASK_CIX | AMASK_MVI
3540              | AMASK_TRAP | AMASK_PREFETCH);
3541
3542     max = ARRAY_SIZE(cpu_defs);
3543     for (i = 0; i < max; i++) {
3544         if (strcmp (cpu_model, cpu_defs[i].name) == 0) {
3545             implver = cpu_defs[i].implver;
3546             amask = cpu_defs[i].amask;
3547             break;
3548         }
3549     }
3550     env->implver = implver;
3551     env->amask = amask;
3552
3553     qemu_init_vcpu(env);
3554     return env;
3555 }
3556
3557 void restore_state_to_opc(CPUAlphaState *env, TranslationBlock *tb, int pc_pos)
3558 {
3559     env->pc = gen_opc_pc[pc_pos];
3560 }