git.maemo.org Git - qemu/blob - 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, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdint.h>
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24
  25 #include "cpu.h"
  26 #include "exec-all.h"
  27 #include "disas.h"
  28 #include "host-utils.h"
  29 #include "helper.h"
  30 #include "tcg-op.h"
  31 #include "qemu-common.h"
  32
  33 #define DO_SINGLE_STEP
  34 #define GENERATE_NOP
  35 #define ALPHA_DEBUG_DISAS
  36 #define DO_TB_FLUSH
  37
  38 typedef struct DisasContext DisasContext;
  39 struct DisasContext {
  40     uint64_t pc;
  41     int mem_idx;
  42 #if !defined (CONFIG_USER_ONLY)
  43     int pal_mode;
  44 #endif
  45     uint32_t amask;
  46 };
  47
  48 /* global register indexes */
  49 static TCGv cpu_env;
  50 static TCGv cpu_ir[31];
  51 static TCGv cpu_pc;
  52
  53 /* dyngen register indexes */
  54 static TCGv cpu_T[3];
  55
  56 /* register names */
  57 static char cpu_reg_names[10*4+21*5];
  58
  59 #include "gen-icount.h"
  60
  61 static void alpha_translate_init(void)
  62 {
  63     int i;
  64     char *p;
  65     static int done_init = 0;
  66
  67     if (done_init)
  68         return;
  69
  70     cpu_env = tcg_global_reg_new(TCG_TYPE_PTR, TCG_AREG0, "env");
  71
  72 #if TARGET_LONG_BITS > HOST_LONG_BITS
  73     cpu_T[0] = tcg_global_mem_new(TCG_TYPE_I64, TCG_AREG0,
  74                                   offsetof(CPUState, t0), "T0");
  75     cpu_T[1] = tcg_global_mem_new(TCG_TYPE_I64, TCG_AREG0,
  76                                   offsetof(CPUState, t1), "T1");
  77     cpu_T[2] = tcg_global_mem_new(TCG_TYPE_I64, TCG_AREG0,
  78                                   offsetof(CPUState, t2), "T2");
  79 #else
  80     cpu_T[0] = tcg_global_reg_new(TCG_TYPE_I64, TCG_AREG1, "T0");
  81     cpu_T[1] = tcg_global_reg_new(TCG_TYPE_I64, TCG_AREG2, "T1");
  82     cpu_T[2] = tcg_global_reg_new(TCG_TYPE_I64, TCG_AREG3, "T2");
  83 #endif
  84
  85     p = cpu_reg_names;
  86     for (i = 0; i < 31; i++) {
  87         sprintf(p, "ir%d", i);
  88         cpu_ir[i] = tcg_global_mem_new(TCG_TYPE_I64, TCG_AREG0,
  89                                        offsetof(CPUState, ir[i]), p);
  90         p += (i < 10) ? 4 : 5;
  91     }
  92
  93     cpu_pc = tcg_global_mem_new(TCG_TYPE_I64, TCG_AREG0,
  94                                 offsetof(CPUState, pc), "pc");
  95
  96     /* register helpers */
  97 #undef DEF_HELPER
  98 #define DEF_HELPER(ret, name, params) tcg_register_helper(name, #name);
  99 #include "helper.h"
 100
 101     done_init = 1;
 102 }
 103
 104 static always_inline void gen_op_nop (void)
 105 {
 106 #if defined(GENERATE_NOP)
 107     gen_op_no_op();
 108 #endif
 109 }
 110
 111 #define GEN32(func, NAME) \
 112 static GenOpFunc *NAME ## _table [32] = {                                     \
 113 NAME ## 0, NAME ## 1, NAME ## 2, NAME ## 3,                                   \
 114 NAME ## 4, NAME ## 5, NAME ## 6, NAME ## 7,                                   \
 115 NAME ## 8, NAME ## 9, NAME ## 10, NAME ## 11,                                 \
 116 NAME ## 12, NAME ## 13, NAME ## 14, NAME ## 15,                               \
 117 NAME ## 16, NAME ## 17, NAME ## 18, NAME ## 19,                               \
 118 NAME ## 20, NAME ## 21, NAME ## 22, NAME ## 23,                               \
 119 NAME ## 24, NAME ## 25, NAME ## 26, NAME ## 27,                               \
 120 NAME ## 28, NAME ## 29, NAME ## 30, NAME ## 31,                               \
 121 };                                                                            \
 122 static always_inline void func (int n)                                        \
 123 {                                                                             \
 124     NAME ## _table[n]();                                                      \
 125 }
 126
 127 /* FIR moves */
 128 /* Special hacks for fir31 */
 129 #define gen_op_load_FT0_fir31 gen_op_reset_FT0
 130 #define gen_op_load_FT1_fir31 gen_op_reset_FT1
 131 #define gen_op_load_FT2_fir31 gen_op_reset_FT2
 132 #define gen_op_store_FT0_fir31 gen_op_nop
 133 #define gen_op_store_FT1_fir31 gen_op_nop
 134 #define gen_op_store_FT2_fir31 gen_op_nop
 135 #define gen_op_cmov_fir31 gen_op_nop
 136 GEN32(gen_op_load_FT0_fir, gen_op_load_FT0_fir);
 137 GEN32(gen_op_load_FT1_fir, gen_op_load_FT1_fir);
 138 GEN32(gen_op_load_FT2_fir, gen_op_load_FT2_fir);
 139 GEN32(gen_op_store_FT0_fir, gen_op_store_FT0_fir);
 140 GEN32(gen_op_store_FT1_fir, gen_op_store_FT1_fir);
 141 GEN32(gen_op_store_FT2_fir, gen_op_store_FT2_fir);
 142 GEN32(gen_op_cmov_fir, gen_op_cmov_fir);
 143
 144 static always_inline void gen_load_fir (DisasContext *ctx, int firn, int Tn)
 145 {
 146     switch (Tn) {
 147     case 0:
 148         gen_op_load_FT0_fir(firn);
 149         break;
 150     case 1:
 151         gen_op_load_FT1_fir(firn);
 152         break;
 153     case 2:
 154         gen_op_load_FT2_fir(firn);
 155         break;
 156     }
 157 }
 158
 159 static always_inline void gen_store_fir (DisasContext *ctx, int firn, int Tn)
 160 {
 161     switch (Tn) {
 162     case 0:
 163         gen_op_store_FT0_fir(firn);
 164         break;
 165     case 1:
 166         gen_op_store_FT1_fir(firn);
 167         break;
 168     case 2:
 169         gen_op_store_FT2_fir(firn);
 170         break;
 171     }
 172 }
 173
 174 /* Memory moves */
 175 #if defined(CONFIG_USER_ONLY)
 176 #define OP_LD_TABLE(width)                                                    \
 177 static GenOpFunc *gen_op_ld##width[] = {                                      \
 178     &gen_op_ld##width##_raw,                                                  \
 179 }
 180 #define OP_ST_TABLE(width)                                                    \
 181 static GenOpFunc *gen_op_st##width[] = {                                      \
 182     &gen_op_st##width##_raw,                                                  \
 183 }
 184 #else
 185 #define OP_LD_TABLE(width)                                                    \
 186 static GenOpFunc *gen_op_ld##width[] = {                                      \
 187     &gen_op_ld##width##_kernel,                                               \
 188     &gen_op_ld##width##_executive,                                            \
 189     &gen_op_ld##width##_supervisor,                                           \
 190     &gen_op_ld##width##_user,                                                 \
 191 }
 192 #define OP_ST_TABLE(width)                                                    \
 193 static GenOpFunc *gen_op_st##width[] = {                                      \
 194     &gen_op_st##width##_kernel,                                               \
 195     &gen_op_st##width##_executive,                                            \
 196     &gen_op_st##width##_supervisor,                                           \
 197     &gen_op_st##width##_user,                                                 \
 198 }
 199 #endif
 200
 201 #define GEN_LD(width)                                                         \
 202 OP_LD_TABLE(width);                                                           \
 203 static always_inline void gen_ld##width (DisasContext *ctx)                   \
 204 {                                                                             \
 205     (*gen_op_ld##width[ctx->mem_idx])();                                      \
 206 }
 207
 208 #define GEN_ST(width)                                                         \
 209 OP_ST_TABLE(width);                                                           \
 210 static always_inline void gen_st##width (DisasContext *ctx)                   \
 211 {                                                                             \
 212     (*gen_op_st##width[ctx->mem_idx])();                                      \
 213 }
 214
 215 GEN_LD(bu);
 216 GEN_ST(b);
 217 GEN_LD(wu);
 218 GEN_ST(w);
 219 GEN_LD(l);
 220 GEN_ST(l);
 221 GEN_LD(q);
 222 GEN_ST(q);
 223 GEN_LD(q_u);
 224 GEN_ST(q_u);
 225 GEN_LD(l_l);
 226 GEN_ST(l_c);
 227 GEN_LD(q_l);
 228 GEN_ST(q_c);
 229
 230 #if 0 /* currently unused */
 231 GEN_LD(f);
 232 GEN_ST(f);
 233 GEN_LD(g);
 234 GEN_ST(g);
 235 #endif /* 0 */
 236 GEN_LD(s);
 237 GEN_ST(s);
 238 GEN_LD(t);
 239 GEN_ST(t);
 240
 241 static always_inline void _gen_op_bcond (DisasContext *ctx)
 242 {
 243 #if 0 // Qemu does not know how to do this...
 244     gen_op_bcond(ctx->pc);
 245 #else
 246     gen_op_bcond(ctx->pc >> 32, ctx->pc);
 247 #endif
 248 }
 249
 250 static always_inline void gen_excp (DisasContext *ctx,
 251                                     int exception, int error_code)
 252 {
 253     tcg_gen_movi_i64(cpu_pc, ctx->pc);
 254     gen_op_excp(exception, error_code);
 255 }
 256
 257 static always_inline void gen_invalid (DisasContext *ctx)
 258 {
 259     gen_excp(ctx, EXCP_OPCDEC, 0);
 260 }
 261
 262 static always_inline void gen_load_mem (DisasContext *ctx,
 263                                         void (*gen_load_op)(DisasContext *ctx),
 264                                         int ra, int rb, int32_t disp16,
 265                                         int clear)
 266 {
 267     if (ra == 31 && disp16 == 0) {
 268         /* UNOP */
 269         gen_op_nop();
 270     } else {
 271         if (rb != 31)
 272             tcg_gen_addi_i64(cpu_T[0], cpu_ir[rb], disp16);
 273         else
 274             tcg_gen_movi_i64(cpu_T[0], disp16);
 275         if (clear)
 276             tcg_gen_andi_i64(cpu_T[0], cpu_T[0], ~0x7);
 277         (*gen_load_op)(ctx);
 278         if (ra != 31)
 279             tcg_gen_mov_i64(cpu_ir[ra], cpu_T[1]);
 280     }
 281 }
 282
 283 static always_inline void gen_store_mem (DisasContext *ctx,
 284                                          void (*gen_store_op)(DisasContext *ctx),
 285                                          int ra, int rb, int32_t disp16,
 286                                          int clear)
 287 {
 288     if (rb != 31)
 289         tcg_gen_addi_i64(cpu_T[0], cpu_ir[rb], disp16);
 290     else
 291         tcg_gen_movi_i64(cpu_T[0], disp16);
 292     if (clear)
 293         tcg_gen_andi_i64(cpu_T[0], cpu_T[0], ~0x7);
 294     if (ra != 31)
 295         tcg_gen_mov_i64(cpu_T[1], cpu_ir[ra]);
 296     else
 297         tcg_gen_movi_i64(cpu_T[1], 0);
 298     (*gen_store_op)(ctx);
 299 }
 300
 301 static always_inline void gen_load_fmem (DisasContext *ctx,
 302                                          void (*gen_load_fop)(DisasContext *ctx),
 303                                          int ra, int rb, int32_t disp16)
 304 {
 305     if (rb != 31)
 306         tcg_gen_addi_i64(cpu_T[0], cpu_ir[rb], disp16);
 307     else
 308         tcg_gen_movi_i64(cpu_T[0], disp16);
 309     (*gen_load_fop)(ctx);
 310     gen_store_fir(ctx, ra, 1);
 311 }
 312
 313 static always_inline void gen_store_fmem (DisasContext *ctx,
 314                                           void (*gen_store_fop)(DisasContext *ctx),
 315                                           int ra, int rb, int32_t disp16)
 316 {
 317     if (rb != 31)
 318         tcg_gen_addi_i64(cpu_T[0], cpu_ir[rb], disp16);
 319     else
 320         tcg_gen_movi_i64(cpu_T[0], disp16);
 321     gen_load_fir(ctx, ra, 1);
 322     (*gen_store_fop)(ctx);
 323 }
 324
 325 static always_inline void gen_bcond (DisasContext *ctx,
 326                                      TCGCond cond,
 327                                      int ra, int32_t disp16, int mask)
 328 {
 329     int l1, l2;
 330
 331     l1 = gen_new_label();
 332     l2 = gen_new_label();
 333     if (likely(ra != 31)) {
 334         if (mask) {
 335             TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 336             tcg_gen_andi_i64(tmp, cpu_ir[ra], 1);
 337             tcg_gen_brcondi_i64(cond, tmp, 0, l1);
 338             tcg_temp_free(tmp);
 339         } else
 340             tcg_gen_brcondi_i64(cond, cpu_ir[ra], 0, l1);
 341     } else {
 342         /* Very uncommon case - Do not bother to optimize.  */
 343         TCGv tmp = tcg_const_i64(0);
 344         tcg_gen_brcondi_i64(cond, tmp, 0, l1);
 345         tcg_temp_free(tmp);
 346     }
 347     tcg_gen_movi_i64(cpu_pc, ctx->pc);
 348     tcg_gen_br(l2);
 349     gen_set_label(l1);
 350     tcg_gen_movi_i64(cpu_pc, ctx->pc + (int64_t)(disp16 << 2));
 351     gen_set_label(l2);
 352 }
 353
 354 static always_inline void gen_fbcond (DisasContext *ctx,
 355                                       void (*gen_test_op)(void),
 356                                       int ra, int32_t disp16)
 357 {
 358     tcg_gen_movi_i64(cpu_T[1], ctx->pc + (int64_t)(disp16 << 2));
 359     gen_load_fir(ctx, ra, 0);
 360     (*gen_test_op)();
 361     _gen_op_bcond(ctx);
 362 }
 363
 364 static always_inline void gen_arith3 (DisasContext *ctx,
 365                                       void (*gen_arith_op)(void),
 366                                       int ra, int rb, int rc,
 367                                       int islit, uint8_t lit)
 368 {
 369     if (ra != 31)
 370         tcg_gen_mov_i64(cpu_T[0], cpu_ir[ra]);
 371     else
 372         tcg_gen_movi_i64(cpu_T[0], 0);
 373     if (islit)
 374         tcg_gen_movi_i64(cpu_T[1], lit);
 375     else if (rb != 31)
 376         tcg_gen_mov_i64(cpu_T[1], cpu_ir[rb]);
 377     else
 378         tcg_gen_movi_i64(cpu_T[1], 0);
 379     (*gen_arith_op)();
 380     if (rc != 31)
 381         tcg_gen_mov_i64(cpu_ir[rc], cpu_T[0]);
 382 }
 383
 384 static always_inline void gen_cmov (DisasContext *ctx,
 385                                     TCGCond inv_cond,
 386                                     int ra, int rb, int rc,
 387                                     int islit, int8_t lit, int mask)
 388 {
 389     int l1;
 390
 391     if (unlikely(rc == 31))
 392         return;
 393
 394     l1 = gen_new_label();
 395
 396     if (ra != 31) {
 397         if (mask) {
 398             TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 399             tcg_gen_andi_i64(tmp, cpu_ir[ra], 1);
 400             tcg_gen_brcondi_i64(inv_cond, tmp, 0, l1);
 401             tcg_temp_free(tmp);
 402         } else
 403             tcg_gen_brcondi_i64(inv_cond, cpu_ir[ra], 0, l1);
 404     } else {
 405         /* Very uncommon case - Do not bother to optimize.  */
 406         TCGv tmp = tcg_const_i64(0);
 407         tcg_gen_brcondi_i64(inv_cond, tmp, 0, l1);
 408         tcg_temp_free(tmp);
 409     }
 410
 411     if (islit)
 412         tcg_gen_movi_i64(cpu_ir[rc], lit);
 413     else if (rb != 31)
 414         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
 415     else
 416         tcg_gen_movi_i64(cpu_ir[rc], 0);
 417     gen_set_label(l1);
 418 }
 419
 420 static always_inline void gen_farith2 (DisasContext *ctx,
 421                                        void (*gen_arith_fop)(void),
 422                                        int rb, int rc)
 423 {
 424     gen_load_fir(ctx, rb, 0);
 425     (*gen_arith_fop)();
 426     gen_store_fir(ctx, rc, 0);
 427 }
 428
 429 static always_inline void gen_farith3 (DisasContext *ctx,
 430                                        void (*gen_arith_fop)(void),
 431                                        int ra, int rb, int rc)
 432 {
 433     gen_load_fir(ctx, ra, 0);
 434     gen_load_fir(ctx, rb, 1);
 435     (*gen_arith_fop)();
 436     gen_store_fir(ctx, rc, 0);
 437 }
 438
 439 static always_inline void gen_fcmov (DisasContext *ctx,
 440                                      void (*gen_test_fop)(void),
 441                                      int ra, int rb, int rc)
 442 {
 443     gen_load_fir(ctx, ra, 0);
 444     gen_load_fir(ctx, rb, 1);
 445     (*gen_test_fop)();
 446     gen_op_cmov_fir(rc);
 447 }
 448
 449 static always_inline void gen_fti (DisasContext *ctx,
 450                                    void (*gen_move_fop)(void),
 451                                    int ra, int rc)
 452 {
 453     gen_load_fir(ctx, rc, 0);
 454     (*gen_move_fop)();
 455     if (ra != 31)
 456         tcg_gen_mov_i64(cpu_ir[ra], cpu_T[0]);
 457 }
 458
 459 static always_inline void gen_itf (DisasContext *ctx,
 460                                    void (*gen_move_fop)(void),
 461                                    int ra, int rc)
 462 {
 463     if (ra != 31)
 464         tcg_gen_mov_i64(cpu_T[0], cpu_ir[ra]);
 465     else
 466         tcg_gen_movi_i64(cpu_T[0], 0);
 467     (*gen_move_fop)();
 468     gen_store_fir(ctx, rc, 0);
 469 }
 470
 471 static always_inline int translate_one (DisasContext *ctx, uint32_t insn)
 472 {
 473     uint32_t palcode;
 474     int32_t disp21, disp16, disp12;
 475     uint16_t fn11, fn16;
 476     uint8_t opc, ra, rb, rc, sbz, fpfn, fn7, fn2, islit;
 477     int8_t lit;
 478     int ret;
 479
 480     /* Decode all instruction fields */
 481     opc = insn >> 26;
 482     ra = (insn >> 21) & 0x1F;
 483     rb = (insn >> 16) & 0x1F;
 484     rc = insn & 0x1F;
 485     sbz = (insn >> 13) & 0x07;
 486     islit = (insn >> 12) & 1;
 487     lit = (insn >> 13) & 0xFF;
 488     palcode = insn & 0x03FFFFFF;
 489     disp21 = ((int32_t)((insn & 0x001FFFFF) << 11)) >> 11;
 490     disp16 = (int16_t)(insn & 0x0000FFFF);
 491     disp12 = (int32_t)((insn & 0x00000FFF) << 20) >> 20;
 492     fn16 = insn & 0x0000FFFF;
 493     fn11 = (insn >> 5) & 0x000007FF;
 494     fpfn = fn11 & 0x3F;
 495     fn7 = (insn >> 5) & 0x0000007F;
 496     fn2 = (insn >> 5) & 0x00000003;
 497     ret = 0;
 498 #if defined ALPHA_DEBUG_DISAS
 499     if (logfile != NULL) {
 500         fprintf(logfile, "opc %02x ra %d rb %d rc %d disp16 %04x\n",
 501                 opc, ra, rb, rc, disp16);
 502     }
 503 #endif
 504     switch (opc) {
 505     case 0x00:
 506         /* CALL_PAL */
 507         if (palcode >= 0x80 && palcode < 0xC0) {
 508             /* Unprivileged PAL call */
 509             gen_excp(ctx, EXCP_CALL_PAL + ((palcode & 0x1F) << 6), 0);
 510 #if !defined (CONFIG_USER_ONLY)
 511         } else if (palcode < 0x40) {
 512             /* Privileged PAL code */
 513             if (ctx->mem_idx & 1)
 514                 goto invalid_opc;
 515             else
 516                 gen_excp(ctx, EXCP_CALL_PALP + ((palcode & 0x1F) << 6), 0);
 517 #endif
 518         } else {
 519             /* Invalid PAL call */
 520             goto invalid_opc;
 521         }
 522         ret = 3;
 523         break;
 524     case 0x01:
 525         /* OPC01 */
 526         goto invalid_opc;
 527     case 0x02:
 528         /* OPC02 */
 529         goto invalid_opc;
 530     case 0x03:
 531         /* OPC03 */
 532         goto invalid_opc;
 533     case 0x04:
 534         /* OPC04 */
 535         goto invalid_opc;
 536     case 0x05:
 537         /* OPC05 */
 538         goto invalid_opc;
 539     case 0x06:
 540         /* OPC06 */
 541         goto invalid_opc;
 542     case 0x07:
 543         /* OPC07 */
 544         goto invalid_opc;
 545     case 0x08:
 546         /* LDA */
 547         if (likely(ra != 31)) {
 548             if (rb != 31)
 549                 tcg_gen_addi_i64(cpu_ir[ra], cpu_ir[rb], disp16);
 550             else
 551                 tcg_gen_movi_i64(cpu_ir[ra], disp16);
 552         }
 553         break;
 554     case 0x09:
 555         /* LDAH */
 556         if (likely(ra != 31)) {
 557             if (rb != 31)
 558                 tcg_gen_addi_i64(cpu_ir[ra], cpu_ir[rb], disp16 << 16);
 559             else
 560                 tcg_gen_movi_i64(cpu_ir[ra], disp16 << 16);
 561         }
 562         break;
 563     case 0x0A:
 564         /* LDBU */
 565         if (!(ctx->amask & AMASK_BWX))
 566             goto invalid_opc;
 567         gen_load_mem(ctx, &gen_ldbu, ra, rb, disp16, 0);
 568         break;
 569     case 0x0B:
 570         /* LDQ_U */
 571         gen_load_mem(ctx, &gen_ldq_u, ra, rb, disp16, 1);
 572         break;
 573     case 0x0C:
 574         /* LDWU */
 575         if (!(ctx->amask & AMASK_BWX))
 576             goto invalid_opc;
 577         gen_load_mem(ctx, &gen_ldwu, ra, rb, disp16, 0);
 578         break;
 579     case 0x0D:
 580         /* STW */
 581         if (!(ctx->amask & AMASK_BWX))
 582             goto invalid_opc;
 583         gen_store_mem(ctx, &gen_stw, ra, rb, disp16, 0);
 584         break;
 585     case 0x0E:
 586         /* STB */
 587         if (!(ctx->amask & AMASK_BWX))
 588             goto invalid_opc;
 589         gen_store_mem(ctx, &gen_stb, ra, rb, disp16, 0);
 590         break;
 591     case 0x0F:
 592         /* STQ_U */
 593         gen_store_mem(ctx, &gen_stq_u, ra, rb, disp16, 1);
 594         break;
 595     case 0x10:
 596         switch (fn7) {
 597         case 0x00:
 598             /* ADDL */
 599             if (likely(rc != 31)) {
 600                 if (ra != 31) {
 601                     if (islit) {
 602                         tcg_gen_addi_i64(cpu_ir[rc], cpu_ir[ra], lit);
 603                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 604                     } else if (rb != 31) {
 605                         tcg_gen_add_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
 606                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 607                     } else
 608                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[ra]);
 609                 } else {
 610                     if (islit)
 611                         tcg_gen_movi_i64(cpu_ir[rc], (int32_t)lit);
 612                     else if (rb != 31)
 613                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
 614                     else
 615                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 616                 }
 617             }
 618             break;
 619         case 0x02:
 620             /* S4ADDL */
 621             if (likely(rc != 31)) {
 622                 if (ra != 31) {
 623                     if (islit || rb != 31) {
 624                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 625                         tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
 626                         if (islit)
 627                             tcg_gen_addi_i64(tmp, tmp, lit);
 628                         else
 629                             tcg_gen_add_i64(tmp, tmp, cpu_ir[rb]);
 630                         tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
 631                         tcg_temp_free(tmp);
 632                     } else {
 633                         tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], 2);
 634                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 635                     }
 636                 } else {
 637                     if (islit)
 638                         tcg_gen_movi_i64(cpu_ir[rc], lit);
 639                     else if (rb != 31)
 640                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
 641                     else
 642                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 643                 }
 644             }
 645             break;
 646         case 0x09:
 647             /* SUBL */
 648             if (likely(rc != 31)) {
 649                 if (ra != 31) {
 650                     if (islit) {
 651                         tcg_gen_subi_i64(cpu_ir[rc], cpu_ir[ra], lit);
 652                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 653                     } else if (rb != 31) {
 654                         tcg_gen_sub_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
 655                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 656                     } else
 657                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[ra]);
 658                 } else {
 659                     if (islit)
 660                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
 661                     else if (rb != 31) {
 662                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
 663                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 664                     } else
 665                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 666                 }
 667             }
 668             break;
 669         case 0x0B:
 670             /* S4SUBL */
 671             if (likely(rc != 31)) {
 672                 if (ra != 31) {
 673                     if (islit || rb != 31) {
 674                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 675                         tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
 676                         if (islit)
 677                             tcg_gen_subi_i64(tmp, tmp, lit);
 678                         else
 679                             tcg_gen_sub_i64(tmp, tmp, cpu_ir[rb]);
 680                         tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
 681                         tcg_temp_free(tmp);
 682                     } else {
 683                         tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], 2);
 684                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 685                     }
 686                 } else {
 687                     if (islit)
 688                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
 689                     else if (rb != 31) {
 690                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
 691                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 692                     } else
 693                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 694                 }
 695             }
 696             break;
 697         case 0x0F:
 698             /* CMPBGE */
 699             gen_arith3(ctx, &gen_op_cmpbge, ra, rb, rc, islit, lit);
 700             break;
 701         case 0x12:
 702             /* S8ADDL */
 703             if (likely(rc != 31)) {
 704                 if (ra != 31) {
 705                     if (islit || rb != 31) {
 706                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 707                         tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
 708                         if (islit)
 709                             tcg_gen_addi_i64(tmp, tmp, lit);
 710                         else
 711                             tcg_gen_add_i64(tmp, tmp, cpu_ir[rb]);
 712                         tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
 713                         tcg_temp_free(tmp);
 714                     } else {
 715                         tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], 3);
 716                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 717                     }
 718                 } else {
 719                     if (islit)
 720                         tcg_gen_movi_i64(cpu_ir[rc], lit);
 721                     else if (rb != 31)
 722                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rb]);
 723                     else
 724                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 725                 }
 726             }
 727             break;
 728         case 0x1B:
 729             /* S8SUBL */
 730             if (likely(rc != 31)) {
 731                 if (ra != 31) {
 732                     if (islit || rb != 31) {
 733                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 734                         tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
 735                         if (islit)
 736                             tcg_gen_subi_i64(tmp, tmp, lit);
 737                         else
 738                             tcg_gen_sub_i64(tmp, tmp, cpu_ir[rb]);
 739                         tcg_gen_ext32s_i64(cpu_ir[rc], tmp);
 740                         tcg_temp_free(tmp);
 741                     } else {
 742                         tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], 3);
 743                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 744                     }
 745                 } else {
 746                     if (islit)
 747                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
 748                     else if (rb != 31) {
 749                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
 750                         tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
 751                     } else
 752                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 753                 }
 754             }
 755             break;
 756         case 0x1D:
 757             /* CMPULT */
 758             gen_arith3(ctx, &gen_op_cmpult, ra, rb, rc, islit, lit);
 759             break;
 760         case 0x20:
 761             /* ADDQ */
 762             if (likely(rc != 31)) {
 763                 if (ra != 31) {
 764                     if (islit)
 765                         tcg_gen_addi_i64(cpu_ir[rc], cpu_ir[ra], lit);
 766                     else if (rb != 31)
 767                         tcg_gen_add_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
 768                     else
 769                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);
 770                 } else {
 771                     if (islit)
 772                         tcg_gen_movi_i64(cpu_ir[rc], lit);
 773                     else if (rb != 31)
 774                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
 775                     else
 776                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 777                 }
 778             }
 779             break;
 780         case 0x22:
 781             /* S4ADDQ */
 782             if (likely(rc != 31)) {
 783                 if (ra != 31) {
 784                     if (islit || rb != 31) {
 785                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 786                         tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
 787                         if (islit)
 788                             tcg_gen_addi_i64(cpu_ir[rc], tmp, lit);
 789                         else
 790                             tcg_gen_add_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
 791                         tcg_temp_free(tmp);
 792                     } else
 793                         tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], 2);
 794                 } else {
 795                     if (islit)
 796                         tcg_gen_movi_i64(cpu_ir[rc], lit);
 797                     else if (rb != 31)
 798                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
 799                     else
 800                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 801                 }
 802             }
 803             break;
 804         case 0x29:
 805             /* SUBQ */
 806             if (likely(rc != 31)) {
 807                 if (ra != 31) {
 808                     if (islit)
 809                         tcg_gen_subi_i64(cpu_ir[rc], cpu_ir[ra], lit);
 810                     else if (rb != 31)
 811                         tcg_gen_sub_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
 812                     else
 813                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);
 814                 } else {
 815                     if (islit)
 816                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
 817                     else if (rb != 31)
 818                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
 819                     else
 820                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 821                 }
 822             }
 823             break;
 824         case 0x2B:
 825             /* S4SUBQ */
 826             if (likely(rc != 31)) {
 827                 if (ra != 31) {
 828                     if (islit || rb != 31) {
 829                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 830                         tcg_gen_shli_i64(tmp, cpu_ir[ra], 2);
 831                         if (islit)
 832                             tcg_gen_subi_i64(cpu_ir[rc], tmp, lit);
 833                         else
 834                             tcg_gen_sub_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
 835                         tcg_temp_free(tmp);
 836                     } else
 837                         tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], 2);
 838                 } else {
 839                     if (islit)
 840                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
 841                     else if (rb != 31)
 842                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
 843                     else
 844                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 845                 }
 846             }
 847             break;
 848         case 0x2D:
 849             /* CMPEQ */
 850             gen_arith3(ctx, &gen_op_cmpeq, ra, rb, rc, islit, lit);
 851             break;
 852         case 0x32:
 853             /* S8ADDQ */
 854             if (likely(rc != 31)) {
 855                 if (ra != 31) {
 856                     if (islit || rb != 31) {
 857                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 858                         tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
 859                         if (islit)
 860                             tcg_gen_addi_i64(cpu_ir[rc], tmp, lit);
 861                         else
 862                             tcg_gen_add_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
 863                         tcg_temp_free(tmp);
 864                     } else
 865                         tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], 3);
 866                 } else {
 867                     if (islit)
 868                         tcg_gen_movi_i64(cpu_ir[rc], lit);
 869                     else if (rb != 31)
 870                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
 871                     else
 872                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 873                 }
 874             }
 875             break;
 876         case 0x3B:
 877             /* S8SUBQ */
 878             if (likely(rc != 31)) {
 879                 if (ra != 31) {
 880                     if (islit || rb != 31) {
 881                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 882                         tcg_gen_shli_i64(tmp, cpu_ir[ra], 3);
 883                         if (islit)
 884                             tcg_gen_subi_i64(cpu_ir[rc], tmp, lit);
 885                         else
 886                             tcg_gen_sub_i64(cpu_ir[rc], tmp, cpu_ir[rb]);
 887                         tcg_temp_free(tmp);
 888                     } else
 889                         tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], 3);
 890                 } else {
 891                     if (islit)
 892                         tcg_gen_movi_i64(cpu_ir[rc], -lit);
 893                     else if (rb != 31)
 894                         tcg_gen_neg_i64(cpu_ir[rc], cpu_ir[rb]);
 895                     else
 896                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 897                 }
 898             }
 899             break;
 900         case 0x3D:
 901             /* CMPULE */
 902             gen_arith3(ctx, &gen_op_cmpule, ra, rb, rc, islit, lit);
 903             break;
 904         case 0x40:
 905             /* ADDL/V */
 906             gen_arith3(ctx, &gen_op_addlv, ra, rb, rc, islit, lit);
 907             break;
 908         case 0x49:
 909             /* SUBL/V */
 910             gen_arith3(ctx, &gen_op_sublv, ra, rb, rc, islit, lit);
 911             break;
 912         case 0x4D:
 913             /* CMPLT */
 914             gen_arith3(ctx, &gen_op_cmplt, ra, rb, rc, islit, lit);
 915             break;
 916         case 0x60:
 917             /* ADDQ/V */
 918             gen_arith3(ctx, &gen_op_addqv, ra, rb, rc, islit, lit);
 919             break;
 920         case 0x69:
 921             /* SUBQ/V */
 922             gen_arith3(ctx, &gen_op_subqv, ra, rb, rc, islit, lit);
 923             break;
 924         case 0x6D:
 925             /* CMPLE */
 926             gen_arith3(ctx, &gen_op_cmple, ra, rb, rc, islit, lit);
 927             break;
 928         default:
 929             goto invalid_opc;
 930         }
 931         break;
 932     case 0x11:
 933         switch (fn7) {
 934         case 0x00:
 935             /* AND */
 936             if (likely(rc != 31)) {
 937                 if (ra == 31 || (rb == 31 && !islit))
 938                     tcg_gen_movi_i64(cpu_ir[rc], 0);
 939                 else if (islit)
 940                     tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[ra], lit);
 941                 else
 942                     tcg_gen_and_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
 943             }
 944             break;
 945         case 0x08:
 946             /* BIC */
 947             if (likely(rc != 31)) {
 948                 if (ra != 31) {
 949                     if (islit)
 950                         tcg_gen_andi_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
 951                     else if (rb != 31) {
 952                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
 953                         tcg_gen_not_i64(tmp, cpu_ir[rb]);
 954                         tcg_gen_and_i64(cpu_ir[rc], cpu_ir[ra], tmp);
 955                         tcg_temp_free(tmp);
 956                     } else
 957                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);
 958                 } else
 959                     tcg_gen_movi_i64(cpu_ir[rc], 0);
 960             }
 961             break;
 962         case 0x14:
 963             /* CMOVLBS */
 964             gen_cmov(ctx, TCG_COND_EQ, ra, rb, rc, islit, lit, 1);
 965             break;
 966         case 0x16:
 967             /* CMOVLBC */
 968             gen_cmov(ctx, TCG_COND_NE, ra, rb, rc, islit, lit, 1);
 969             break;
 970         case 0x20:
 971             /* BIS */
 972             if (likely(rc != 31)) {
 973                 if (ra != 31) {
 974                     if (islit)
 975                         tcg_gen_ori_i64(cpu_ir[rc], cpu_ir[ra], lit);
 976                     else if (rb != 31)
 977                         tcg_gen_or_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
 978                     else
 979                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);
 980                 } else {
 981                     if (islit)
 982                         tcg_gen_movi_i64(cpu_ir[rc], lit);
 983                     else if (rb != 31)
 984                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
 985                     else
 986                         tcg_gen_movi_i64(cpu_ir[rc], 0);
 987                 }
 988             }
 989             break;
 990         case 0x24:
 991             /* CMOVEQ */
 992             gen_cmov(ctx, TCG_COND_NE, ra, rb, rc, islit, lit, 0);
 993             break;
 994         case 0x26:
 995             /* CMOVNE */
 996             gen_cmov(ctx, TCG_COND_EQ, ra, rb, rc, islit, lit, 0);
 997             break;
 998         case 0x28:
 999             /* ORNOT */
1000             if (likely(rc != 31)) {
1001                 if (rb == 31 && !islit)
1002                     tcg_gen_movi_i64(cpu_ir[rc], ~0);
1003                 else if (ra != 31) {
1004                     if (islit)
1005                         tcg_gen_ori_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
1006                     else {
1007                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
1008                         tcg_gen_not_i64(tmp, cpu_ir[rb]);
1009                         tcg_gen_or_i64(cpu_ir[rc], cpu_ir[ra], tmp);
1010                         tcg_temp_free(tmp);
1011                     }
1012                 } else {
1013                     if (islit)
1014                         tcg_gen_movi_i64(cpu_ir[rc], ~lit);
1015                     else
1016                         tcg_gen_not_i64(cpu_ir[rc], cpu_ir[rb]);
1017                 }
1018             }
1019             break;
1020         case 0x40:
1021             /* XOR */
1022             if (likely(rc != 31)) {
1023                 if (ra != 31) {
1024                     if (islit)
1025                         tcg_gen_xori_i64(cpu_ir[rc], cpu_ir[ra], lit);
1026                     else if (rb != 31)
1027                         tcg_gen_xor_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1028                     else
1029                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);
1030                 } else {
1031                     if (islit)
1032                         tcg_gen_movi_i64(cpu_ir[rc], lit);
1033                     else if (rb != 31)
1034                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[rb]);
1035                     else
1036                         tcg_gen_movi_i64(cpu_ir[rc], 0);
1037                 }
1038             }
1039             break;
1040         case 0x44:
1041             /* CMOVLT */
1042             gen_cmov(ctx, TCG_COND_GE, ra, rb, rc, islit, lit, 0);
1043             break;
1044         case 0x46:
1045             /* CMOVGE */
1046             gen_cmov(ctx, TCG_COND_LT, ra, rb, rc, islit, lit, 0);
1047             break;
1048         case 0x48:
1049             /* EQV */
1050             if (likely(rc != 31)) {
1051                 if (ra != 31) {
1052                     if (islit)
1053                         tcg_gen_xori_i64(cpu_ir[rc], cpu_ir[ra], ~lit);
1054                     else if (rb != 31) {
1055                         TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
1056                         tcg_gen_not_i64(tmp, cpu_ir[rb]);
1057                         tcg_gen_xor_i64(cpu_ir[rc], cpu_ir[ra], tmp);
1058                         tcg_temp_free(tmp);
1059                     } else
1060                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);
1061                 } else {
1062                     if (islit)
1063                         tcg_gen_movi_i64(cpu_ir[rc], ~lit);
1064                     else if (rb != 31)
1065                         tcg_gen_not_i64(cpu_ir[rc], cpu_ir[rb]);
1066                     else
1067                         tcg_gen_movi_i64(cpu_ir[rc], ~0);
1068                 }
1069             }
1070             break;
1071         case 0x61:
1072             /* AMASK */
1073             if (likely(rc != 31)) {
1074                 if (islit)
1075                     tcg_gen_movi_i64(cpu_ir[rc], helper_amask(lit));
1076                 else if (rb != 31)
1077                     tcg_gen_helper_1_1(helper_amask, cpu_ir[rc], cpu_ir[rb]);
1078                 else
1079                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1080             }
1081             break;
1082         case 0x64:
1083             /* CMOVLE */
1084             gen_cmov(ctx, TCG_COND_GT, ra, rb, rc, islit, lit, 0);
1085             break;
1086         case 0x66:
1087             /* CMOVGT */
1088             gen_cmov(ctx, TCG_COND_LE, ra, rb, rc, islit, lit, 0);
1089             break;
1090         case 0x6C:
1091             /* IMPLVER */
1092             gen_op_load_implver();
1093             if (rc != 31)
1094                 tcg_gen_mov_i64(cpu_ir[rc], cpu_T[0]);
1095             break;
1096         default:
1097             goto invalid_opc;
1098         }
1099         break;
1100     case 0x12:
1101         switch (fn7) {
1102         case 0x02:
1103             /* MSKBL */
1104             gen_arith3(ctx, &gen_op_mskbl, ra, rb, rc, islit, lit);
1105             break;
1106         case 0x06:
1107             /* EXTBL */
1108             gen_arith3(ctx, &gen_op_extbl, ra, rb, rc, islit, lit);
1109             break;
1110         case 0x0B:
1111             /* INSBL */
1112             gen_arith3(ctx, &gen_op_insbl, ra, rb, rc, islit, lit);
1113             break;
1114         case 0x12:
1115             /* MSKWL */
1116             gen_arith3(ctx, &gen_op_mskwl, ra, rb, rc, islit, lit);
1117             break;
1118         case 0x16:
1119             /* EXTWL */
1120             gen_arith3(ctx, &gen_op_extwl, ra, rb, rc, islit, lit);
1121             break;
1122         case 0x1B:
1123             /* INSWL */
1124             gen_arith3(ctx, &gen_op_inswl, ra, rb, rc, islit, lit);
1125             break;
1126         case 0x22:
1127             /* MSKLL */
1128             gen_arith3(ctx, &gen_op_mskll, ra, rb, rc, islit, lit);
1129             break;
1130         case 0x26:
1131             /* EXTLL */
1132             gen_arith3(ctx, &gen_op_extll, ra, rb, rc, islit, lit);
1133             break;
1134         case 0x2B:
1135             /* INSLL */
1136             gen_arith3(ctx, &gen_op_insll, ra, rb, rc, islit, lit);
1137             break;
1138         case 0x30:
1139             /* ZAP */
1140             gen_arith3(ctx, &gen_op_zap, ra, rb, rc, islit, lit);
1141             break;
1142         case 0x31:
1143             /* ZAPNOT */
1144             gen_arith3(ctx, &gen_op_zapnot, ra, rb, rc, islit, lit);
1145             break;
1146         case 0x32:
1147             /* MSKQL */
1148             gen_arith3(ctx, &gen_op_mskql, ra, rb, rc, islit, lit);
1149             break;
1150         case 0x34:
1151             /* SRL */
1152             if (likely(rc != 31)) {
1153                 if (ra != 31) {
1154                     if (islit)
1155                         tcg_gen_shri_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
1156                     else if (rb != 31) {
1157                         TCGv shift = tcg_temp_new(TCG_TYPE_I64);
1158                         tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
1159                         tcg_gen_shr_i64(cpu_ir[rc], cpu_ir[ra], shift);
1160                         tcg_temp_free(shift);
1161                     } else
1162                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);
1163                 } else
1164                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1165             }
1166             break;
1167         case 0x36:
1168             /* EXTQL */
1169             gen_arith3(ctx, &gen_op_extql, ra, rb, rc, islit, lit);
1170             break;
1171         case 0x39:
1172             /* SLL */
1173             if (likely(rc != 31)) {
1174                 if (ra != 31) {
1175                     if (islit)
1176                         tcg_gen_shli_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
1177                     else if (rb != 31) {
1178                         TCGv shift = tcg_temp_new(TCG_TYPE_I64);
1179                         tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
1180                         tcg_gen_shl_i64(cpu_ir[rc], cpu_ir[ra], shift);
1181                         tcg_temp_free(shift);
1182                     } else
1183                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);
1184                 } else
1185                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1186             }
1187             break;
1188         case 0x3B:
1189             /* INSQL */
1190             gen_arith3(ctx, &gen_op_insql, ra, rb, rc, islit, lit);
1191             break;
1192         case 0x3C:
1193             /* SRA */
1194             if (likely(rc != 31)) {
1195                 if (ra != 31) {
1196                     if (islit)
1197                         tcg_gen_sari_i64(cpu_ir[rc], cpu_ir[ra], lit & 0x3f);
1198                     else if (rb != 31) {
1199                         TCGv shift = tcg_temp_new(TCG_TYPE_I64);
1200                         tcg_gen_andi_i64(shift, cpu_ir[rb], 0x3f);
1201                         tcg_gen_sar_i64(cpu_ir[rc], cpu_ir[ra], shift);
1202                         tcg_temp_free(shift);
1203                     } else
1204                         tcg_gen_mov_i64(cpu_ir[rc], cpu_ir[ra]);
1205                 } else
1206                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1207             }
1208             break;
1209         case 0x52:
1210             /* MSKWH */
1211             gen_arith3(ctx, &gen_op_mskwh, ra, rb, rc, islit, lit);
1212             break;
1213         case 0x57:
1214             /* INSWH */
1215             gen_arith3(ctx, &gen_op_inswh, ra, rb, rc, islit, lit);
1216             break;
1217         case 0x5A:
1218             /* EXTWH */
1219             gen_arith3(ctx, &gen_op_extwh, ra, rb, rc, islit, lit);
1220             break;
1221         case 0x62:
1222             /* MSKLH */
1223             gen_arith3(ctx, &gen_op_msklh, ra, rb, rc, islit, lit);
1224             break;
1225         case 0x67:
1226             /* INSLH */
1227             gen_arith3(ctx, &gen_op_inslh, ra, rb, rc, islit, lit);
1228             break;
1229         case 0x6A:
1230             /* EXTLH */
1231             gen_arith3(ctx, &gen_op_extlh, ra, rb, rc, islit, lit);
1232             break;
1233         case 0x72:
1234             /* MSKQH */
1235             gen_arith3(ctx, &gen_op_mskqh, ra, rb, rc, islit, lit);
1236             break;
1237         case 0x77:
1238             /* INSQH */
1239             gen_arith3(ctx, &gen_op_insqh, ra, rb, rc, islit, lit);
1240             break;
1241         case 0x7A:
1242             /* EXTQH */
1243             gen_arith3(ctx, &gen_op_extqh, ra, rb, rc, islit, lit);
1244             break;
1245         default:
1246             goto invalid_opc;
1247         }
1248         break;
1249     case 0x13:
1250         switch (fn7) {
1251         case 0x00:
1252             /* MULL */
1253             if (likely(rc != 31)) {
1254                 if (ra == 31 || (rb == 31 && !islit))
1255                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1256                 else {
1257                     if (islit)
1258                         tcg_gen_muli_i64(cpu_ir[rc], cpu_ir[ra], lit);
1259                     else
1260                         tcg_gen_mul_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1261                     tcg_gen_ext32s_i64(cpu_ir[rc], cpu_ir[rc]);
1262                 }
1263             }
1264             break;
1265         case 0x20:
1266             /* MULQ */
1267             if (likely(rc != 31)) {
1268                 if (ra == 31 || (rb == 31 && !islit))
1269                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1270                 else if (islit)
1271                     tcg_gen_muli_i64(cpu_ir[rc], cpu_ir[ra], lit);
1272                 else
1273                     tcg_gen_mul_i64(cpu_ir[rc], cpu_ir[ra], cpu_ir[rb]);
1274             }
1275             break;
1276         case 0x30:
1277             /* UMULH */
1278             gen_arith3(ctx, &gen_op_umulh, ra, rb, rc, islit, lit);
1279             break;
1280         case 0x40:
1281             /* MULL/V */
1282             gen_arith3(ctx, &gen_op_mullv, ra, rb, rc, islit, lit);
1283             break;
1284         case 0x60:
1285             /* MULQ/V */
1286             gen_arith3(ctx, &gen_op_mulqv, ra, rb, rc, islit, lit);
1287             break;
1288         default:
1289             goto invalid_opc;
1290         }
1291         break;
1292     case 0x14:
1293         switch (fpfn) { /* f11 & 0x3F */
1294         case 0x04:
1295             /* ITOFS */
1296             if (!(ctx->amask & AMASK_FIX))
1297                 goto invalid_opc;
1298             gen_itf(ctx, &gen_op_itofs, ra, rc);
1299             break;
1300         case 0x0A:
1301             /* SQRTF */
1302             if (!(ctx->amask & AMASK_FIX))
1303                 goto invalid_opc;
1304             gen_farith2(ctx, &gen_op_sqrtf, rb, rc);
1305             break;
1306         case 0x0B:
1307             /* SQRTS */
1308             if (!(ctx->amask & AMASK_FIX))
1309                 goto invalid_opc;
1310             gen_farith2(ctx, &gen_op_sqrts, rb, rc);
1311             break;
1312         case 0x14:
1313             /* ITOFF */
1314             if (!(ctx->amask & AMASK_FIX))
1315                 goto invalid_opc;
1316 #if 0 // TODO
1317             gen_itf(ctx, &gen_op_itoff, ra, rc);
1318 #else
1319             goto invalid_opc;
1320 #endif
1321             break;
1322         case 0x24:
1323             /* ITOFT */
1324             if (!(ctx->amask & AMASK_FIX))
1325                 goto invalid_opc;
1326             gen_itf(ctx, &gen_op_itoft, ra, rc);
1327             break;
1328         case 0x2A:
1329             /* SQRTG */
1330             if (!(ctx->amask & AMASK_FIX))
1331                 goto invalid_opc;
1332             gen_farith2(ctx, &gen_op_sqrtg, rb, rc);
1333             break;
1334         case 0x02B:
1335             /* SQRTT */
1336             if (!(ctx->amask & AMASK_FIX))
1337                 goto invalid_opc;
1338             gen_farith2(ctx, &gen_op_sqrtt, rb, rc);
1339             break;
1340         default:
1341             goto invalid_opc;
1342         }
1343         break;
1344     case 0x15:
1345         /* VAX floating point */
1346         /* XXX: rounding mode and trap are ignored (!) */
1347         switch (fpfn) { /* f11 & 0x3F */
1348         case 0x00:
1349             /* ADDF */
1350             gen_farith3(ctx, &gen_op_addf, ra, rb, rc);
1351             break;
1352         case 0x01:
1353             /* SUBF */
1354             gen_farith3(ctx, &gen_op_subf, ra, rb, rc);
1355             break;
1356         case 0x02:
1357             /* MULF */
1358             gen_farith3(ctx, &gen_op_mulf, ra, rb, rc);
1359             break;
1360         case 0x03:
1361             /* DIVF */
1362             gen_farith3(ctx, &gen_op_divf, ra, rb, rc);
1363             break;
1364         case 0x1E:
1365             /* CVTDG */
1366 #if 0 // TODO
1367             gen_farith2(ctx, &gen_op_cvtdg, rb, rc);
1368 #else
1369             goto invalid_opc;
1370 #endif
1371             break;
1372         case 0x20:
1373             /* ADDG */
1374             gen_farith3(ctx, &gen_op_addg, ra, rb, rc);
1375             break;
1376         case 0x21:
1377             /* SUBG */
1378             gen_farith3(ctx, &gen_op_subg, ra, rb, rc);
1379             break;
1380         case 0x22:
1381             /* MULG */
1382             gen_farith3(ctx, &gen_op_mulg, ra, rb, rc);
1383             break;
1384         case 0x23:
1385             /* DIVG */
1386             gen_farith3(ctx, &gen_op_divg, ra, rb, rc);
1387             break;
1388         case 0x25:
1389             /* CMPGEQ */
1390             gen_farith3(ctx, &gen_op_cmpgeq, ra, rb, rc);
1391             break;
1392         case 0x26:
1393             /* CMPGLT */
1394             gen_farith3(ctx, &gen_op_cmpglt, ra, rb, rc);
1395             break;
1396         case 0x27:
1397             /* CMPGLE */
1398             gen_farith3(ctx, &gen_op_cmpgle, ra, rb, rc);
1399             break;
1400         case 0x2C:
1401             /* CVTGF */
1402             gen_farith2(ctx, &gen_op_cvtgf, rb, rc);
1403             break;
1404         case 0x2D:
1405             /* CVTGD */
1406 #if 0 // TODO
1407             gen_farith2(ctx, &gen_op_cvtgd, rb, rc);
1408 #else
1409             goto invalid_opc;
1410 #endif
1411             break;
1412         case 0x2F:
1413             /* CVTGQ */
1414             gen_farith2(ctx, &gen_op_cvtgq, rb, rc);
1415             break;
1416         case 0x3C:
1417             /* CVTQF */
1418             gen_farith2(ctx, &gen_op_cvtqf, rb, rc);
1419             break;
1420         case 0x3E:
1421             /* CVTQG */
1422             gen_farith2(ctx, &gen_op_cvtqg, rb, rc);
1423             break;
1424         default:
1425             goto invalid_opc;
1426         }
1427         break;
1428     case 0x16:
1429         /* IEEE floating-point */
1430         /* XXX: rounding mode and traps are ignored (!) */
1431         switch (fpfn) { /* f11 & 0x3F */
1432         case 0x00:
1433             /* ADDS */
1434             gen_farith3(ctx, &gen_op_adds, ra, rb, rc);
1435             break;
1436         case 0x01:
1437             /* SUBS */
1438             gen_farith3(ctx, &gen_op_subs, ra, rb, rc);
1439             break;
1440         case 0x02:
1441             /* MULS */
1442             gen_farith3(ctx, &gen_op_muls, ra, rb, rc);
1443             break;
1444         case 0x03:
1445             /* DIVS */
1446             gen_farith3(ctx, &gen_op_divs, ra, rb, rc);
1447             break;
1448         case 0x20:
1449             /* ADDT */
1450             gen_farith3(ctx, &gen_op_addt, ra, rb, rc);
1451             break;
1452         case 0x21:
1453             /* SUBT */
1454             gen_farith3(ctx, &gen_op_subt, ra, rb, rc);
1455             break;
1456         case 0x22:
1457             /* MULT */
1458             gen_farith3(ctx, &gen_op_mult, ra, rb, rc);
1459             break;
1460         case 0x23:
1461             /* DIVT */
1462             gen_farith3(ctx, &gen_op_divt, ra, rb, rc);
1463             break;
1464         case 0x24:
1465             /* CMPTUN */
1466             gen_farith3(ctx, &gen_op_cmptun, ra, rb, rc);
1467             break;
1468         case 0x25:
1469             /* CMPTEQ */
1470             gen_farith3(ctx, &gen_op_cmpteq, ra, rb, rc);
1471             break;
1472         case 0x26:
1473             /* CMPTLT */
1474             gen_farith3(ctx, &gen_op_cmptlt, ra, rb, rc);
1475             break;
1476         case 0x27:
1477             /* CMPTLE */
1478             gen_farith3(ctx, &gen_op_cmptle, ra, rb, rc);
1479             break;
1480         case 0x2C:
1481             /* XXX: incorrect */
1482             if (fn11 == 0x2AC) {
1483                 /* CVTST */
1484                 gen_farith2(ctx, &gen_op_cvtst, rb, rc);
1485             } else {
1486                 /* CVTTS */
1487                 gen_farith2(ctx, &gen_op_cvtts, rb, rc);
1488             }
1489             break;
1490         case 0x2F:
1491             /* CVTTQ */
1492             gen_farith2(ctx, &gen_op_cvttq, rb, rc);
1493             break;
1494         case 0x3C:
1495             /* CVTQS */
1496             gen_farith2(ctx, &gen_op_cvtqs, rb, rc);
1497             break;
1498         case 0x3E:
1499             /* CVTQT */
1500             gen_farith2(ctx, &gen_op_cvtqt, rb, rc);
1501             break;
1502         default:
1503             goto invalid_opc;
1504         }
1505         break;
1506     case 0x17:
1507         switch (fn11) {
1508         case 0x010:
1509             /* CVTLQ */
1510             gen_farith2(ctx, &gen_op_cvtlq, rb, rc);
1511             break;
1512         case 0x020:
1513             /* CPYS */
1514             if (ra == rb) {
1515                 if (ra == 31 && rc == 31) {
1516                     /* FNOP */
1517                     gen_op_nop();
1518                 } else {
1519                     /* FMOV */
1520                     gen_load_fir(ctx, rb, 0);
1521                     gen_store_fir(ctx, rc, 0);
1522                 }
1523             } else {
1524                 gen_farith3(ctx, &gen_op_cpys, ra, rb, rc);
1525             }
1526             break;
1527         case 0x021:
1528             /* CPYSN */
1529             gen_farith2(ctx, &gen_op_cpysn, rb, rc);
1530             break;
1531         case 0x022:
1532             /* CPYSE */
1533             gen_farith2(ctx, &gen_op_cpyse, rb, rc);
1534             break;
1535         case 0x024:
1536             /* MT_FPCR */
1537             gen_load_fir(ctx, ra, 0);
1538             gen_op_store_fpcr();
1539             break;
1540         case 0x025:
1541             /* MF_FPCR */
1542             gen_op_load_fpcr();
1543             gen_store_fir(ctx, ra, 0);
1544             break;
1545         case 0x02A:
1546             /* FCMOVEQ */
1547             gen_fcmov(ctx, &gen_op_cmpfeq, ra, rb, rc);
1548             break;
1549         case 0x02B:
1550             /* FCMOVNE */
1551             gen_fcmov(ctx, &gen_op_cmpfne, ra, rb, rc);
1552             break;
1553         case 0x02C:
1554             /* FCMOVLT */
1555             gen_fcmov(ctx, &gen_op_cmpflt, ra, rb, rc);
1556             break;
1557         case 0x02D:
1558             /* FCMOVGE */
1559             gen_fcmov(ctx, &gen_op_cmpfge, ra, rb, rc);
1560             break;
1561         case 0x02E:
1562             /* FCMOVLE */
1563             gen_fcmov(ctx, &gen_op_cmpfle, ra, rb, rc);
1564             break;
1565         case 0x02F:
1566             /* FCMOVGT */
1567             gen_fcmov(ctx, &gen_op_cmpfgt, ra, rb, rc);
1568             break;
1569         case 0x030:
1570             /* CVTQL */
1571             gen_farith2(ctx, &gen_op_cvtql, rb, rc);
1572             break;
1573         case 0x130:
1574             /* CVTQL/V */
1575             gen_farith2(ctx, &gen_op_cvtqlv, rb, rc);
1576             break;
1577         case 0x530:
1578             /* CVTQL/SV */
1579             gen_farith2(ctx, &gen_op_cvtqlsv, rb, rc);
1580             break;
1581         default:
1582             goto invalid_opc;
1583         }
1584         break;
1585     case 0x18:
1586         switch ((uint16_t)disp16) {
1587         case 0x0000:
1588             /* TRAPB */
1589             /* No-op. Just exit from the current tb */
1590             ret = 2;
1591             break;
1592         case 0x0400:
1593             /* EXCB */
1594             /* No-op. Just exit from the current tb */
1595             ret = 2;
1596             break;
1597         case 0x4000:
1598             /* MB */
1599             /* No-op */
1600             break;
1601         case 0x4400:
1602             /* WMB */
1603             /* No-op */
1604             break;
1605         case 0x8000:
1606             /* FETCH */
1607             /* No-op */
1608             break;
1609         case 0xA000:
1610             /* FETCH_M */
1611             /* No-op */
1612             break;
1613         case 0xC000:
1614             /* RPCC */
1615             gen_op_load_pcc();
1616             if (ra != 31)
1617                 tcg_gen_mov_i64(cpu_ir[ra], cpu_T[0]);
1618             break;
1619         case 0xE000:
1620             /* RC */
1621             gen_op_load_irf();
1622             if (ra != 31)
1623                 tcg_gen_mov_i64(cpu_ir[ra], cpu_T[0]);
1624             gen_op_clear_irf();
1625             break;
1626         case 0xE800:
1627             /* ECB */
1628             /* XXX: TODO: evict tb cache at address rb */
1629 #if 0
1630             ret = 2;
1631 #else
1632             goto invalid_opc;
1633 #endif
1634             break;
1635         case 0xF000:
1636             /* RS */
1637             gen_op_load_irf();
1638             if (ra != 31)
1639                 tcg_gen_mov_i64(cpu_ir[ra], cpu_T[0]);
1640             gen_op_set_irf();
1641             break;
1642         case 0xF800:
1643             /* WH64 */
1644             /* No-op */
1645             break;
1646         default:
1647             goto invalid_opc;
1648         }
1649         break;
1650     case 0x19:
1651         /* HW_MFPR (PALcode) */
1652 #if defined (CONFIG_USER_ONLY)
1653         goto invalid_opc;
1654 #else
1655         if (!ctx->pal_mode)
1656             goto invalid_opc;
1657         gen_op_mfpr(insn & 0xFF);
1658         if (ra != 31)
1659             tcg_gen_mov_i64(cpu_ir[ra], cpu_T[0]);
1660         break;
1661 #endif
1662     case 0x1A:
1663         if (ra != 31)
1664             tcg_gen_movi_i64(cpu_ir[ra], ctx->pc);
1665         if (rb != 31)
1666             tcg_gen_andi_i64(cpu_pc, cpu_ir[rb], ~3);
1667         else
1668             tcg_gen_movi_i64(cpu_pc, 0);
1669         /* Those four jumps only differ by the branch prediction hint */
1670         switch (fn2) {
1671         case 0x0:
1672             /* JMP */
1673             break;
1674         case 0x1:
1675             /* JSR */
1676             break;
1677         case 0x2:
1678             /* RET */
1679             break;
1680         case 0x3:
1681             /* JSR_COROUTINE */
1682             break;
1683         }
1684         ret = 1;
1685         break;
1686     case 0x1B:
1687         /* HW_LD (PALcode) */
1688 #if defined (CONFIG_USER_ONLY)
1689         goto invalid_opc;
1690 #else
1691         if (!ctx->pal_mode)
1692             goto invalid_opc;
1693         if (rb != 31)
1694             tcg_gen_mov_i64(cpu_T[0], cpu_ir[rb]);
1695         else
1696             tcg_gen_movi_i64(cpu_T[0], 0);
1697         tcg_gen_movi_i64(cpu_T[1], disp12);
1698         tcg_gen_add_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
1699         switch ((insn >> 12) & 0xF) {
1700         case 0x0:
1701             /* Longword physical access */
1702             gen_op_ldl_raw();
1703             break;
1704         case 0x1:
1705             /* Quadword physical access */
1706             gen_op_ldq_raw();
1707             break;
1708         case 0x2:
1709             /* Longword physical access with lock */
1710             gen_op_ldl_l_raw();
1711             break;
1712         case 0x3:
1713             /* Quadword physical access with lock */
1714             gen_op_ldq_l_raw();
1715             break;
1716         case 0x4:
1717             /* Longword virtual PTE fetch */
1718             gen_op_ldl_kernel();
1719             break;
1720         case 0x5:
1721             /* Quadword virtual PTE fetch */
1722             gen_op_ldq_kernel();
1723             break;
1724         case 0x6:
1725             /* Invalid */
1726             goto invalid_opc;
1727         case 0x7:
1728             /* Invalid */
1729             goto invalid_opc;
1730         case 0x8:
1731             /* Longword virtual access */
1732             gen_op_ld_phys_to_virt();
1733             gen_op_ldl_raw();
1734             break;
1735         case 0x9:
1736             /* Quadword virtual access */
1737             gen_op_ld_phys_to_virt();
1738             gen_op_ldq_raw();
1739             break;
1740         case 0xA:
1741             /* Longword virtual access with protection check */
1742             gen_ldl(ctx);
1743             break;
1744         case 0xB:
1745             /* Quadword virtual access with protection check */
1746             gen_ldq(ctx);
1747             break;
1748         case 0xC:
1749             /* Longword virtual access with altenate access mode */
1750             gen_op_set_alt_mode();
1751             gen_op_ld_phys_to_virt();
1752             gen_op_ldl_raw();
1753             gen_op_restore_mode();
1754             break;
1755         case 0xD:
1756             /* Quadword virtual access with altenate access mode */
1757             gen_op_set_alt_mode();
1758             gen_op_ld_phys_to_virt();
1759             gen_op_ldq_raw();
1760             gen_op_restore_mode();
1761             break;
1762         case 0xE:
1763             /* Longword virtual access with alternate access mode and
1764              * protection checks
1765              */
1766             gen_op_set_alt_mode();
1767             gen_op_ldl_data();
1768             gen_op_restore_mode();
1769             break;
1770         case 0xF:
1771             /* Quadword virtual access with alternate access mode and
1772              * protection checks
1773              */
1774             gen_op_set_alt_mode();
1775             gen_op_ldq_data();
1776             gen_op_restore_mode();
1777             break;
1778         }
1779         if (ra != 31)
1780             tcg_gen_mov_i64(cpu_ir[ra], cpu_T[1]);
1781         break;
1782 #endif
1783     case 0x1C:
1784         switch (fn7) {
1785         case 0x00:
1786             /* SEXTB */
1787             if (!(ctx->amask & AMASK_BWX))
1788                 goto invalid_opc;
1789             if (likely(rc != 31)) {
1790                 if (islit)
1791                     tcg_gen_movi_i64(cpu_ir[rc], (int64_t)((int8_t)lit));
1792                 else if (rb != 31)
1793                     tcg_gen_ext8s_i64(cpu_ir[rc], cpu_ir[rb]);
1794                 else
1795                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1796             }
1797             break;
1798         case 0x01:
1799             /* SEXTW */
1800             if (!(ctx->amask & AMASK_BWX))
1801                 goto invalid_opc;
1802             if (likely(rc != 31)) {
1803                 if (islit)
1804                     tcg_gen_movi_i64(cpu_ir[rc], (int64_t)((int16_t)lit));
1805                 else if (rb != 31)
1806                     tcg_gen_ext16s_i64(cpu_ir[rc], cpu_ir[rb]);
1807                 else
1808                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1809             }
1810             break;
1811         case 0x30:
1812             /* CTPOP */
1813             if (!(ctx->amask & AMASK_CIX))
1814                 goto invalid_opc;
1815             if (likely(rc != 31)) {
1816                 if (islit)
1817                     tcg_gen_movi_i64(cpu_ir[rc], ctpop64(lit));
1818                 else if (rb != 31)
1819                     tcg_gen_helper_1_1(helper_ctpop, cpu_ir[rc], cpu_ir[rb]);
1820                 else
1821                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1822             }
1823             break;
1824         case 0x31:
1825             /* PERR */
1826             if (!(ctx->amask & AMASK_MVI))
1827                 goto invalid_opc;
1828             /* XXX: TODO */
1829             goto invalid_opc;
1830             break;
1831         case 0x32:
1832             /* CTLZ */
1833             if (!(ctx->amask & AMASK_CIX))
1834                 goto invalid_opc;
1835             if (likely(rc != 31)) {
1836                 if (islit)
1837                     tcg_gen_movi_i64(cpu_ir[rc], clz64(lit));
1838                 else if (rb != 31)
1839                     tcg_gen_helper_1_1(helper_ctlz, cpu_ir[rc], cpu_ir[rb]);
1840                 else
1841                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1842             }
1843             break;
1844         case 0x33:
1845             /* CTTZ */
1846             if (!(ctx->amask & AMASK_CIX))
1847                 goto invalid_opc;
1848             if (likely(rc != 31)) {
1849                 if (islit)
1850                     tcg_gen_movi_i64(cpu_ir[rc], ctz64(lit));
1851                 else if (rb != 31)
1852                     tcg_gen_helper_1_1(helper_cttz, cpu_ir[rc], cpu_ir[rb]);
1853                 else
1854                     tcg_gen_movi_i64(cpu_ir[rc], 0);
1855             }
1856             break;
1857         case 0x34:
1858             /* UNPKBW */
1859             if (!(ctx->amask & AMASK_MVI))
1860                 goto invalid_opc;
1861             /* XXX: TODO */
1862             goto invalid_opc;
1863             break;
1864         case 0x35:
1865             /* UNPKWL */
1866             if (!(ctx->amask & AMASK_MVI))
1867                 goto invalid_opc;
1868             /* XXX: TODO */
1869             goto invalid_opc;
1870             break;
1871         case 0x36:
1872             /* PKWB */
1873             if (!(ctx->amask & AMASK_MVI))
1874                 goto invalid_opc;
1875             /* XXX: TODO */
1876             goto invalid_opc;
1877             break;
1878         case 0x37:
1879             /* PKLB */
1880             if (!(ctx->amask & AMASK_MVI))
1881                 goto invalid_opc;
1882             /* XXX: TODO */
1883             goto invalid_opc;
1884             break;
1885         case 0x38:
1886             /* MINSB8 */
1887             if (!(ctx->amask & AMASK_MVI))
1888                 goto invalid_opc;
1889             /* XXX: TODO */
1890             goto invalid_opc;
1891             break;
1892         case 0x39:
1893             /* MINSW4 */
1894             if (!(ctx->amask & AMASK_MVI))
1895                 goto invalid_opc;
1896             /* XXX: TODO */
1897             goto invalid_opc;
1898             break;
1899         case 0x3A:
1900             /* MINUB8 */
1901             if (!(ctx->amask & AMASK_MVI))
1902                 goto invalid_opc;
1903             /* XXX: TODO */
1904             goto invalid_opc;
1905             break;
1906         case 0x3B:
1907             /* MINUW4 */
1908             if (!(ctx->amask & AMASK_MVI))
1909                 goto invalid_opc;
1910             /* XXX: TODO */
1911             goto invalid_opc;
1912             break;
1913         case 0x3C:
1914             /* MAXUB8 */
1915             if (!(ctx->amask & AMASK_MVI))
1916                 goto invalid_opc;
1917             /* XXX: TODO */
1918             goto invalid_opc;
1919             break;
1920         case 0x3D:
1921             /* MAXUW4 */
1922             if (!(ctx->amask & AMASK_MVI))
1923                 goto invalid_opc;
1924             /* XXX: TODO */
1925             goto invalid_opc;
1926             break;
1927         case 0x3E:
1928             /* MAXSB8 */
1929             if (!(ctx->amask & AMASK_MVI))
1930                 goto invalid_opc;
1931             /* XXX: TODO */
1932             goto invalid_opc;
1933             break;
1934         case 0x3F:
1935             /* MAXSW4 */
1936             if (!(ctx->amask & AMASK_MVI))
1937                 goto invalid_opc;
1938             /* XXX: TODO */
1939             goto invalid_opc;
1940             break;
1941         case 0x70:
1942             /* FTOIT */
1943             if (!(ctx->amask & AMASK_FIX))
1944                 goto invalid_opc;
1945             gen_fti(ctx, &gen_op_ftoit, ra, rb);
1946             break;
1947         case 0x78:
1948             /* FTOIS */
1949             if (!(ctx->amask & AMASK_FIX))
1950                 goto invalid_opc;
1951             gen_fti(ctx, &gen_op_ftois, ra, rb);
1952             break;
1953         default:
1954             goto invalid_opc;
1955         }
1956         break;
1957     case 0x1D:
1958         /* HW_MTPR (PALcode) */
1959 #if defined (CONFIG_USER_ONLY)
1960         goto invalid_opc;
1961 #else
1962         if (!ctx->pal_mode)
1963             goto invalid_opc;
1964         if (ra != 31)
1965             tcg_gen_mov_i64(cpu_T[0], cpu_ir[ra]);
1966         else
1967             tcg_gen_movi_i64(cpu_T[0], 0);
1968         gen_op_mtpr(insn & 0xFF);
1969         ret = 2;
1970         break;
1971 #endif
1972     case 0x1E:
1973         /* HW_REI (PALcode) */
1974 #if defined (CONFIG_USER_ONLY)
1975         goto invalid_opc;
1976 #else
1977         if (!ctx->pal_mode)
1978             goto invalid_opc;
1979         if (rb == 31) {
1980             /* "Old" alpha */
1981             gen_op_hw_rei();
1982         } else {
1983             if (ra != 31)
1984                 tcg_gen_mov_i64(cpu_T[0], cpu_ir[rb]);
1985             else
1986                 tcg_gen_movi_i64(cpu_T[0], 0);
1987             tcg_gen_movi_i64(cpu_T[1], (((int64_t)insn << 51) >> 51));
1988             tcg_gen_add_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
1989             gen_op_hw_ret();
1990         }
1991         ret = 2;
1992         break;
1993 #endif
1994     case 0x1F:
1995         /* HW_ST (PALcode) */
1996 #if defined (CONFIG_USER_ONLY)
1997         goto invalid_opc;
1998 #else
1999         if (!ctx->pal_mode)
2000             goto invalid_opc;
2001         if (ra != 31)
2002             tcg_gen_addi_i64(cpu_T[0], cpu_ir[rb], disp12);
2003         else
2004             tcg_gen_movi_i64(cpu_T[0], disp12);
2005         if (ra != 31)
2006             tcg_gen_mov_i64(cpu_T[1], cpu_ir[ra]);
2007         else
2008             tcg_gen_movi_i64(cpu_T[1], 0);
2009         switch ((insn >> 12) & 0xF) {
2010         case 0x0:
2011             /* Longword physical access */
2012             gen_op_stl_raw();
2013             break;
2014         case 0x1:
2015             /* Quadword physical access */
2016             gen_op_stq_raw();
2017             break;
2018         case 0x2:
2019             /* Longword physical access with lock */
2020             gen_op_stl_c_raw();
2021             break;
2022         case 0x3:
2023             /* Quadword physical access with lock */
2024             gen_op_stq_c_raw();
2025             break;
2026         case 0x4:
2027             /* Longword virtual access */
2028             gen_op_st_phys_to_virt();
2029             gen_op_stl_raw();
2030             break;
2031         case 0x5:
2032             /* Quadword virtual access */
2033             gen_op_st_phys_to_virt();
2034             gen_op_stq_raw();
2035             break;
2036         case 0x6:
2037             /* Invalid */
2038             goto invalid_opc;
2039         case 0x7:
2040             /* Invalid */
2041             goto invalid_opc;
2042         case 0x8:
2043             /* Invalid */
2044             goto invalid_opc;
2045         case 0x9:
2046             /* Invalid */
2047             goto invalid_opc;
2048         case 0xA:
2049             /* Invalid */
2050             goto invalid_opc;
2051         case 0xB:
2052             /* Invalid */
2053             goto invalid_opc;
2054         case 0xC:
2055             /* Longword virtual access with alternate access mode */
2056             gen_op_set_alt_mode();
2057             gen_op_st_phys_to_virt();
2058             gen_op_ldl_raw();
2059             gen_op_restore_mode();
2060             break;
2061         case 0xD:
2062             /* Quadword virtual access with alternate access mode */
2063             gen_op_set_alt_mode();
2064             gen_op_st_phys_to_virt();
2065             gen_op_ldq_raw();
2066             gen_op_restore_mode();
2067             break;
2068         case 0xE:
2069             /* Invalid */
2070             goto invalid_opc;
2071         case 0xF:
2072             /* Invalid */
2073             goto invalid_opc;
2074         }
2075         ret = 2;
2076         break;
2077 #endif
2078     case 0x20:
2079         /* LDF */
2080 #if 0 // TODO
2081         gen_load_fmem(ctx, &gen_ldf, ra, rb, disp16);
2082 #else
2083         goto invalid_opc;
2084 #endif
2085         break;
2086     case 0x21:
2087         /* LDG */
2088 #if 0 // TODO
2089         gen_load_fmem(ctx, &gen_ldg, ra, rb, disp16);
2090 #else
2091         goto invalid_opc;
2092 #endif
2093         break;
2094     case 0x22:
2095         /* LDS */
2096         gen_load_fmem(ctx, &gen_lds, ra, rb, disp16);
2097         break;
2098     case 0x23:
2099         /* LDT */
2100         gen_load_fmem(ctx, &gen_ldt, ra, rb, disp16);
2101         break;
2102     case 0x24:
2103         /* STF */
2104 #if 0 // TODO
2105         gen_store_fmem(ctx, &gen_stf, ra, rb, disp16);
2106 #else
2107         goto invalid_opc;
2108 #endif
2109         break;
2110     case 0x25:
2111         /* STG */
2112 #if 0 // TODO
2113         gen_store_fmem(ctx, &gen_stg, ra, rb, disp16);
2114 #else
2115         goto invalid_opc;
2116 #endif
2117         break;
2118     case 0x26:
2119         /* STS */
2120         gen_store_fmem(ctx, &gen_sts, ra, rb, disp16);
2121         break;
2122     case 0x27:
2123         /* STT */
2124         gen_store_fmem(ctx, &gen_stt, ra, rb, disp16);
2125         break;
2126     case 0x28:
2127         /* LDL */
2128         gen_load_mem(ctx, &gen_ldl, ra, rb, disp16, 0);
2129         break;
2130     case 0x29:
2131         /* LDQ */
2132         gen_load_mem(ctx, &gen_ldq, ra, rb, disp16, 0);
2133         break;
2134     case 0x2A:
2135         /* LDL_L */
2136         gen_load_mem(ctx, &gen_ldl_l, ra, rb, disp16, 0);
2137         break;
2138     case 0x2B:
2139         /* LDQ_L */
2140         gen_load_mem(ctx, &gen_ldq_l, ra, rb, disp16, 0);
2141         break;
2142     case 0x2C:
2143         /* STL */
2144         gen_store_mem(ctx, &gen_stl, ra, rb, disp16, 0);
2145         break;
2146     case 0x2D:
2147         /* STQ */
2148         gen_store_mem(ctx, &gen_stq, ra, rb, disp16, 0);
2149         break;
2150     case 0x2E:
2151         /* STL_C */
2152         gen_store_mem(ctx, &gen_stl_c, ra, rb, disp16, 0);
2153         break;
2154     case 0x2F:
2155         /* STQ_C */
2156         gen_store_mem(ctx, &gen_stq_c, ra, rb, disp16, 0);
2157         break;
2158     case 0x30:
2159         /* BR */
2160         if (ra != 31)
2161             tcg_gen_movi_i64(cpu_ir[ra], ctx->pc);
2162         tcg_gen_movi_i64(cpu_pc, ctx->pc + (int64_t)(disp21 << 2));
2163         ret = 1;
2164         break;
2165     case 0x31:
2166         /* FBEQ */
2167         gen_fbcond(ctx, &gen_op_cmpfeq, ra, disp16);
2168         ret = 1;
2169         break;
2170     case 0x32:
2171         /* FBLT */
2172         gen_fbcond(ctx, &gen_op_cmpflt, ra, disp16);
2173         ret = 1;
2174         break;
2175     case 0x33:
2176         /* FBLE */
2177         gen_fbcond(ctx, &gen_op_cmpfle, ra, disp16);
2178         ret = 1;
2179         break;
2180     case 0x34:
2181         /* BSR */
2182         if (ra != 31)
2183             tcg_gen_movi_i64(cpu_ir[ra], ctx->pc);
2184         tcg_gen_movi_i64(cpu_pc, ctx->pc + (int64_t)(disp21 << 2));
2185         ret = 1;
2186         break;
2187     case 0x35:
2188         /* FBNE */
2189         gen_fbcond(ctx, &gen_op_cmpfne, ra, disp16);
2190         ret = 1;
2191         break;
2192     case 0x36:
2193         /* FBGE */
2194         gen_fbcond(ctx, &gen_op_cmpfge, ra, disp16);
2195         ret = 1;
2196         break;
2197     case 0x37:
2198         /* FBGT */
2199         gen_fbcond(ctx, &gen_op_cmpfgt, ra, disp16);
2200         ret = 1;
2201         break;
2202     case 0x38:
2203         /* BLBC */
2204         gen_bcond(ctx, TCG_COND_EQ, ra, disp16, 1);
2205         ret = 1;
2206         break;
2207     case 0x39:
2208         /* BEQ */
2209         gen_bcond(ctx, TCG_COND_EQ, ra, disp16, 0);
2210         ret = 1;
2211         break;
2212     case 0x3A:
2213         /* BLT */
2214         gen_bcond(ctx, TCG_COND_LT, ra, disp16, 0);
2215         ret = 1;
2216         break;
2217     case 0x3B:
2218         /* BLE */
2219         gen_bcond(ctx, TCG_COND_LE, ra, disp16, 0);
2220         ret = 1;
2221         break;
2222     case 0x3C:
2223         /* BLBS */
2224         gen_bcond(ctx, TCG_COND_NE, ra, disp16, 1);
2225         ret = 1;
2226         break;
2227     case 0x3D:
2228         /* BNE */
2229         gen_bcond(ctx, TCG_COND_NE, ra, disp16, 0);
2230         ret = 1;
2231         break;
2232     case 0x3E:
2233         /* BGE */
2234         gen_bcond(ctx, TCG_COND_GE, ra, disp16, 0);
2235         ret = 1;
2236         break;
2237     case 0x3F:
2238         /* BGT */
2239         gen_bcond(ctx, TCG_COND_GT, ra, disp16, 0);
2240         ret = 1;
2241         break;
2242     invalid_opc:
2243         gen_invalid(ctx);
2244         ret = 3;
2245         break;
2246     }
2247
2248     return ret;
2249 }
2250
2251 static always_inline void gen_intermediate_code_internal (CPUState *env,
2252                                                           TranslationBlock *tb,
2253                                                           int search_pc)
2254 {
2255 #if defined ALPHA_DEBUG_DISAS
2256     static int insn_count;
2257 #endif
2258     DisasContext ctx, *ctxp = &ctx;
2259     target_ulong pc_start;
2260     uint32_t insn;
2261     uint16_t *gen_opc_end;
2262     int j, lj = -1;
2263     int ret;
2264     int num_insns;
2265     int max_insns;
2266
2267     pc_start = tb->pc;
2268     gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
2269     ctx.pc = pc_start;
2270     ctx.amask = env->amask;
2271 #if defined (CONFIG_USER_ONLY)
2272     ctx.mem_idx = 0;
2273 #else
2274     ctx.mem_idx = ((env->ps >> 3) & 3);
2275     ctx.pal_mode = env->ipr[IPR_EXC_ADDR] & 1;
2276 #endif
2277     num_insns = 0;
2278     max_insns = tb->cflags & CF_COUNT_MASK;
2279     if (max_insns == 0)
2280         max_insns = CF_COUNT_MASK;
2281
2282     gen_icount_start();
2283     for (ret = 0; ret == 0;) {
2284         if (env->nb_breakpoints > 0) {
2285             for(j = 0; j < env->nb_breakpoints; j++) {
2286                 if (env->breakpoints[j] == ctx.pc) {
2287                     gen_excp(&ctx, EXCP_DEBUG, 0);
2288                     break;
2289                 }
2290             }
2291         }
2292         if (search_pc) {
2293             j = gen_opc_ptr - gen_opc_buf;
2294             if (lj < j) {
2295                 lj++;
2296                 while (lj < j)
2297                     gen_opc_instr_start[lj++] = 0;
2298                 gen_opc_pc[lj] = ctx.pc;
2299                 gen_opc_instr_start[lj] = 1;
2300                 gen_opc_icount[lj] = num_insns;
2301             }
2302         }
2303         if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
2304             gen_io_start();
2305 #if defined ALPHA_DEBUG_DISAS
2306         insn_count++;
2307         if (logfile != NULL) {
2308             fprintf(logfile, "pc " TARGET_FMT_lx " mem_idx %d\n",
2309                     ctx.pc, ctx.mem_idx);
2310         }
2311 #endif
2312         insn = ldl_code(ctx.pc);
2313 #if defined ALPHA_DEBUG_DISAS
2314         insn_count++;
2315         if (logfile != NULL) {
2316             fprintf(logfile, "opcode %08x %d\n", insn, insn_count);
2317         }
2318 #endif
2319         num_insns++;
2320         ctx.pc += 4;
2321         ret = translate_one(ctxp, insn);
2322         if (ret != 0)
2323             break;
2324         /* if we reach a page boundary or are single stepping, stop
2325          * generation
2326          */
2327         if (((ctx.pc & (TARGET_PAGE_SIZE - 1)) == 0) ||
2328             (env->singlestep_enabled) ||
2329             num_insns >= max_insns) {
2330             break;
2331         }
2332 #if defined (DO_SINGLE_STEP)
2333         break;
2334 #endif
2335     }
2336     if (ret != 1 && ret != 3) {
2337         tcg_gen_movi_i64(cpu_pc, ctx.pc);
2338     }
2339 #if defined (DO_TB_FLUSH)
2340     tcg_gen_helper_0_0(helper_tb_flush);
2341 #endif
2342     if (tb->cflags & CF_LAST_IO)
2343         gen_io_end();
2344     /* Generate the return instruction */
2345     tcg_gen_exit_tb(0);
2346     gen_icount_end(tb, num_insns);
2347     *gen_opc_ptr = INDEX_op_end;
2348     if (search_pc) {
2349         j = gen_opc_ptr - gen_opc_buf;
2350         lj++;
2351         while (lj <= j)
2352             gen_opc_instr_start[lj++] = 0;
2353     } else {
2354         tb->size = ctx.pc - pc_start;
2355         tb->icount = num_insns;
2356     }
2357 #if defined ALPHA_DEBUG_DISAS
2358     if (loglevel & CPU_LOG_TB_CPU) {
2359         cpu_dump_state(env, logfile, fprintf, 0);
2360     }
2361     if (loglevel & CPU_LOG_TB_IN_ASM) {
2362         fprintf(logfile, "IN: %s\n", lookup_symbol(pc_start));
2363         target_disas(logfile, pc_start, ctx.pc - pc_start, 1);
2364         fprintf(logfile, "\n");
2365     }
2366 #endif
2367 }
2368
2369 void gen_intermediate_code (CPUState *env, struct TranslationBlock *tb)
2370 {
2371     gen_intermediate_code_internal(env, tb, 0);
2372 }
2373
2374 void gen_intermediate_code_pc (CPUState *env, struct TranslationBlock *tb)
2375 {
2376     gen_intermediate_code_internal(env, tb, 1);
2377 }
2378
2379 CPUAlphaState * cpu_alpha_init (const char *cpu_model)
2380 {
2381     CPUAlphaState *env;
2382     uint64_t hwpcb;
2383
2384     env = qemu_mallocz(sizeof(CPUAlphaState));
2385     if (!env)
2386         return NULL;
2387     cpu_exec_init(env);
2388     alpha_translate_init();
2389     tlb_flush(env, 1);
2390     /* XXX: should not be hardcoded */
2391     env->implver = IMPLVER_2106x;
2392     env->ps = 0x1F00;
2393 #if defined (CONFIG_USER_ONLY)
2394     env->ps |= 1 << 3;
2395 #endif
2396     pal_init(env);
2397     /* Initialize IPR */
2398     hwpcb = env->ipr[IPR_PCBB];
2399     env->ipr[IPR_ASN] = 0;
2400     env->ipr[IPR_ASTEN] = 0;
2401     env->ipr[IPR_ASTSR] = 0;
2402     env->ipr[IPR_DATFX] = 0;
2403     /* XXX: fix this */
2404     //    env->ipr[IPR_ESP] = ldq_raw(hwpcb + 8);
2405     //    env->ipr[IPR_KSP] = ldq_raw(hwpcb + 0);
2406     //    env->ipr[IPR_SSP] = ldq_raw(hwpcb + 16);
2407     //    env->ipr[IPR_USP] = ldq_raw(hwpcb + 24);
2408     env->ipr[IPR_FEN] = 0;
2409     env->ipr[IPR_IPL] = 31;
2410     env->ipr[IPR_MCES] = 0;
2411     env->ipr[IPR_PERFMON] = 0; /* Implementation specific */
2412     //    env->ipr[IPR_PTBR] = ldq_raw(hwpcb + 32);
2413     env->ipr[IPR_SISR] = 0;
2414     env->ipr[IPR_VIRBND] = -1ULL;
2415
2416     return env;
2417 }
2418
2419 void gen_pc_load(CPUState *env, TranslationBlock *tb,
2420                 unsigned long searched_pc, int pc_pos, void *puc)
2421 {
2422     env->pc = gen_opc_pc[pc_pos];
2423 }