target-mips/translate.c

   1 /*
   2  *  MIPS32 emulation for qemu: main translation routines.
   3  *
   4  *  Copyright (c) 2004-2005 Jocelyn Mayer
   5  *  Copyright (c) 2006 Marius Groeger (FPU operations)
   6  *  Copyright (c) 2006 Thiemo Seufer (MIPS32R2 support)
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <stdarg.h>
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <inttypes.h>
  28
  29 #include "cpu.h"
  30 #include "exec-all.h"
  31 #include "disas.h"
  32
  33 //#define MIPS_DEBUG_DISAS
  34 //#define MIPS_DEBUG_SIGN_EXTENSIONS
  35 //#define MIPS_SINGLE_STEP
  36
  37 #ifdef USE_DIRECT_JUMP
  38 #define TBPARAM(x)
  39 #else
  40 #define TBPARAM(x) (long)(x)
  41 #endif
  42
  43 enum {
  44 #define DEF(s, n, copy_size) INDEX_op_ ## s,
  45 #include "opc.h"
  46 #undef DEF
  47     NB_OPS,
  48 };
  49
  50 static uint16_t *gen_opc_ptr;
  51 static uint32_t *gen_opparam_ptr;
  52
  53 #include "gen-op.h"
  54
  55 /* MIPS major opcodes */
  56 #define MASK_OP_MAJOR(op)  (op & (0x3F << 26))
  57
  58 enum {
  59     /* indirect opcode tables */
  60     OPC_SPECIAL  = (0x00 << 26),
  61     OPC_REGIMM   = (0x01 << 26),
  62     OPC_CP0      = (0x10 << 26),
  63     OPC_CP1      = (0x11 << 26),
  64     OPC_CP2      = (0x12 << 26),
  65     OPC_CP3      = (0x13 << 26),
  66     OPC_SPECIAL2 = (0x1C << 26),
  67     OPC_SPECIAL3 = (0x1F << 26),
  68     /* arithmetic with immediate */
  69     OPC_ADDI     = (0x08 << 26),
  70     OPC_ADDIU    = (0x09 << 26),
  71     OPC_SLTI     = (0x0A << 26),
  72     OPC_SLTIU    = (0x0B << 26),
  73     OPC_ANDI     = (0x0C << 26),
  74     OPC_ORI      = (0x0D << 26),
  75     OPC_XORI     = (0x0E << 26),
  76     OPC_LUI      = (0x0F << 26),
  77     OPC_DADDI    = (0x18 << 26),
  78     OPC_DADDIU   = (0x19 << 26),
  79     /* Jump and branches */
  80     OPC_J        = (0x02 << 26),
  81     OPC_JAL      = (0x03 << 26),
  82     OPC_BEQ      = (0x04 << 26),  /* Unconditional if rs = rt = 0 (B) */
  83     OPC_BEQL     = (0x14 << 26),
  84     OPC_BNE      = (0x05 << 26),
  85     OPC_BNEL     = (0x15 << 26),
  86     OPC_BLEZ     = (0x06 << 26),
  87     OPC_BLEZL    = (0x16 << 26),
  88     OPC_BGTZ     = (0x07 << 26),
  89     OPC_BGTZL    = (0x17 << 26),
  90     OPC_JALX     = (0x1D << 26),  /* MIPS 16 only */
  91     /* Load and stores */
  92     OPC_LDL      = (0x1A << 26),
  93     OPC_LDR      = (0x1B << 26),
  94     OPC_LB       = (0x20 << 26),
  95     OPC_LH       = (0x21 << 26),
  96     OPC_LWL      = (0x22 << 26),
  97     OPC_LW       = (0x23 << 26),
  98     OPC_LBU      = (0x24 << 26),
  99     OPC_LHU      = (0x25 << 26),
 100     OPC_LWR      = (0x26 << 26),
 101     OPC_LWU      = (0x27 << 26),
 102     OPC_SB       = (0x28 << 26),
 103     OPC_SH       = (0x29 << 26),
 104     OPC_SWL      = (0x2A << 26),
 105     OPC_SW       = (0x2B << 26),
 106     OPC_SDL      = (0x2C << 26),
 107     OPC_SDR      = (0x2D << 26),
 108     OPC_SWR      = (0x2E << 26),
 109     OPC_LL       = (0x30 << 26),
 110     OPC_LLD      = (0x34 << 26),
 111     OPC_LD       = (0x37 << 26),
 112     OPC_SC       = (0x38 << 26),
 113     OPC_SCD      = (0x3C << 26),
 114     OPC_SD       = (0x3F << 26),
 115     /* Floating point load/store */
 116     OPC_LWC1     = (0x31 << 26),
 117     OPC_LWC2     = (0x32 << 26),
 118     OPC_LDC1     = (0x35 << 26),
 119     OPC_LDC2     = (0x36 << 26),
 120     OPC_SWC1     = (0x39 << 26),
 121     OPC_SWC2     = (0x3A << 26),
 122     OPC_SDC1     = (0x3D << 26),
 123     OPC_SDC2     = (0x3E << 26),
 124     /* MDMX ASE specific */
 125     OPC_MDMX     = (0x1E << 26),
 126     /* Cache and prefetch */
 127     OPC_CACHE    = (0x2F << 26),
 128     OPC_PREF     = (0x33 << 26),
 129     /* Reserved major opcode */
 130     OPC_MAJOR3B_RESERVED = (0x3B << 26),
 131 };
 132
 133 /* MIPS special opcodes */
 134 #define MASK_SPECIAL(op)   MASK_OP_MAJOR(op) | (op & 0x3F)
 135
 136 enum {
 137     /* Shifts */
 138     OPC_SLL      = 0x00 | OPC_SPECIAL,
 139     /* NOP is SLL r0, r0, 0   */
 140     /* SSNOP is SLL r0, r0, 1 */
 141     /* EHB is SLL r0, r0, 3 */
 142     OPC_SRL      = 0x02 | OPC_SPECIAL, /* also ROTR */
 143     OPC_SRA      = 0x03 | OPC_SPECIAL,
 144     OPC_SLLV     = 0x04 | OPC_SPECIAL,
 145     OPC_SRLV     = 0x06 | OPC_SPECIAL, /* also ROTRV */
 146     OPC_SRAV     = 0x07 | OPC_SPECIAL,
 147     OPC_DSLLV    = 0x14 | OPC_SPECIAL,
 148     OPC_DSRLV    = 0x16 | OPC_SPECIAL, /* also DROTRV */
 149     OPC_DSRAV    = 0x17 | OPC_SPECIAL,
 150     OPC_DSLL     = 0x38 | OPC_SPECIAL,
 151     OPC_DSRL     = 0x3A | OPC_SPECIAL, /* also DROTR */
 152     OPC_DSRA     = 0x3B | OPC_SPECIAL,
 153     OPC_DSLL32   = 0x3C | OPC_SPECIAL,
 154     OPC_DSRL32   = 0x3E | OPC_SPECIAL, /* also DROTR32 */
 155     OPC_DSRA32   = 0x3F | OPC_SPECIAL,
 156     /* Multiplication / division */
 157     OPC_MULT     = 0x18 | OPC_SPECIAL,
 158     OPC_MULTU    = 0x19 | OPC_SPECIAL,
 159     OPC_DIV      = 0x1A | OPC_SPECIAL,
 160     OPC_DIVU     = 0x1B | OPC_SPECIAL,
 161     OPC_DMULT    = 0x1C | OPC_SPECIAL,
 162     OPC_DMULTU   = 0x1D | OPC_SPECIAL,
 163     OPC_DDIV     = 0x1E | OPC_SPECIAL,
 164     OPC_DDIVU    = 0x1F | OPC_SPECIAL,
 165     /* 2 registers arithmetic / logic */
 166     OPC_ADD      = 0x20 | OPC_SPECIAL,
 167     OPC_ADDU     = 0x21 | OPC_SPECIAL,
 168     OPC_SUB      = 0x22 | OPC_SPECIAL,
 169     OPC_SUBU     = 0x23 | OPC_SPECIAL,
 170     OPC_AND      = 0x24 | OPC_SPECIAL,
 171     OPC_OR       = 0x25 | OPC_SPECIAL,
 172     OPC_XOR      = 0x26 | OPC_SPECIAL,
 173     OPC_NOR      = 0x27 | OPC_SPECIAL,
 174     OPC_SLT      = 0x2A | OPC_SPECIAL,
 175     OPC_SLTU     = 0x2B | OPC_SPECIAL,
 176     OPC_DADD     = 0x2C | OPC_SPECIAL,
 177     OPC_DADDU    = 0x2D | OPC_SPECIAL,
 178     OPC_DSUB     = 0x2E | OPC_SPECIAL,
 179     OPC_DSUBU    = 0x2F | OPC_SPECIAL,
 180     /* Jumps */
 181     OPC_JR       = 0x08 | OPC_SPECIAL, /* Also JR.HB */
 182     OPC_JALR     = 0x09 | OPC_SPECIAL, /* Also JALR.HB */
 183     /* Traps */
 184     OPC_TGE      = 0x30 | OPC_SPECIAL,
 185     OPC_TGEU     = 0x31 | OPC_SPECIAL,
 186     OPC_TLT      = 0x32 | OPC_SPECIAL,
 187     OPC_TLTU     = 0x33 | OPC_SPECIAL,
 188     OPC_TEQ      = 0x34 | OPC_SPECIAL,
 189     OPC_TNE      = 0x36 | OPC_SPECIAL,
 190     /* HI / LO registers load & stores */
 191     OPC_MFHI     = 0x10 | OPC_SPECIAL,
 192     OPC_MTHI     = 0x11 | OPC_SPECIAL,
 193     OPC_MFLO     = 0x12 | OPC_SPECIAL,
 194     OPC_MTLO     = 0x13 | OPC_SPECIAL,
 195     /* Conditional moves */
 196     OPC_MOVZ     = 0x0A | OPC_SPECIAL,
 197     OPC_MOVN     = 0x0B | OPC_SPECIAL,
 198
 199     OPC_MOVCI    = 0x01 | OPC_SPECIAL,
 200
 201     /* Special */
 202     OPC_PMON     = 0x05 | OPC_SPECIAL, /* inofficial */
 203     OPC_SYSCALL  = 0x0C | OPC_SPECIAL,
 204     OPC_BREAK    = 0x0D | OPC_SPECIAL,
 205     OPC_SPIM     = 0x0E | OPC_SPECIAL, /* inofficial */
 206     OPC_SYNC     = 0x0F | OPC_SPECIAL,
 207
 208     OPC_SPECIAL15_RESERVED = 0x15 | OPC_SPECIAL,
 209     OPC_SPECIAL28_RESERVED = 0x28 | OPC_SPECIAL,
 210     OPC_SPECIAL29_RESERVED = 0x29 | OPC_SPECIAL,
 211     OPC_SPECIAL35_RESERVED = 0x35 | OPC_SPECIAL,
 212     OPC_SPECIAL37_RESERVED = 0x37 | OPC_SPECIAL,
 213     OPC_SPECIAL39_RESERVED = 0x39 | OPC_SPECIAL,
 214     OPC_SPECIAL3D_RESERVED = 0x3D | OPC_SPECIAL,
 215 };
 216
 217 /* REGIMM (rt field) opcodes */
 218 #define MASK_REGIMM(op)    MASK_OP_MAJOR(op) | (op & (0x1F << 16))
 219
 220 enum {
 221     OPC_BLTZ     = (0x00 << 16) | OPC_REGIMM,
 222     OPC_BLTZL    = (0x02 << 16) | OPC_REGIMM,
 223     OPC_BGEZ     = (0x01 << 16) | OPC_REGIMM,
 224     OPC_BGEZL    = (0x03 << 16) | OPC_REGIMM,
 225     OPC_BLTZAL   = (0x10 << 16) | OPC_REGIMM,
 226     OPC_BLTZALL  = (0x12 << 16) | OPC_REGIMM,
 227     OPC_BGEZAL   = (0x11 << 16) | OPC_REGIMM,
 228     OPC_BGEZALL  = (0x13 << 16) | OPC_REGIMM,
 229     OPC_TGEI     = (0x08 << 16) | OPC_REGIMM,
 230     OPC_TGEIU    = (0x09 << 16) | OPC_REGIMM,
 231     OPC_TLTI     = (0x0A << 16) | OPC_REGIMM,
 232     OPC_TLTIU    = (0x0B << 16) | OPC_REGIMM,
 233     OPC_TEQI     = (0x0C << 16) | OPC_REGIMM,
 234     OPC_TNEI     = (0x0E << 16) | OPC_REGIMM,
 235     OPC_SYNCI    = (0x1F << 16) | OPC_REGIMM,
 236 };
 237
 238 /* Special2 opcodes */
 239 #define MASK_SPECIAL2(op)  MASK_OP_MAJOR(op) | (op & 0x3F)
 240
 241 enum {
 242     /* Multiply & xxx operations */
 243     OPC_MADD     = 0x00 | OPC_SPECIAL2,
 244     OPC_MADDU    = 0x01 | OPC_SPECIAL2,
 245     OPC_MUL      = 0x02 | OPC_SPECIAL2,
 246     OPC_MSUB     = 0x04 | OPC_SPECIAL2,
 247     OPC_MSUBU    = 0x05 | OPC_SPECIAL2,
 248     /* Misc */
 249     OPC_CLZ      = 0x20 | OPC_SPECIAL2,
 250     OPC_CLO      = 0x21 | OPC_SPECIAL2,
 251     OPC_DCLZ     = 0x24 | OPC_SPECIAL2,
 252     OPC_DCLO     = 0x25 | OPC_SPECIAL2,
 253     /* Special */
 254     OPC_SDBBP    = 0x3F | OPC_SPECIAL2,
 255 };
 256
 257 /* Special3 opcodes */
 258 #define MASK_SPECIAL3(op)  MASK_OP_MAJOR(op) | (op & 0x3F)
 259
 260 enum {
 261     OPC_EXT      = 0x00 | OPC_SPECIAL3,
 262     OPC_DEXTM    = 0x01 | OPC_SPECIAL3,
 263     OPC_DEXTU    = 0x02 | OPC_SPECIAL3,
 264     OPC_DEXT     = 0x03 | OPC_SPECIAL3,
 265     OPC_INS      = 0x04 | OPC_SPECIAL3,
 266     OPC_DINSM    = 0x05 | OPC_SPECIAL3,
 267     OPC_DINSU    = 0x06 | OPC_SPECIAL3,
 268     OPC_DINS     = 0x07 | OPC_SPECIAL3,
 269     OPC_FORK     = 0x08 | OPC_SPECIAL3,
 270     OPC_YIELD    = 0x09 | OPC_SPECIAL3,
 271     OPC_BSHFL    = 0x20 | OPC_SPECIAL3,
 272     OPC_DBSHFL   = 0x24 | OPC_SPECIAL3,
 273     OPC_RDHWR    = 0x3B | OPC_SPECIAL3,
 274 };
 275
 276 /* BSHFL opcodes */
 277 #define MASK_BSHFL(op)     MASK_SPECIAL3(op) | (op & (0x1F << 6))
 278
 279 enum {
 280     OPC_WSBH     = (0x02 << 6) | OPC_BSHFL,
 281     OPC_SEB      = (0x10 << 6) | OPC_BSHFL,
 282     OPC_SEH      = (0x18 << 6) | OPC_BSHFL,
 283 };
 284
 285 /* DBSHFL opcodes */
 286 #define MASK_DBSHFL(op)    MASK_SPECIAL3(op) | (op & (0x1F << 6))
 287
 288 enum {
 289     OPC_DSBH     = (0x02 << 6) | OPC_DBSHFL,
 290     OPC_DSHD     = (0x05 << 6) | OPC_DBSHFL,
 291 };
 292
 293 /* Coprocessor 0 (rs field) */
 294 #define MASK_CP0(op)       MASK_OP_MAJOR(op) | (op & (0x1F << 21))
 295
 296 enum {
 297     OPC_MFC0     = (0x00 << 21) | OPC_CP0,
 298     OPC_DMFC0    = (0x01 << 21) | OPC_CP0,
 299     OPC_MTC0     = (0x04 << 21) | OPC_CP0,
 300     OPC_DMTC0    = (0x05 << 21) | OPC_CP0,
 301     OPC_MFTR     = (0x08 << 21) | OPC_CP0,
 302     OPC_RDPGPR   = (0x0A << 21) | OPC_CP0,
 303     OPC_MFMC0    = (0x0B << 21) | OPC_CP0,
 304     OPC_MTTR     = (0x0C << 21) | OPC_CP0,
 305     OPC_WRPGPR   = (0x0E << 21) | OPC_CP0,
 306     OPC_C0       = (0x10 << 21) | OPC_CP0,
 307     OPC_C0_FIRST = (0x10 << 21) | OPC_CP0,
 308     OPC_C0_LAST  = (0x1F << 21) | OPC_CP0,
 309 };
 310
 311 /* MFMC0 opcodes */
 312 #define MASK_MFMC0(op)     MASK_CP0(op) | (op & 0xFFFF)
 313
 314 enum {
 315     OPC_DMT      = 0x01 | (0 << 5) | (0x0F << 6) | (0x01 << 11) | OPC_MFMC0,
 316     OPC_EMT      = 0x01 | (1 << 5) | (0x0F << 6) | (0x01 << 11) | OPC_MFMC0,
 317     OPC_DVPE     = 0x01 | (0 << 5) | OPC_MFMC0,
 318     OPC_EVPE     = 0x01 | (1 << 5) | OPC_MFMC0,
 319     OPC_DI       = (0 << 5) | (0x0C << 11) | OPC_MFMC0,
 320     OPC_EI       = (1 << 5) | (0x0C << 11) | OPC_MFMC0,
 321 };
 322
 323 /* Coprocessor 0 (with rs == C0) */
 324 #define MASK_C0(op)        MASK_CP0(op) | (op & 0x3F)
 325
 326 enum {
 327     OPC_TLBR     = 0x01 | OPC_C0,
 328     OPC_TLBWI    = 0x02 | OPC_C0,
 329     OPC_TLBWR    = 0x06 | OPC_C0,
 330     OPC_TLBP     = 0x08 | OPC_C0,
 331     OPC_RFE      = 0x10 | OPC_C0,
 332     OPC_ERET     = 0x18 | OPC_C0,
 333     OPC_DERET    = 0x1F | OPC_C0,
 334     OPC_WAIT     = 0x20 | OPC_C0,
 335 };
 336
 337 /* Coprocessor 1 (rs field) */
 338 #define MASK_CP1(op)       MASK_OP_MAJOR(op) | (op & (0x1F << 21))
 339
 340 enum {
 341     OPC_MFC1     = (0x00 << 21) | OPC_CP1,
 342     OPC_DMFC1    = (0x01 << 21) | OPC_CP1,
 343     OPC_CFC1     = (0x02 << 21) | OPC_CP1,
 344     OPC_MFHC1    = (0x03 << 21) | OPC_CP1,
 345     OPC_MTC1     = (0x04 << 21) | OPC_CP1,
 346     OPC_DMTC1    = (0x05 << 21) | OPC_CP1,
 347     OPC_CTC1     = (0x06 << 21) | OPC_CP1,
 348     OPC_MTHC1    = (0x07 << 21) | OPC_CP1,
 349     OPC_BC1      = (0x08 << 21) | OPC_CP1, /* bc */
 350     OPC_BC1ANY2  = (0x09 << 21) | OPC_CP1,
 351     OPC_BC1ANY4  = (0x0A << 21) | OPC_CP1,
 352     OPC_S_FMT    = (0x10 << 21) | OPC_CP1, /* 16: fmt=single fp */
 353     OPC_D_FMT    = (0x11 << 21) | OPC_CP1, /* 17: fmt=double fp */
 354     OPC_E_FMT    = (0x12 << 21) | OPC_CP1, /* 18: fmt=extended fp */
 355     OPC_Q_FMT    = (0x13 << 21) | OPC_CP1, /* 19: fmt=quad fp */
 356     OPC_W_FMT    = (0x14 << 21) | OPC_CP1, /* 20: fmt=32bit fixed */
 357     OPC_L_FMT    = (0x15 << 21) | OPC_CP1, /* 21: fmt=64bit fixed */
 358     OPC_PS_FMT   = (0x16 << 21) | OPC_CP1, /* 22: fmt=paired single fp */
 359 };
 360
 361 #define MASK_CP1_FUNC(op)       MASK_CP1(op) | (op & 0x3F)
 362 #define MASK_BC1(op)            MASK_CP1(op) | (op & (0x3 << 16))
 363
 364 enum {
 365     OPC_BC1F     = (0x00 << 16) | OPC_BC1,
 366     OPC_BC1T     = (0x01 << 16) | OPC_BC1,
 367     OPC_BC1FL    = (0x02 << 16) | OPC_BC1,
 368     OPC_BC1TL    = (0x03 << 16) | OPC_BC1,
 369 };
 370
 371 enum {
 372     OPC_BC1FANY2     = (0x00 << 16) | OPC_BC1ANY2,
 373     OPC_BC1TANY2     = (0x01 << 16) | OPC_BC1ANY2,
 374 };
 375
 376 enum {
 377     OPC_BC1FANY4     = (0x00 << 16) | OPC_BC1ANY4,
 378     OPC_BC1TANY4     = (0x01 << 16) | OPC_BC1ANY4,
 379 };
 380
 381 #define MASK_CP2(op)       MASK_OP_MAJOR(op) | (op & (0x1F << 21))
 382
 383 enum {
 384     OPC_MFC2    = (0x00 << 21) | OPC_CP2,
 385     OPC_DMFC2   = (0x01 << 21) | OPC_CP2,
 386     OPC_CFC2    = (0x02 << 21) | OPC_CP2,
 387     OPC_MFHC2   = (0x03 << 21) | OPC_CP2,
 388     OPC_MTC2    = (0x04 << 21) | OPC_CP2,
 389     OPC_DMTC2   = (0x05 << 21) | OPC_CP2,
 390     OPC_CTC2    = (0x06 << 21) | OPC_CP2,
 391     OPC_MTHC2   = (0x07 << 21) | OPC_CP2,
 392     OPC_BC2     = (0x08 << 21) | OPC_CP2,
 393 };
 394
 395 #define MASK_CP3(op)       MASK_OP_MAJOR(op) | (op & 0x3F)
 396
 397 enum {
 398     OPC_LWXC1   = 0x00 | OPC_CP3,
 399     OPC_LDXC1   = 0x01 | OPC_CP3,
 400     OPC_LUXC1   = 0x05 | OPC_CP3,
 401     OPC_SWXC1   = 0x08 | OPC_CP3,
 402     OPC_SDXC1   = 0x09 | OPC_CP3,
 403     OPC_SUXC1   = 0x0D | OPC_CP3,
 404     OPC_PREFX   = 0x0F | OPC_CP3,
 405     OPC_ALNV_PS = 0x1E | OPC_CP3,
 406     OPC_MADD_S  = 0x20 | OPC_CP3,
 407     OPC_MADD_D  = 0x21 | OPC_CP3,
 408     OPC_MADD_PS = 0x26 | OPC_CP3,
 409     OPC_MSUB_S  = 0x28 | OPC_CP3,
 410     OPC_MSUB_D  = 0x29 | OPC_CP3,
 411     OPC_MSUB_PS = 0x2E | OPC_CP3,
 412     OPC_NMADD_S = 0x30 | OPC_CP3,
 413     OPC_NMADD_D = 0x31 | OPC_CP3,
 414     OPC_NMADD_PS= 0x36 | OPC_CP3,
 415     OPC_NMSUB_S = 0x38 | OPC_CP3,
 416     OPC_NMSUB_D = 0x39 | OPC_CP3,
 417     OPC_NMSUB_PS= 0x3E | OPC_CP3,
 418 };
 419
 420
 421 const unsigned char *regnames[] =
 422     { "r0", "at", "v0", "v1", "a0", "a1", "a2", "a3",
 423       "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
 424       "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
 425       "t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra", };
 426
 427 /* Warning: no function for r0 register (hard wired to zero) */
 428 #define GEN32(func, NAME)                        \
 429 static GenOpFunc *NAME ## _table [32] = {        \
 430 NULL,       NAME ## 1, NAME ## 2, NAME ## 3,     \
 431 NAME ## 4,  NAME ## 5, NAME ## 6, NAME ## 7,     \
 432 NAME ## 8,  NAME ## 9, NAME ## 10, NAME ## 11,   \
 433 NAME ## 12, NAME ## 13, NAME ## 14, NAME ## 15,  \
 434 NAME ## 16, NAME ## 17, NAME ## 18, NAME ## 19,  \
 435 NAME ## 20, NAME ## 21, NAME ## 22, NAME ## 23,  \
 436 NAME ## 24, NAME ## 25, NAME ## 26, NAME ## 27,  \
 437 NAME ## 28, NAME ## 29, NAME ## 30, NAME ## 31,  \
 438 };                                               \
 439 static inline void func(int n)                   \
 440 {                                                \
 441     NAME ## _table[n]();                         \
 442 }
 443
 444 /* General purpose registers moves */
 445 GEN32(gen_op_load_gpr_T0, gen_op_load_gpr_T0_gpr);
 446 GEN32(gen_op_load_gpr_T1, gen_op_load_gpr_T1_gpr);
 447 GEN32(gen_op_load_gpr_T2, gen_op_load_gpr_T2_gpr);
 448
 449 GEN32(gen_op_store_T0_gpr, gen_op_store_T0_gpr_gpr);
 450 GEN32(gen_op_store_T1_gpr, gen_op_store_T1_gpr_gpr);
 451
 452 /* Moves to/from shadow registers */
 453 GEN32(gen_op_load_srsgpr_T0, gen_op_load_srsgpr_T0_gpr);
 454 GEN32(gen_op_store_T0_srsgpr, gen_op_store_T0_srsgpr_gpr);
 455
 456 static const char *fregnames[] =
 457     { "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
 458       "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
 459       "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 460       "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", };
 461
 462 #define FGEN32(func, NAME)                       \
 463 static GenOpFunc *NAME ## _table [32] = {        \
 464 NAME ## 0,  NAME ## 1,  NAME ## 2,  NAME ## 3,   \
 465 NAME ## 4,  NAME ## 5,  NAME ## 6,  NAME ## 7,   \
 466 NAME ## 8,  NAME ## 9,  NAME ## 10, NAME ## 11,  \
 467 NAME ## 12, NAME ## 13, NAME ## 14, NAME ## 15,  \
 468 NAME ## 16, NAME ## 17, NAME ## 18, NAME ## 19,  \
 469 NAME ## 20, NAME ## 21, NAME ## 22, NAME ## 23,  \
 470 NAME ## 24, NAME ## 25, NAME ## 26, NAME ## 27,  \
 471 NAME ## 28, NAME ## 29, NAME ## 30, NAME ## 31,  \
 472 };                                               \
 473 static inline void func(int n)                   \
 474 {                                                \
 475     NAME ## _table[n]();                         \
 476 }
 477
 478 FGEN32(gen_op_load_fpr_WT0,  gen_op_load_fpr_WT0_fpr);
 479 FGEN32(gen_op_store_fpr_WT0, gen_op_store_fpr_WT0_fpr);
 480
 481 FGEN32(gen_op_load_fpr_WT1,  gen_op_load_fpr_WT1_fpr);
 482 FGEN32(gen_op_store_fpr_WT1, gen_op_store_fpr_WT1_fpr);
 483
 484 FGEN32(gen_op_load_fpr_WT2,  gen_op_load_fpr_WT2_fpr);
 485 FGEN32(gen_op_store_fpr_WT2, gen_op_store_fpr_WT2_fpr);
 486
 487 FGEN32(gen_op_load_fpr_DT0,  gen_op_load_fpr_DT0_fpr);
 488 FGEN32(gen_op_store_fpr_DT0, gen_op_store_fpr_DT0_fpr);
 489
 490 FGEN32(gen_op_load_fpr_DT1,  gen_op_load_fpr_DT1_fpr);
 491 FGEN32(gen_op_store_fpr_DT1, gen_op_store_fpr_DT1_fpr);
 492
 493 FGEN32(gen_op_load_fpr_DT2,  gen_op_load_fpr_DT2_fpr);
 494 FGEN32(gen_op_store_fpr_DT2, gen_op_store_fpr_DT2_fpr);
 495
 496 FGEN32(gen_op_load_fpr_WTH0,  gen_op_load_fpr_WTH0_fpr);
 497 FGEN32(gen_op_store_fpr_WTH0, gen_op_store_fpr_WTH0_fpr);
 498
 499 FGEN32(gen_op_load_fpr_WTH1,  gen_op_load_fpr_WTH1_fpr);
 500 FGEN32(gen_op_store_fpr_WTH1, gen_op_store_fpr_WTH1_fpr);
 501
 502 FGEN32(gen_op_load_fpr_WTH2,  gen_op_load_fpr_WTH2_fpr);
 503 FGEN32(gen_op_store_fpr_WTH2, gen_op_store_fpr_WTH2_fpr);
 504
 505 #define FOP_CONDS(type, fmt)                                            \
 506 static GenOpFunc1 * gen_op_cmp ## type ## _ ## fmt ## _table[16] = {    \
 507     gen_op_cmp ## type ## _ ## fmt ## _f,                               \
 508     gen_op_cmp ## type ## _ ## fmt ## _un,                              \
 509     gen_op_cmp ## type ## _ ## fmt ## _eq,                              \
 510     gen_op_cmp ## type ## _ ## fmt ## _ueq,                             \
 511     gen_op_cmp ## type ## _ ## fmt ## _olt,                             \
 512     gen_op_cmp ## type ## _ ## fmt ## _ult,                             \
 513     gen_op_cmp ## type ## _ ## fmt ## _ole,                             \
 514     gen_op_cmp ## type ## _ ## fmt ## _ule,                             \
 515     gen_op_cmp ## type ## _ ## fmt ## _sf,                              \
 516     gen_op_cmp ## type ## _ ## fmt ## _ngle,                            \
 517     gen_op_cmp ## type ## _ ## fmt ## _seq,                             \
 518     gen_op_cmp ## type ## _ ## fmt ## _ngl,                             \
 519     gen_op_cmp ## type ## _ ## fmt ## _lt,                              \
 520     gen_op_cmp ## type ## _ ## fmt ## _nge,                             \
 521     gen_op_cmp ## type ## _ ## fmt ## _le,                              \
 522     gen_op_cmp ## type ## _ ## fmt ## _ngt,                             \
 523 };                                                                      \
 524 static inline void gen_cmp ## type ## _ ## fmt(int n, long cc)          \
 525 {                                                                       \
 526     gen_op_cmp ## type ## _ ## fmt ## _table[n](cc);                    \
 527 }
 528
 529 FOP_CONDS(, d)
 530 FOP_CONDS(abs, d)
 531 FOP_CONDS(, s)
 532 FOP_CONDS(abs, s)
 533 FOP_CONDS(, ps)
 534 FOP_CONDS(abs, ps)
 535
 536 typedef struct DisasContext {
 537     struct TranslationBlock *tb;
 538     target_ulong pc, saved_pc;
 539     uint32_t opcode;
 540     uint32_t fp_status;
 541     /* Routine used to access memory */
 542     int mem_idx;
 543     uint32_t hflags, saved_hflags;
 544     int bstate;
 545     target_ulong btarget;
 546 } DisasContext;
 547
 548 enum {
 549     BS_NONE     = 0, /* We go out of the TB without reaching a branch or an
 550                       * exception condition
 551                       */
 552     BS_STOP     = 1, /* We want to stop translation for any reason */
 553     BS_BRANCH   = 2, /* We reached a branch condition     */
 554     BS_EXCP     = 3, /* We reached an exception condition */
 555 };
 556
 557 #ifdef MIPS_DEBUG_DISAS
 558 #define MIPS_DEBUG(fmt, args...)                                              \
 559 do {                                                                          \
 560     if (loglevel & CPU_LOG_TB_IN_ASM) {                                       \
 561         fprintf(logfile, TARGET_FMT_lx ": %08x " fmt "\n",                    \
 562                 ctx->pc, ctx->opcode , ##args);                               \
 563     }                                                                         \
 564 } while (0)
 565 #else
 566 #define MIPS_DEBUG(fmt, args...) do { } while(0)
 567 #endif
 568
 569 #define MIPS_INVAL(op)                                                        \
 570 do {                                                                          \
 571     MIPS_DEBUG("Invalid %s %03x %03x %03x", op, ctx->opcode >> 26,            \
 572                ctx->opcode & 0x3F, ((ctx->opcode >> 16) & 0x1F));             \
 573 } while (0)
 574
 575 #define GEN_LOAD_REG_TN(Tn, Rn)                                               \
 576 do {                                                                          \
 577     if (Rn == 0) {                                                            \
 578         glue(gen_op_reset_, Tn)();                                            \
 579     } else {                                                                  \
 580         glue(gen_op_load_gpr_, Tn)(Rn);                                       \
 581     }                                                                         \
 582 } while (0)
 583
 584 #define GEN_LOAD_SRSREG_TN(Tn, Rn)                                            \
 585 do {                                                                          \
 586     if (Rn == 0) {                                                            \
 587         glue(gen_op_reset_, Tn)();                                            \
 588     } else {                                                                  \
 589         glue(gen_op_load_srsgpr_, Tn)(Rn);                                    \
 590     }                                                                         \
 591 } while (0)
 592
 593 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
 594 #define GEN_LOAD_IMM_TN(Tn, Imm)                                              \
 595 do {                                                                          \
 596     if (Imm == 0) {                                                           \
 597         glue(gen_op_reset_, Tn)();                                            \
 598     } else if ((int32_t)Imm == Imm) {                                         \
 599         glue(gen_op_set_, Tn)(Imm);                                           \
 600     } else {                                                                  \
 601         glue(gen_op_set64_, Tn)(((uint64_t)Imm) >> 32, (uint32_t)Imm);        \
 602     }                                                                         \
 603 } while (0)
 604 #else
 605 #define GEN_LOAD_IMM_TN(Tn, Imm)                                              \
 606 do {                                                                          \
 607     if (Imm == 0) {                                                           \
 608         glue(gen_op_reset_, Tn)();                                            \
 609     } else {                                                                  \
 610         glue(gen_op_set_, Tn)(Imm);                                           \
 611     }                                                                         \
 612 } while (0)
 613 #endif
 614
 615 #define GEN_STORE_TN_REG(Rn, Tn)                                              \
 616 do {                                                                          \
 617     if (Rn != 0) {                                                            \
 618         glue(glue(gen_op_store_, Tn),_gpr)(Rn);                               \
 619     }                                                                         \
 620 } while (0)
 621
 622 #define GEN_STORE_TN_SRSREG(Rn, Tn)                                           \
 623 do {                                                                          \
 624     if (Rn != 0) {                                                            \
 625         glue(glue(gen_op_store_, Tn),_srsgpr)(Rn);                            \
 626     }                                                                         \
 627 } while (0)
 628
 629 #define GEN_LOAD_FREG_FTN(FTn, Fn)                                            \
 630 do {                                                                          \
 631     glue(gen_op_load_fpr_, FTn)(Fn);                                          \
 632 } while (0)
 633
 634 #define GEN_STORE_FTN_FREG(Fn, FTn)                                           \
 635 do {                                                                          \
 636     glue(gen_op_store_fpr_, FTn)(Fn);                                         \
 637 } while (0)
 638
 639 static inline void gen_save_pc(target_ulong pc)
 640 {
 641 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
 642     if (pc == (int32_t)pc) {
 643         gen_op_save_pc(pc);
 644     } else {
 645         gen_op_save_pc64(pc >> 32, (uint32_t)pc);
 646     }
 647 #else
 648     gen_op_save_pc(pc);
 649 #endif
 650 }
 651
 652 static inline void gen_save_btarget(target_ulong btarget)
 653 {
 654 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
 655     if (btarget == (int32_t)btarget) {
 656         gen_op_save_btarget(btarget);
 657     } else {
 658         gen_op_save_btarget64(btarget >> 32, (uint32_t)btarget);
 659     }
 660 #else
 661     gen_op_save_btarget(btarget);
 662 #endif
 663 }
 664
 665 static inline void save_cpu_state (DisasContext *ctx, int do_save_pc)
 666 {
 667 #if defined MIPS_DEBUG_DISAS
 668     if (loglevel & CPU_LOG_TB_IN_ASM) {
 669             fprintf(logfile, "hflags %08x saved %08x\n",
 670                     ctx->hflags, ctx->saved_hflags);
 671     }
 672 #endif
 673     if (do_save_pc && ctx->pc != ctx->saved_pc) {
 674         gen_save_pc(ctx->pc);
 675         ctx->saved_pc = ctx->pc;
 676     }
 677     if (ctx->hflags != ctx->saved_hflags) {
 678         gen_op_save_state(ctx->hflags);
 679         ctx->saved_hflags = ctx->hflags;
 680         switch (ctx->hflags & MIPS_HFLAG_BMASK) {
 681         case MIPS_HFLAG_BR:
 682             gen_op_save_breg_target();
 683             break;
 684         case MIPS_HFLAG_BC:
 685             gen_op_save_bcond();
 686             /* fall through */
 687         case MIPS_HFLAG_BL:
 688             /* bcond was already saved by the BL insn */
 689             /* fall through */
 690         case MIPS_HFLAG_B:
 691             gen_save_btarget(ctx->btarget);
 692             break;
 693         }
 694     }
 695 }
 696
 697 static inline void restore_cpu_state (CPUState *env, DisasContext *ctx)
 698 {
 699     ctx->saved_hflags = ctx->hflags;
 700     switch (ctx->hflags & MIPS_HFLAG_BMASK) {
 701     case MIPS_HFLAG_BR:
 702         gen_op_restore_breg_target();
 703         break;
 704     case MIPS_HFLAG_B:
 705         ctx->btarget = env->btarget;
 706         break;
 707     case MIPS_HFLAG_BC:
 708     case MIPS_HFLAG_BL:
 709         ctx->btarget = env->btarget;
 710         gen_op_restore_bcond();
 711         break;
 712     }
 713 }
 714
 715 static inline void generate_exception_err (DisasContext *ctx, int excp, int err)
 716 {
 717 #if defined MIPS_DEBUG_DISAS
 718     if (loglevel & CPU_LOG_TB_IN_ASM)
 719             fprintf(logfile, "%s: raise exception %d\n", __func__, excp);
 720 #endif
 721     save_cpu_state(ctx, 1);
 722     if (err == 0)
 723         gen_op_raise_exception(excp);
 724     else
 725         gen_op_raise_exception_err(excp, err);
 726     ctx->bstate = BS_EXCP;
 727 }
 728
 729 static inline void generate_exception (DisasContext *ctx, int excp)
 730 {
 731     generate_exception_err (ctx, excp, 0);
 732 }
 733
 734 static inline void check_cp0_enabled(DisasContext *ctx)
 735 {
 736     if (unlikely(!(ctx->hflags & MIPS_HFLAG_CP0)))
 737         generate_exception_err(ctx, EXCP_CpU, 1);
 738 }
 739
 740 static inline void check_cp1_enabled(DisasContext *ctx)
 741 {
 742     if (unlikely(!(ctx->hflags & MIPS_HFLAG_FPU)))
 743         generate_exception_err(ctx, EXCP_CpU, 1);
 744 }
 745
 746 static inline void check_cp1_64bitmode(DisasContext *ctx)
 747 {
 748     if (unlikely(!(ctx->hflags & MIPS_HFLAG_F64)))
 749         generate_exception(ctx, EXCP_RI);
 750 }
 751
 752 /*
 753  * Verify if floating point register is valid; an operation is not defined
 754  * if bit 0 of any register specification is set and the FR bit in the
 755  * Status register equals zero, since the register numbers specify an
 756  * even-odd pair of adjacent coprocessor general registers. When the FR bit
 757  * in the Status register equals one, both even and odd register numbers
 758  * are valid. This limitation exists only for 64 bit wide (d,l,ps) registers.
 759  *
 760  * Multiple 64 bit wide registers can be checked by calling
 761  * gen_op_cp1_registers(freg1 | freg2 | ... | fregN);
 762  */
 763 void check_cp1_registers(DisasContext *ctx, int regs)
 764 {
 765     if (unlikely(!(ctx->hflags & MIPS_HFLAG_F64) && (regs & 1)))
 766         generate_exception(ctx, EXCP_RI);
 767 }
 768
 769 /* This code generates a "reserved instruction" exception if the
 770    CPU does not support the instruction set corresponding to flags. */
 771 static inline void check_insn(CPUState *env, DisasContext *ctx, int flags)
 772 {
 773     if (unlikely(!(env->insn_flags & flags)))
 774         generate_exception(ctx, EXCP_RI);
 775 }
 776
 777 /* This code generates a "reserved instruction" exception if the
 778    CPU is not MIPS MT capable. */
 779 static inline void check_mips_mt(CPUState *env, DisasContext *ctx)
 780 {
 781     if (unlikely(!(env->CP0_Config3 & (1 << CP0C3_MT))))
 782         generate_exception(ctx, EXCP_RI);
 783 }
 784
 785 /* This code generates a "reserved instruction" exception if 64-bit
 786    instructions are not enabled. */
 787 static inline void check_mips_64(DisasContext *ctx)
 788 {
 789     if (unlikely(!(ctx->hflags & MIPS_HFLAG_64)))
 790         generate_exception(ctx, EXCP_RI);
 791 }
 792
 793 #if defined(CONFIG_USER_ONLY)
 794 #define op_ldst(name)        gen_op_##name##_raw()
 795 #define OP_LD_TABLE(width)
 796 #define OP_ST_TABLE(width)
 797 #else
 798 #define op_ldst(name)        (*gen_op_##name[ctx->mem_idx])()
 799 #define OP_LD_TABLE(width)                                                    \
 800 static GenOpFunc *gen_op_l##width[] = {                                       \
 801     &gen_op_l##width##_user,                                                  \
 802     &gen_op_l##width##_kernel,                                                \
 803 }
 804 #define OP_ST_TABLE(width)                                                    \
 805 static GenOpFunc *gen_op_s##width[] = {                                       \
 806     &gen_op_s##width##_user,                                                  \
 807     &gen_op_s##width##_kernel,                                                \
 808 }
 809 #endif
 810
 811 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
 812 OP_LD_TABLE(d);
 813 OP_LD_TABLE(dl);
 814 OP_LD_TABLE(dr);
 815 OP_ST_TABLE(d);
 816 OP_ST_TABLE(dl);
 817 OP_ST_TABLE(dr);
 818 OP_LD_TABLE(ld);
 819 OP_ST_TABLE(cd);
 820 OP_LD_TABLE(wu);
 821 #endif
 822 OP_LD_TABLE(w);
 823 OP_LD_TABLE(wl);
 824 OP_LD_TABLE(wr);
 825 OP_ST_TABLE(w);
 826 OP_ST_TABLE(wl);
 827 OP_ST_TABLE(wr);
 828 OP_LD_TABLE(h);
 829 OP_LD_TABLE(hu);
 830 OP_ST_TABLE(h);
 831 OP_LD_TABLE(b);
 832 OP_LD_TABLE(bu);
 833 OP_ST_TABLE(b);
 834 OP_LD_TABLE(l);
 835 OP_ST_TABLE(c);
 836 OP_LD_TABLE(wc1);
 837 OP_ST_TABLE(wc1);
 838 OP_LD_TABLE(dc1);
 839 OP_ST_TABLE(dc1);
 840 OP_LD_TABLE(uxc1);
 841 OP_ST_TABLE(uxc1);
 842
 843 /* Load and store */
 844 static void gen_ldst (DisasContext *ctx, uint32_t opc, int rt,
 845                       int base, int16_t offset)
 846 {
 847     const char *opn = "ldst";
 848
 849     if (base == 0) {
 850         GEN_LOAD_IMM_TN(T0, offset);
 851     } else if (offset == 0) {
 852         gen_op_load_gpr_T0(base);
 853     } else {
 854         gen_op_load_gpr_T0(base);
 855         gen_op_set_T1(offset);
 856         gen_op_addr_add();
 857     }
 858     /* Don't do NOP if destination is zero: we must perform the actual
 859        memory access. */
 860     switch (opc) {
 861 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
 862     case OPC_LWU:
 863         op_ldst(lwu);
 864         GEN_STORE_TN_REG(rt, T0);
 865         opn = "lwu";
 866         break;
 867     case OPC_LD:
 868         op_ldst(ld);
 869         GEN_STORE_TN_REG(rt, T0);
 870         opn = "ld";
 871         break;
 872     case OPC_LLD:
 873         op_ldst(lld);
 874         GEN_STORE_TN_REG(rt, T0);
 875         opn = "lld";
 876         break;
 877     case OPC_SD:
 878         GEN_LOAD_REG_TN(T1, rt);
 879         op_ldst(sd);
 880         opn = "sd";
 881         break;
 882     case OPC_SCD:
 883         save_cpu_state(ctx, 1);
 884         GEN_LOAD_REG_TN(T1, rt);
 885         op_ldst(scd);
 886         GEN_STORE_TN_REG(rt, T0);
 887         opn = "scd";
 888         break;
 889     case OPC_LDL:
 890         GEN_LOAD_REG_TN(T1, rt);
 891         op_ldst(ldl);
 892         GEN_STORE_TN_REG(rt, T1);
 893         opn = "ldl";
 894         break;
 895     case OPC_SDL:
 896         GEN_LOAD_REG_TN(T1, rt);
 897         op_ldst(sdl);
 898         opn = "sdl";
 899         break;
 900     case OPC_LDR:
 901         GEN_LOAD_REG_TN(T1, rt);
 902         op_ldst(ldr);
 903         GEN_STORE_TN_REG(rt, T1);
 904         opn = "ldr";
 905         break;
 906     case OPC_SDR:
 907         GEN_LOAD_REG_TN(T1, rt);
 908         op_ldst(sdr);
 909         opn = "sdr";
 910         break;
 911 #endif
 912     case OPC_LW:
 913         op_ldst(lw);
 914         GEN_STORE_TN_REG(rt, T0);
 915         opn = "lw";
 916         break;
 917     case OPC_SW:
 918         GEN_LOAD_REG_TN(T1, rt);
 919         op_ldst(sw);
 920         opn = "sw";
 921         break;
 922     case OPC_LH:
 923         op_ldst(lh);
 924         GEN_STORE_TN_REG(rt, T0);
 925         opn = "lh";
 926         break;
 927     case OPC_SH:
 928         GEN_LOAD_REG_TN(T1, rt);
 929         op_ldst(sh);
 930         opn = "sh";
 931         break;
 932     case OPC_LHU:
 933         op_ldst(lhu);
 934         GEN_STORE_TN_REG(rt, T0);
 935         opn = "lhu";
 936         break;
 937     case OPC_LB:
 938         op_ldst(lb);
 939         GEN_STORE_TN_REG(rt, T0);
 940         opn = "lb";
 941         break;
 942     case OPC_SB:
 943         GEN_LOAD_REG_TN(T1, rt);
 944         op_ldst(sb);
 945         opn = "sb";
 946         break;
 947     case OPC_LBU:
 948         op_ldst(lbu);
 949         GEN_STORE_TN_REG(rt, T0);
 950         opn = "lbu";
 951         break;
 952     case OPC_LWL:
 953         GEN_LOAD_REG_TN(T1, rt);
 954         op_ldst(lwl);
 955         GEN_STORE_TN_REG(rt, T1);
 956         opn = "lwl";
 957         break;
 958     case OPC_SWL:
 959         GEN_LOAD_REG_TN(T1, rt);
 960         op_ldst(swl);
 961         opn = "swr";
 962         break;
 963     case OPC_LWR:
 964         GEN_LOAD_REG_TN(T1, rt);
 965         op_ldst(lwr);
 966         GEN_STORE_TN_REG(rt, T1);
 967         opn = "lwr";
 968         break;
 969     case OPC_SWR:
 970         GEN_LOAD_REG_TN(T1, rt);
 971         op_ldst(swr);
 972         opn = "swr";
 973         break;
 974     case OPC_LL:
 975         op_ldst(ll);
 976         GEN_STORE_TN_REG(rt, T0);
 977         opn = "ll";
 978         break;
 979     case OPC_SC:
 980         save_cpu_state(ctx, 1);
 981         GEN_LOAD_REG_TN(T1, rt);
 982         op_ldst(sc);
 983         GEN_STORE_TN_REG(rt, T0);
 984         opn = "sc";
 985         break;
 986     default:
 987         MIPS_INVAL(opn);
 988         generate_exception(ctx, EXCP_RI);
 989         return;
 990     }
 991     MIPS_DEBUG("%s %s, %d(%s)", opn, regnames[rt], offset, regnames[base]);
 992 }
 993
 994 /* Load and store */
 995 static void gen_flt_ldst (DisasContext *ctx, uint32_t opc, int ft,
 996                       int base, int16_t offset)
 997 {
 998     const char *opn = "flt_ldst";
 999
1000     if (base == 0) {
1001         GEN_LOAD_IMM_TN(T0, offset);
1002     } else if (offset == 0) {
1003         gen_op_load_gpr_T0(base);
1004     } else {
1005         gen_op_load_gpr_T0(base);
1006         gen_op_set_T1(offset);
1007         gen_op_addr_add();
1008     }
1009     /* Don't do NOP if destination is zero: we must perform the actual
1010        memory access. */
1011     switch (opc) {
1012     case OPC_LWC1:
1013         op_ldst(lwc1);
1014         GEN_STORE_FTN_FREG(ft, WT0);
1015         opn = "lwc1";
1016         break;
1017     case OPC_SWC1:
1018         GEN_LOAD_FREG_FTN(WT0, ft);
1019         op_ldst(swc1);
1020         opn = "swc1";
1021         break;
1022     case OPC_LDC1:
1023         op_ldst(ldc1);
1024         GEN_STORE_FTN_FREG(ft, DT0);
1025         opn = "ldc1";
1026         break;
1027     case OPC_SDC1:
1028         GEN_LOAD_FREG_FTN(DT0, ft);
1029         op_ldst(sdc1);
1030         opn = "sdc1";
1031         break;
1032     default:
1033         MIPS_INVAL(opn);
1034         generate_exception(ctx, EXCP_RI);
1035         return;
1036     }
1037     MIPS_DEBUG("%s %s, %d(%s)", opn, fregnames[ft], offset, regnames[base]);
1038 }
1039
1040 /* Arithmetic with immediate operand */
1041 static void gen_arith_imm (CPUState *env, DisasContext *ctx, uint32_t opc,
1042                            int rt, int rs, int16_t imm)
1043 {
1044     target_ulong uimm;
1045     const char *opn = "imm arith";
1046
1047     if (rt == 0 && opc != OPC_ADDI && opc != OPC_DADDI) {
1048         /* If no destination, treat it as a NOP.
1049            For addi, we must generate the overflow exception when needed. */
1050         MIPS_DEBUG("NOP");
1051         return;
1052     }
1053     uimm = (uint16_t)imm;
1054     switch (opc) {
1055     case OPC_ADDI:
1056     case OPC_ADDIU:
1057 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
1058     case OPC_DADDI:
1059     case OPC_DADDIU:
1060 #endif
1061     case OPC_SLTI:
1062     case OPC_SLTIU:
1063         uimm = (target_long)imm; /* Sign extend to 32/64 bits */
1064         /* Fall through. */
1065     case OPC_ANDI:
1066     case OPC_ORI:
1067     case OPC_XORI:
1068         GEN_LOAD_REG_TN(T0, rs);
1069         GEN_LOAD_IMM_TN(T1, uimm);
1070         break;
1071     case OPC_LUI:
1072         GEN_LOAD_IMM_TN(T0, imm << 16);
1073         break;
1074     case OPC_SLL:
1075     case OPC_SRA:
1076     case OPC_SRL:
1077 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
1078     case OPC_DSLL:
1079     case OPC_DSRA:
1080     case OPC_DSRL:
1081     case OPC_DSLL32:
1082     case OPC_DSRA32:
1083     case OPC_DSRL32:
1084 #endif
1085         uimm &= 0x1f;
1086         GEN_LOAD_REG_TN(T0, rs);
1087         GEN_LOAD_IMM_TN(T1, uimm);
1088         break;
1089     }
1090     switch (opc) {
1091     case OPC_ADDI:
1092         save_cpu_state(ctx, 1);
1093         gen_op_addo();
1094         opn = "addi";
1095         break;
1096     case OPC_ADDIU:
1097         gen_op_add();
1098         opn = "addiu";
1099         break;
1100 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
1101     case OPC_DADDI:
1102         save_cpu_state(ctx, 1);
1103         gen_op_daddo();
1104         opn = "daddi";
1105         break;
1106     case OPC_DADDIU:
1107         gen_op_dadd();
1108         opn = "daddiu";
1109         break;
1110 #endif
1111     case OPC_SLTI:
1112         gen_op_lt();
1113         opn = "slti";
1114         break;
1115     case OPC_SLTIU:
1116         gen_op_ltu();
1117         opn = "sltiu";
1118         break;
1119     case OPC_ANDI:
1120         gen_op_and();
1121         opn = "andi";
1122         break;
1123     case OPC_ORI:
1124         gen_op_or();
1125         opn = "ori";
1126         break;
1127     case OPC_XORI:
1128         gen_op_xor();
1129         opn = "xori";
1130         break;
1131     case OPC_LUI:
1132         opn = "lui";
1133         break;
1134     case OPC_SLL:
1135         gen_op_sll();
1136         opn = "sll";
1137         break;
1138     case OPC_SRA:
1139         gen_op_sra();
1140         opn = "sra";
1141         break;
1142     case OPC_SRL:
1143         switch ((ctx->opcode >> 21) & 0x1f) {
1144         case 0:
1145             gen_op_srl();
1146             opn = "srl";
1147             break;
1148         case 1:
1149             /* rotr is decoded as srl on non-R2 CPUs */
1150             if (env->insn_flags & ISA_MIPS32R2) {
1151                 gen_op_rotr();
1152                 opn = "rotr";
1153             } else {
1154                 gen_op_srl();
1155                 opn = "srl";
1156             }
1157             break;
1158         default:
1159             MIPS_INVAL("invalid srl flag");
1160             generate_exception(ctx, EXCP_RI);
1161             break;
1162         }
1163         break;
1164 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
1165     case OPC_DSLL:
1166         gen_op_dsll();
1167         opn = "dsll";
1168         break;
1169     case OPC_DSRA:
1170         gen_op_dsra();
1171         opn = "dsra";
1172         break;
1173     case OPC_DSRL:
1174         switch ((ctx->opcode >> 21) & 0x1f) {
1175         case 0:
1176             gen_op_dsrl();
1177             opn = "dsrl";
1178             break;
1179         case 1:
1180             /* drotr is decoded as dsrl on non-R2 CPUs */
1181             if (env->insn_flags & ISA_MIPS32R2) {
1182                 gen_op_drotr();
1183                 opn = "drotr";
1184             } else {
1185                 gen_op_dsrl();
1186                 opn = "dsrl";
1187             }
1188             break;
1189         default:
1190             MIPS_INVAL("invalid dsrl flag");
1191             generate_exception(ctx, EXCP_RI);
1192             break;
1193         }
1194         break;
1195     case OPC_DSLL32:
1196         gen_op_dsll32();
1197         opn = "dsll32";
1198         break;
1199     case OPC_DSRA32:
1200         gen_op_dsra32();
1201         opn = "dsra32";
1202         break;
1203     case OPC_DSRL32:
1204         switch ((ctx->opcode >> 21) & 0x1f) {
1205         case 0:
1206             gen_op_dsrl32();
1207             opn = "dsrl32";
1208             break;
1209         case 1:
1210             /* drotr32 is decoded as dsrl32 on non-R2 CPUs */
1211             if (env->insn_flags & ISA_MIPS32R2) {
1212                 gen_op_drotr32();
1213                 opn = "drotr32";
1214             } else {
1215                 gen_op_dsrl32();
1216                 opn = "dsrl32";
1217             }
1218             break;
1219         default:
1220             MIPS_INVAL("invalid dsrl32 flag");
1221             generate_exception(ctx, EXCP_RI);
1222             break;
1223         }
1224         break;
1225 #endif
1226     default:
1227         MIPS_INVAL(opn);
1228         generate_exception(ctx, EXCP_RI);
1229         return;
1230     }
1231     GEN_STORE_TN_REG(rt, T0);
1232     MIPS_DEBUG("%s %s, %s, " TARGET_FMT_lx, opn, regnames[rt], regnames[rs], uimm);
1233 }
1234
1235 /* Arithmetic */
1236 static void gen_arith (CPUState *env, DisasContext *ctx, uint32_t opc,
1237                        int rd, int rs, int rt)
1238 {
1239     const char *opn = "arith";
1240
1241     if (rd == 0 && opc != OPC_ADD && opc != OPC_SUB
1242        && opc != OPC_DADD && opc != OPC_DSUB) {
1243         /* If no destination, treat it as a NOP.
1244            For add & sub, we must generate the overflow exception when needed. */
1245         MIPS_DEBUG("NOP");
1246         return;
1247     }
1248     GEN_LOAD_REG_TN(T0, rs);
1249     GEN_LOAD_REG_TN(T1, rt);
1250     switch (opc) {
1251     case OPC_ADD:
1252         save_cpu_state(ctx, 1);
1253         gen_op_addo();
1254         opn = "add";
1255         break;
1256     case OPC_ADDU:
1257         gen_op_add();
1258         opn = "addu";
1259         break;
1260     case OPC_SUB:
1261         save_cpu_state(ctx, 1);
1262         gen_op_subo();
1263         opn = "sub";
1264         break;
1265     case OPC_SUBU:
1266         gen_op_sub();
1267         opn = "subu";
1268         break;
1269 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
1270     case OPC_DADD:
1271         save_cpu_state(ctx, 1);
1272         gen_op_daddo();
1273         opn = "dadd";
1274         break;
1275     case OPC_DADDU:
1276         gen_op_dadd();
1277         opn = "daddu";
1278         break;
1279     case OPC_DSUB:
1280         save_cpu_state(ctx, 1);
1281         gen_op_dsubo();
1282         opn = "dsub";
1283         break;
1284     case OPC_DSUBU:
1285         gen_op_dsub();
1286         opn = "dsubu";
1287         break;
1288 #endif
1289     case OPC_SLT:
1290         gen_op_lt();
1291         opn = "slt";
1292         break;
1293     case OPC_SLTU:
1294         gen_op_ltu();
1295         opn = "sltu";
1296         break;
1297     case OPC_AND:
1298         gen_op_and();
1299         opn = "and";
1300         break;
1301     case OPC_NOR:
1302         gen_op_nor();
1303         opn = "nor";
1304         break;
1305     case OPC_OR:
1306         gen_op_or();
1307         opn = "or";
1308         break;
1309     case OPC_XOR:
1310         gen_op_xor();
1311         opn = "xor";
1312         break;
1313     case OPC_MUL:
1314         gen_op_mul();
1315         opn = "mul";
1316         break;
1317     case OPC_MOVN:
1318         gen_op_movn(rd);
1319         opn = "movn";
1320         goto print;
1321     case OPC_MOVZ:
1322         gen_op_movz(rd);
1323         opn = "movz";
1324         goto print;
1325     case OPC_SLLV:
1326         gen_op_sllv();
1327         opn = "sllv";
1328         break;
1329     case OPC_SRAV:
1330         gen_op_srav();
1331         opn = "srav";
1332         break;
1333     case OPC_SRLV:
1334         switch ((ctx->opcode >> 6) & 0x1f) {
1335         case 0:
1336             gen_op_srlv();
1337             opn = "srlv";
1338             break;
1339         case 1:
1340             /* rotrv is decoded as srlv on non-R2 CPUs */
1341             if (env->insn_flags & ISA_MIPS32R2) {
1342                 gen_op_rotrv();
1343                 opn = "rotrv";
1344             } else {
1345                 gen_op_srlv();
1346                 opn = "srlv";
1347             }
1348             break;
1349         default:
1350             MIPS_INVAL("invalid srlv flag");
1351             generate_exception(ctx, EXCP_RI);
1352             break;
1353         }
1354         break;
1355 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
1356     case OPC_DSLLV:
1357         gen_op_dsllv();
1358         opn = "dsllv";
1359         break;
1360     case OPC_DSRAV:
1361         gen_op_dsrav();
1362         opn = "dsrav";
1363         break;
1364     case OPC_DSRLV:
1365         switch ((ctx->opcode >> 6) & 0x1f) {
1366         case 0:
1367             gen_op_dsrlv();
1368             opn = "dsrlv";
1369             break;
1370         case 1:
1371             /* drotrv is decoded as dsrlv on non-R2 CPUs */
1372             if (env->insn_flags & ISA_MIPS32R2) {
1373                 gen_op_drotrv();
1374                 opn = "drotrv";
1375             } else {
1376                 gen_op_dsrlv();
1377                 opn = "dsrlv";
1378             }
1379             break;
1380         default:
1381             MIPS_INVAL("invalid dsrlv flag");
1382             generate_exception(ctx, EXCP_RI);
1383             break;
1384         }
1385         break;
1386 #endif
1387     default:
1388         MIPS_INVAL(opn);
1389         generate_exception(ctx, EXCP_RI);
1390         return;
1391     }
1392     GEN_STORE_TN_REG(rd, T0);
1393  print:
1394     MIPS_DEBUG("%s %s, %s, %s", opn, regnames[rd], regnames[rs], regnames[rt]);
1395 }
1396
1397 /* Arithmetic on HI/LO registers */
1398 static void gen_HILO (DisasContext *ctx, uint32_t opc, int reg)
1399 {
1400     const char *opn = "hilo";
1401
1402     if (reg == 0 && (opc == OPC_MFHI || opc == OPC_MFLO)) {
1403         /* Treat as NOP. */
1404         MIPS_DEBUG("NOP");
1405         return;
1406     }
1407     switch (opc) {
1408     case OPC_MFHI:
1409         gen_op_load_HI(0);
1410         GEN_STORE_TN_REG(reg, T0);
1411         opn = "mfhi";
1412         break;
1413     case OPC_MFLO:
1414         gen_op_load_LO(0);
1415         GEN_STORE_TN_REG(reg, T0);
1416         opn = "mflo";
1417         break;
1418     case OPC_MTHI:
1419         GEN_LOAD_REG_TN(T0, reg);
1420         gen_op_store_HI(0);
1421         opn = "mthi";
1422         break;
1423     case OPC_MTLO:
1424         GEN_LOAD_REG_TN(T0, reg);
1425         gen_op_store_LO(0);
1426         opn = "mtlo";
1427         break;
1428     default:
1429         MIPS_INVAL(opn);
1430         generate_exception(ctx, EXCP_RI);
1431         return;
1432     }
1433     MIPS_DEBUG("%s %s", opn, regnames[reg]);
1434 }
1435
1436 static void gen_muldiv (DisasContext *ctx, uint32_t opc,
1437                         int rs, int rt)
1438 {
1439     const char *opn = "mul/div";
1440
1441     GEN_LOAD_REG_TN(T0, rs);
1442     GEN_LOAD_REG_TN(T1, rt);
1443     switch (opc) {
1444     case OPC_DIV:
1445         gen_op_div();
1446         opn = "div";
1447         break;
1448     case OPC_DIVU:
1449         gen_op_divu();
1450         opn = "divu";
1451         break;
1452     case OPC_MULT:
1453         gen_op_mult();
1454         opn = "mult";
1455         break;
1456     case OPC_MULTU:
1457         gen_op_multu();
1458         opn = "multu";
1459         break;
1460 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
1461     case OPC_DDIV:
1462         gen_op_ddiv();
1463         opn = "ddiv";
1464         break;
1465     case OPC_DDIVU:
1466         gen_op_ddivu();
1467         opn = "ddivu";
1468         break;
1469     case OPC_DMULT:
1470         gen_op_dmult();
1471         opn = "dmult";
1472         break;
1473     case OPC_DMULTU:
1474         gen_op_dmultu();
1475         opn = "dmultu";
1476         break;
1477 #endif
1478     case OPC_MADD:
1479         gen_op_madd();
1480         opn = "madd";
1481         break;
1482     case OPC_MADDU:
1483         gen_op_maddu();
1484         opn = "maddu";
1485         break;
1486     case OPC_MSUB:
1487         gen_op_msub();
1488         opn = "msub";
1489         break;
1490     case OPC_MSUBU:
1491         gen_op_msubu();
1492         opn = "msubu";
1493         break;
1494     default:
1495         MIPS_INVAL(opn);
1496         generate_exception(ctx, EXCP_RI);
1497         return;
1498     }
1499     MIPS_DEBUG("%s %s %s", opn, regnames[rs], regnames[rt]);
1500 }
1501
1502 static void gen_cl (DisasContext *ctx, uint32_t opc,
1503                     int rd, int rs)
1504 {
1505     const char *opn = "CLx";
1506     if (rd == 0) {
1507         /* Treat as NOP. */
1508         MIPS_DEBUG("NOP");
1509         return;
1510     }
1511     GEN_LOAD_REG_TN(T0, rs);
1512     switch (opc) {
1513     case OPC_CLO:
1514         gen_op_clo();
1515         opn = "clo";
1516         break;
1517     case OPC_CLZ:
1518         gen_op_clz();
1519         opn = "clz";
1520         break;
1521 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
1522     case OPC_DCLO:
1523         gen_op_dclo();
1524         opn = "dclo";
1525         break;
1526     case OPC_DCLZ:
1527         gen_op_dclz();
1528         opn = "dclz";
1529         break;
1530 #endif
1531     default:
1532         MIPS_INVAL(opn);
1533         generate_exception(ctx, EXCP_RI);
1534         return;
1535     }
1536     gen_op_store_T0_gpr(rd);
1537     MIPS_DEBUG("%s %s, %s", opn, regnames[rd], regnames[rs]);
1538 }
1539
1540 /* Traps */
1541 static void gen_trap (DisasContext *ctx, uint32_t opc,
1542                       int rs, int rt, int16_t imm)
1543 {
1544     int cond;
1545
1546     cond = 0;
1547     /* Load needed operands */
1548     switch (opc) {
1549     case OPC_TEQ:
1550     case OPC_TGE:
1551     case OPC_TGEU:
1552     case OPC_TLT:
1553     case OPC_TLTU:
1554     case OPC_TNE:
1555         /* Compare two registers */
1556         if (rs != rt) {
1557             GEN_LOAD_REG_TN(T0, rs);
1558             GEN_LOAD_REG_TN(T1, rt);
1559             cond = 1;
1560         }
1561         break;
1562     case OPC_TEQI:
1563     case OPC_TGEI:
1564     case OPC_TGEIU:
1565     case OPC_TLTI:
1566     case OPC_TLTIU:
1567     case OPC_TNEI:
1568         /* Compare register to immediate */
1569         if (rs != 0 || imm != 0) {
1570             GEN_LOAD_REG_TN(T0, rs);
1571             GEN_LOAD_IMM_TN(T1, (int32_t)imm);
1572             cond = 1;
1573         }
1574         break;
1575     }
1576     if (cond == 0) {
1577         switch (opc) {
1578         case OPC_TEQ:   /* rs == rs */
1579         case OPC_TEQI:  /* r0 == 0  */
1580         case OPC_TGE:   /* rs >= rs */
1581         case OPC_TGEI:  /* r0 >= 0  */
1582         case OPC_TGEU:  /* rs >= rs unsigned */
1583         case OPC_TGEIU: /* r0 >= 0  unsigned */
1584             /* Always trap */
1585             gen_op_set_T0(1);
1586             break;
1587         case OPC_TLT:   /* rs < rs           */
1588         case OPC_TLTI:  /* r0 < 0            */
1589         case OPC_TLTU:  /* rs < rs unsigned  */
1590         case OPC_TLTIU: /* r0 < 0  unsigned  */
1591         case OPC_TNE:   /* rs != rs          */
1592         case OPC_TNEI:  /* r0 != 0           */
1593             /* Never trap: treat as NOP. */
1594             return;
1595         default:
1596             MIPS_INVAL("trap");
1597             generate_exception(ctx, EXCP_RI);
1598             return;
1599         }
1600     } else {
1601         switch (opc) {
1602         case OPC_TEQ:
1603         case OPC_TEQI:
1604             gen_op_eq();
1605             break;
1606         case OPC_TGE:
1607         case OPC_TGEI:
1608             gen_op_ge();
1609             break;
1610         case OPC_TGEU:
1611         case OPC_TGEIU:
1612             gen_op_geu();
1613             break;
1614         case OPC_TLT:
1615         case OPC_TLTI:
1616             gen_op_lt();
1617             break;
1618         case OPC_TLTU:
1619         case OPC_TLTIU:
1620             gen_op_ltu();
1621             break;
1622         case OPC_TNE:
1623         case OPC_TNEI:
1624             gen_op_ne();
1625             break;
1626         default:
1627             MIPS_INVAL("trap");
1628             generate_exception(ctx, EXCP_RI);
1629             return;
1630         }
1631     }
1632     save_cpu_state(ctx, 1);
1633     gen_op_trap();
1634     ctx->bstate = BS_STOP;
1635 }
1636
1637 static inline void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
1638 {
1639     TranslationBlock *tb;
1640     tb = ctx->tb;
1641     if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
1642         if (n == 0)
1643             gen_op_goto_tb0(TBPARAM(tb));
1644         else
1645             gen_op_goto_tb1(TBPARAM(tb));
1646         gen_save_pc(dest);
1647         gen_op_set_T0((long)tb + n);
1648     } else {
1649         gen_save_pc(dest);
1650         gen_op_reset_T0();
1651     }
1652     gen_op_exit_tb();
1653 }
1654
1655 /* Branches (before delay slot) */
1656 static void gen_compute_branch (DisasContext *ctx, uint32_t opc,
1657                                 int rs, int rt, int32_t offset)
1658 {
1659     target_ulong btarget = -1;
1660     int blink = 0;
1661     int bcond = 0;
1662
1663     if (ctx->hflags & MIPS_HFLAG_BMASK) {
1664 #ifdef MIPS_DEBUG_DISAS
1665         if (loglevel & CPU_LOG_TB_IN_ASM) {
1666             fprintf(logfile,
1667                     "Branch in delay slot at PC 0x" TARGET_FMT_lx "\n",
1668                     ctx->pc);
1669         }
1670 #endif
1671         generate_exception(ctx, EXCP_RI);
1672         return;
1673     }
1674
1675     /* Load needed operands */
1676     switch (opc) {
1677     case OPC_BEQ:
1678     case OPC_BEQL:
1679     case OPC_BNE:
1680     case OPC_BNEL:
1681         /* Compare two registers */
1682         if (rs != rt) {
1683             GEN_LOAD_REG_TN(T0, rs);
1684             GEN_LOAD_REG_TN(T1, rt);
1685             bcond = 1;
1686         }
1687         btarget = ctx->pc + 4 + offset;
1688         break;
1689     case OPC_BGEZ:
1690     case OPC_BGEZAL:
1691     case OPC_BGEZALL:
1692     case OPC_BGEZL:
1693     case OPC_BGTZ:
1694     case OPC_BGTZL:
1695     case OPC_BLEZ:
1696     case OPC_BLEZL:
1697     case OPC_BLTZ:
1698     case OPC_BLTZAL:
1699     case OPC_BLTZALL:
1700     case OPC_BLTZL:
1701         /* Compare to zero */
1702         if (rs != 0) {
1703             gen_op_load_gpr_T0(rs);
1704             bcond = 1;
1705         }
1706         btarget = ctx->pc + 4 + offset;
1707         break;
1708     case OPC_J:
1709     case OPC_JAL:
1710         /* Jump to immediate */
1711         btarget = ((ctx->pc + 4) & (int32_t)0xF0000000) | (uint32_t)offset;
1712         break;
1713     case OPC_JR:
1714     case OPC_JALR:
1715         /* Jump to register */
1716         if (offset != 0 && offset != 16) {
1717             /* Hint = 0 is JR/JALR, hint 16 is JR.HB/JALR.HB, the
1718                others are reserved. */
1719             MIPS_INVAL("jump hint");
1720             generate_exception(ctx, EXCP_RI);
1721             return;
1722         }
1723         GEN_LOAD_REG_TN(T2, rs);
1724         break;
1725     default:
1726         MIPS_INVAL("branch/jump");
1727         generate_exception(ctx, EXCP_RI);
1728         return;
1729     }
1730     if (bcond == 0) {
1731         /* No condition to be computed */
1732         switch (opc) {
1733         case OPC_BEQ:     /* rx == rx        */
1734         case OPC_BEQL:    /* rx == rx likely */
1735         case OPC_BGEZ:    /* 0 >= 0          */
1736         case OPC_BGEZL:   /* 0 >= 0 likely   */
1737         case OPC_BLEZ:    /* 0 <= 0          */
1738         case OPC_BLEZL:   /* 0 <= 0 likely   */
1739             /* Always take */
1740             ctx->hflags |= MIPS_HFLAG_B;
1741             MIPS_DEBUG("balways");
1742             break;
1743         case OPC_BGEZAL:  /* 0 >= 0          */
1744         case OPC_BGEZALL: /* 0 >= 0 likely   */
1745             /* Always take and link */
1746             blink = 31;
1747             ctx->hflags |= MIPS_HFLAG_B;
1748             MIPS_DEBUG("balways and link");
1749             break;
1750         case OPC_BNE:     /* rx != rx        */
1751         case OPC_BGTZ:    /* 0 > 0           */
1752         case OPC_BLTZ:    /* 0 < 0           */
1753             /* Treat as NOP. */
1754             MIPS_DEBUG("bnever (NOP)");
1755             return;
1756         case OPC_BLTZAL:  /* 0 < 0           */
1757             GEN_LOAD_IMM_TN(T0, ctx->pc + 8);
1758             gen_op_store_T0_gpr(31);
1759             MIPS_DEBUG("bnever and link");
1760             return;
1761         case OPC_BLTZALL: /* 0 < 0 likely */
1762             GEN_LOAD_IMM_TN(T0, ctx->pc + 8);
1763             gen_op_store_T0_gpr(31);
1764             /* Skip the instruction in the delay slot */
1765             MIPS_DEBUG("bnever, link and skip");
1766             ctx->pc += 4;
1767             return;
1768         case OPC_BNEL:    /* rx != rx likely */
1769         case OPC_BGTZL:   /* 0 > 0 likely */
1770         case OPC_BLTZL:   /* 0 < 0 likely */
1771             /* Skip the instruction in the delay slot */
1772             MIPS_DEBUG("bnever and skip");
1773             ctx->pc += 4;
1774             return;
1775         case OPC_J:
1776             ctx->hflags |= MIPS_HFLAG_B;
1777             MIPS_DEBUG("j " TARGET_FMT_lx, btarget);
1778             break;
1779         case OPC_JAL:
1780             blink = 31;
1781             ctx->hflags |= MIPS_HFLAG_B;
1782             MIPS_DEBUG("jal " TARGET_FMT_lx, btarget);
1783             break;
1784         case OPC_JR:
1785             ctx->hflags |= MIPS_HFLAG_BR;
1786             MIPS_DEBUG("jr %s", regnames[rs]);
1787             break;
1788         case OPC_JALR:
1789             blink = rt;
1790             ctx->hflags |= MIPS_HFLAG_BR;
1791             MIPS_DEBUG("jalr %s, %s", regnames[rt], regnames[rs]);
1792             break;
1793         default:
1794             MIPS_INVAL("branch/jump");
1795             generate_exception(ctx, EXCP_RI);
1796             return;
1797         }
1798     } else {
1799         switch (opc) {
1800         case OPC_BEQ:
1801             gen_op_eq();
1802             MIPS_DEBUG("beq %s, %s, " TARGET_FMT_lx,
1803                        regnames[rs], regnames[rt], btarget);
1804             goto not_likely;
1805         case OPC_BEQL:
1806             gen_op_eq();
1807             MIPS_DEBUG("beql %s, %s, " TARGET_FMT_lx,
1808                        regnames[rs], regnames[rt], btarget);
1809             goto likely;
1810         case OPC_BNE:
1811             gen_op_ne();
1812             MIPS_DEBUG("bne %s, %s, " TARGET_FMT_lx,
1813                        regnames[rs], regnames[rt], btarget);
1814             goto not_likely;
1815         case OPC_BNEL:
1816             gen_op_ne();
1817             MIPS_DEBUG("bnel %s, %s, " TARGET_FMT_lx,
1818                        regnames[rs], regnames[rt], btarget);
1819             goto likely;
1820         case OPC_BGEZ:
1821             gen_op_gez();
1822             MIPS_DEBUG("bgez %s, " TARGET_FMT_lx, regnames[rs], btarget);
1823             goto not_likely;
1824         case OPC_BGEZL:
1825             gen_op_gez();
1826             MIPS_DEBUG("bgezl %s, " TARGET_FMT_lx, regnames[rs], btarget);
1827             goto likely;
1828         case OPC_BGEZAL:
1829             gen_op_gez();
1830             MIPS_DEBUG("bgezal %s, " TARGET_FMT_lx, regnames[rs], btarget);
1831             blink = 31;
1832             goto not_likely;
1833         case OPC_BGEZALL:
1834             gen_op_gez();
1835             blink = 31;
1836             MIPS_DEBUG("bgezall %s, " TARGET_FMT_lx, regnames[rs], btarget);
1837             goto likely;
1838         case OPC_BGTZ:
1839             gen_op_gtz();
1840             MIPS_DEBUG("bgtz %s, " TARGET_FMT_lx, regnames[rs], btarget);
1841             goto not_likely;
1842         case OPC_BGTZL:
1843             gen_op_gtz();
1844             MIPS_DEBUG("bgtzl %s, " TARGET_FMT_lx, regnames[rs], btarget);
1845             goto likely;
1846         case OPC_BLEZ:
1847             gen_op_lez();
1848             MIPS_DEBUG("blez %s, " TARGET_FMT_lx, regnames[rs], btarget);
1849             goto not_likely;
1850         case OPC_BLEZL:
1851             gen_op_lez();
1852             MIPS_DEBUG("blezl %s, " TARGET_FMT_lx, regnames[rs], btarget);
1853             goto likely;
1854         case OPC_BLTZ:
1855             gen_op_ltz();
1856             MIPS_DEBUG("bltz %s, " TARGET_FMT_lx, regnames[rs], btarget);
1857             goto not_likely;
1858         case OPC_BLTZL:
1859             gen_op_ltz();
1860             MIPS_DEBUG("bltzl %s, " TARGET_FMT_lx, regnames[rs], btarget);
1861             goto likely;
1862         case OPC_BLTZAL:
1863             gen_op_ltz();
1864             blink = 31;
1865             MIPS_DEBUG("bltzal %s, " TARGET_FMT_lx, regnames[rs], btarget);
1866         not_likely:
1867             ctx->hflags |= MIPS_HFLAG_BC;
1868             gen_op_set_bcond();
1869             break;
1870         case OPC_BLTZALL:
1871             gen_op_ltz();
1872             blink = 31;
1873             MIPS_DEBUG("bltzall %s, " TARGET_FMT_lx, regnames[rs], btarget);
1874         likely:
1875             ctx->hflags |= MIPS_HFLAG_BL;
1876             gen_op_set_bcond();
1877             gen_op_save_bcond();
1878             break;
1879         default:
1880             MIPS_INVAL("conditional branch/jump");
1881             generate_exception(ctx, EXCP_RI);
1882             return;
1883         }
1884     }
1885     MIPS_DEBUG("enter ds: link %d cond %02x target " TARGET_FMT_lx,
1886                blink, ctx->hflags, btarget);
1887
1888     ctx->btarget = btarget;
1889     if (blink > 0) {
1890         GEN_LOAD_IMM_TN(T0, ctx->pc + 8);
1891         gen_op_store_T0_gpr(blink);
1892     }
1893 }
1894
1895 /* special3 bitfield operations */
1896 static void gen_bitops (DisasContext *ctx, uint32_t opc, int rt,
1897                        int rs, int lsb, int msb)
1898 {
1899     GEN_LOAD_REG_TN(T1, rs);
1900     switch (opc) {
1901     case OPC_EXT:
1902         if (lsb + msb > 31)
1903             goto fail;
1904         gen_op_ext(lsb, msb + 1);
1905         break;
1906     case OPC_DEXTM:
1907         if (lsb + msb > 63)
1908             goto fail;
1909         gen_op_ext(lsb, msb + 1 + 32);
1910         break;
1911     case OPC_DEXTU:
1912         if (lsb + msb > 63)
1913             goto fail;
1914         gen_op_ext(lsb + 32, msb + 1);
1915         break;
1916     case OPC_DEXT:
1917         gen_op_ext(lsb, msb + 1);
1918         break;
1919     case OPC_INS:
1920         if (lsb > msb)
1921             goto fail;
1922         GEN_LOAD_REG_TN(T0, rt);
1923         gen_op_ins(lsb, msb - lsb + 1);
1924         break;
1925     case OPC_DINSM:
1926         if (lsb > msb)
1927             goto fail;
1928         GEN_LOAD_REG_TN(T0, rt);
1929         gen_op_ins(lsb, msb - lsb + 1 + 32);
1930         break;
1931     case OPC_DINSU:
1932         if (lsb > msb)
1933             goto fail;
1934         GEN_LOAD_REG_TN(T0, rt);
1935         gen_op_ins(lsb + 32, msb - lsb + 1);
1936         break;
1937     case OPC_DINS:
1938         if (lsb > msb)
1939             goto fail;
1940         GEN_LOAD_REG_TN(T0, rt);
1941         gen_op_ins(lsb, msb - lsb + 1);
1942         break;
1943     default:
1944 fail:
1945         MIPS_INVAL("bitops");
1946         generate_exception(ctx, EXCP_RI);
1947         return;
1948     }
1949     GEN_STORE_TN_REG(rt, T0);
1950 }
1951
1952 /* CP0 (MMU and control) */
1953 static void gen_mfc0 (CPUState *env, DisasContext *ctx, int reg, int sel)
1954 {
1955     const char *rn = "invalid";
1956
1957     if (sel != 0)
1958         check_insn(env, ctx, ISA_MIPS32);
1959
1960     switch (reg) {
1961     case 0:
1962         switch (sel) {
1963         case 0:
1964             gen_op_mfc0_index();
1965             rn = "Index";
1966             break;
1967         case 1:
1968             check_mips_mt(env, ctx);
1969             gen_op_mfc0_mvpcontrol();
1970             rn = "MVPControl";
1971             break;
1972         case 2:
1973             check_mips_mt(env, ctx);
1974             gen_op_mfc0_mvpconf0();
1975             rn = "MVPConf0";
1976             break;
1977         case 3:
1978             check_mips_mt(env, ctx);
1979             gen_op_mfc0_mvpconf1();
1980             rn = "MVPConf1";
1981             break;
1982         default:
1983             goto die;
1984         }
1985         break;
1986     case 1:
1987         switch (sel) {
1988         case 0:
1989             gen_op_mfc0_random();
1990             rn = "Random";
1991             break;
1992         case 1:
1993             check_mips_mt(env, ctx);
1994             gen_op_mfc0_vpecontrol();
1995             rn = "VPEControl";
1996             break;
1997         case 2:
1998             check_mips_mt(env, ctx);
1999             gen_op_mfc0_vpeconf0();
2000             rn = "VPEConf0";
2001             break;
2002         case 3:
2003             check_mips_mt(env, ctx);
2004             gen_op_mfc0_vpeconf1();
2005             rn = "VPEConf1";
2006             break;
2007         case 4:
2008             check_mips_mt(env, ctx);
2009             gen_op_mfc0_yqmask();
2010             rn = "YQMask";
2011             break;
2012         case 5:
2013             check_mips_mt(env, ctx);
2014             gen_op_mfc0_vpeschedule();
2015             rn = "VPESchedule";
2016             break;
2017         case 6:
2018             check_mips_mt(env, ctx);
2019             gen_op_mfc0_vpeschefback();
2020             rn = "VPEScheFBack";
2021             break;
2022         case 7:
2023             check_mips_mt(env, ctx);
2024             gen_op_mfc0_vpeopt();
2025             rn = "VPEOpt";
2026             break;
2027         default:
2028             goto die;
2029         }
2030         break;
2031     case 2:
2032         switch (sel) {
2033         case 0:
2034             gen_op_mfc0_entrylo0();
2035             rn = "EntryLo0";
2036             break;
2037         case 1:
2038             check_mips_mt(env, ctx);
2039             gen_op_mfc0_tcstatus();
2040             rn = "TCStatus";
2041             break;
2042         case 2:
2043             check_mips_mt(env, ctx);
2044             gen_op_mfc0_tcbind();
2045             rn = "TCBind";
2046             break;
2047         case 3:
2048             check_mips_mt(env, ctx);
2049             gen_op_mfc0_tcrestart();
2050             rn = "TCRestart";
2051             break;
2052         case 4:
2053             check_mips_mt(env, ctx);
2054             gen_op_mfc0_tchalt();
2055             rn = "TCHalt";
2056             break;
2057         case 5:
2058             check_mips_mt(env, ctx);
2059             gen_op_mfc0_tccontext();
2060             rn = "TCContext";
2061             break;
2062         case 6:
2063             check_mips_mt(env, ctx);
2064             gen_op_mfc0_tcschedule();
2065             rn = "TCSchedule";
2066             break;
2067         case 7:
2068             check_mips_mt(env, ctx);
2069             gen_op_mfc0_tcschefback();
2070             rn = "TCScheFBack";
2071             break;
2072         default:
2073             goto die;
2074         }
2075         break;
2076     case 3:
2077         switch (sel) {
2078         case 0:
2079             gen_op_mfc0_entrylo1();
2080             rn = "EntryLo1";
2081             break;
2082         default:
2083             goto die;
2084         }
2085         break;
2086     case 4:
2087         switch (sel) {
2088         case 0:
2089             gen_op_mfc0_context();
2090             rn = "Context";
2091             break;
2092         case 1:
2093 //            gen_op_mfc0_contextconfig(); /* SmartMIPS ASE */
2094             rn = "ContextConfig";
2095 //            break;
2096         default:
2097             goto die;
2098         }
2099         break;
2100     case 5:
2101         switch (sel) {
2102         case 0:
2103             gen_op_mfc0_pagemask();
2104             rn = "PageMask";
2105             break;
2106         case 1:
2107             check_insn(env, ctx, ISA_MIPS32R2);
2108             gen_op_mfc0_pagegrain();
2109             rn = "PageGrain";
2110             break;
2111         default:
2112             goto die;
2113         }
2114         break;
2115     case 6:
2116         switch (sel) {
2117         case 0:
2118             gen_op_mfc0_wired();
2119             rn = "Wired";
2120             break;
2121         case 1:
2122             check_insn(env, ctx, ISA_MIPS32R2);
2123             gen_op_mfc0_srsconf0();
2124             rn = "SRSConf0";
2125             break;
2126         case 2:
2127             check_insn(env, ctx, ISA_MIPS32R2);
2128             gen_op_mfc0_srsconf1();
2129             rn = "SRSConf1";
2130             break;
2131         case 3:
2132             check_insn(env, ctx, ISA_MIPS32R2);
2133             gen_op_mfc0_srsconf2();
2134             rn = "SRSConf2";
2135             break;
2136         case 4:
2137             check_insn(env, ctx, ISA_MIPS32R2);
2138             gen_op_mfc0_srsconf3();
2139             rn = "SRSConf3";
2140             break;
2141         case 5:
2142             check_insn(env, ctx, ISA_MIPS32R2);
2143             gen_op_mfc0_srsconf4();
2144             rn = "SRSConf4";
2145             break;
2146         default:
2147             goto die;
2148         }
2149         break;
2150     case 7:
2151         switch (sel) {
2152         case 0:
2153             check_insn(env, ctx, ISA_MIPS32R2);
2154             gen_op_mfc0_hwrena();
2155             rn = "HWREna";
2156             break;
2157         default:
2158             goto die;
2159         }
2160         break;
2161     case 8:
2162         switch (sel) {
2163         case 0:
2164             gen_op_mfc0_badvaddr();
2165             rn = "BadVaddr";
2166             break;
2167         default:
2168             goto die;
2169        }
2170         break;
2171     case 9:
2172         switch (sel) {
2173         case 0:
2174             gen_op_mfc0_count();
2175             rn = "Count";
2176             break;
2177         /* 6,7 are implementation dependent */
2178         default:
2179             goto die;
2180         }
2181         break;
2182     case 10:
2183         switch (sel) {
2184         case 0:
2185             gen_op_mfc0_entryhi();
2186             rn = "EntryHi";
2187             break;
2188         default:
2189             goto die;
2190         }
2191         break;
2192     case 11:
2193         switch (sel) {
2194         case 0:
2195             gen_op_mfc0_compare();
2196             rn = "Compare";
2197             break;
2198         /* 6,7 are implementation dependent */
2199         default:
2200             goto die;
2201         }
2202         break;
2203     case 12:
2204         switch (sel) {
2205         case 0:
2206             gen_op_mfc0_status();
2207             rn = "Status";
2208             break;
2209         case 1:
2210             check_insn(env, ctx, ISA_MIPS32R2);
2211             gen_op_mfc0_intctl();
2212             rn = "IntCtl";
2213             break;
2214         case 2:
2215             check_insn(env, ctx, ISA_MIPS32R2);
2216             gen_op_mfc0_srsctl();
2217             rn = "SRSCtl";
2218             break;
2219         case 3:
2220             check_insn(env, ctx, ISA_MIPS32R2);
2221             gen_op_mfc0_srsmap();
2222             rn = "SRSMap";
2223             break;
2224         default:
2225             goto die;
2226        }
2227         break;
2228     case 13:
2229         switch (sel) {
2230         case 0:
2231             gen_op_mfc0_cause();
2232             rn = "Cause";
2233             break;
2234         default:
2235             goto die;
2236        }
2237         break;
2238     case 14:
2239         switch (sel) {
2240         case 0:
2241             gen_op_mfc0_epc();
2242             rn = "EPC";
2243             break;
2244         default:
2245             goto die;
2246         }
2247         break;
2248     case 15:
2249         switch (sel) {
2250         case 0:
2251             gen_op_mfc0_prid();
2252             rn = "PRid";
2253             break;
2254         case 1:
2255             check_insn(env, ctx, ISA_MIPS32R2);
2256             gen_op_mfc0_ebase();
2257             rn = "EBase";
2258             break;
2259         default:
2260             goto die;
2261        }
2262         break;
2263     case 16:
2264         switch (sel) {
2265         case 0:
2266             gen_op_mfc0_config0();
2267             rn = "Config";
2268             break;
2269         case 1:
2270             gen_op_mfc0_config1();
2271             rn = "Config1";
2272             break;
2273         case 2:
2274             gen_op_mfc0_config2();
2275             rn = "Config2";
2276             break;
2277         case 3:
2278             gen_op_mfc0_config3();
2279             rn = "Config3";
2280             break;
2281         /* 4,5 are reserved */
2282         /* 6,7 are implementation dependent */
2283         case 6:
2284             gen_op_mfc0_config6();
2285             rn = "Config6";
2286             break;
2287         case 7:
2288             gen_op_mfc0_config7();
2289             rn = "Config7";
2290             break;
2291         default:
2292             goto die;
2293         }
2294         break;
2295     case 17:
2296         switch (sel) {
2297         case 0:
2298             gen_op_mfc0_lladdr();
2299             rn = "LLAddr";
2300             break;
2301         default:
2302             goto die;
2303         }
2304         break;
2305     case 18:
2306         switch (sel) {
2307         case 0 ... 7:
2308             gen_op_mfc0_watchlo(sel);
2309             rn = "WatchLo";
2310             break;
2311         default:
2312             goto die;
2313         }
2314         break;
2315     case 19:
2316         switch (sel) {
2317         case 0 ...7:
2318             gen_op_mfc0_watchhi(sel);
2319             rn = "WatchHi";
2320             break;
2321         default:
2322             goto die;
2323         }
2324         break;
2325     case 20:
2326         switch (sel) {
2327         case 0:
2328 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
2329             check_insn(env, ctx, ISA_MIPS3);
2330             gen_op_mfc0_xcontext();
2331             rn = "XContext";
2332             break;
2333 #endif
2334         default:
2335             goto die;
2336         }
2337         break;
2338     case 21:
2339        /* Officially reserved, but sel 0 is used for R1x000 framemask */
2340         switch (sel) {
2341         case 0:
2342             gen_op_mfc0_framemask();
2343             rn = "Framemask";
2344             break;
2345         default:
2346             goto die;
2347         }
2348         break;
2349     case 22:
2350         /* ignored */
2351         rn = "'Diagnostic"; /* implementation dependent */
2352         break;
2353     case 23:
2354         switch (sel) {
2355         case 0:
2356             gen_op_mfc0_debug(); /* EJTAG support */
2357             rn = "Debug";
2358             break;
2359         case 1:
2360 //            gen_op_mfc0_tracecontrol(); /* PDtrace support */
2361             rn = "TraceControl";
2362 //            break;
2363         case 2:
2364 //            gen_op_mfc0_tracecontrol2(); /* PDtrace support */
2365             rn = "TraceControl2";
2366 //            break;
2367         case 3:
2368 //            gen_op_mfc0_usertracedata(); /* PDtrace support */
2369             rn = "UserTraceData";
2370 //            break;
2371         case 4:
2372 //            gen_op_mfc0_debug(); /* PDtrace support */
2373             rn = "TraceBPC";
2374 //            break;
2375         default:
2376             goto die;
2377         }
2378         break;
2379     case 24:
2380         switch (sel) {
2381         case 0:
2382             gen_op_mfc0_depc(); /* EJTAG support */
2383             rn = "DEPC";
2384             break;
2385         default:
2386             goto die;
2387         }
2388         break;
2389     case 25:
2390         switch (sel) {
2391         case 0:
2392             gen_op_mfc0_performance0();
2393             rn = "Performance0";
2394             break;
2395         case 1:
2396 //            gen_op_mfc0_performance1();
2397             rn = "Performance1";
2398 //            break;
2399         case 2:
2400 //            gen_op_mfc0_performance2();
2401             rn = "Performance2";
2402 //            break;
2403         case 3:
2404 //            gen_op_mfc0_performance3();
2405             rn = "Performance3";
2406 //            break;
2407         case 4:
2408 //            gen_op_mfc0_performance4();
2409             rn = "Performance4";
2410 //            break;
2411         case 5:
2412 //            gen_op_mfc0_performance5();
2413             rn = "Performance5";
2414 //            break;
2415         case 6:
2416 //            gen_op_mfc0_performance6();
2417             rn = "Performance6";
2418 //            break;
2419         case 7:
2420 //            gen_op_mfc0_performance7();
2421             rn = "Performance7";
2422 //            break;
2423         default:
2424             goto die;
2425         }
2426         break;
2427     case 26:
2428        rn = "ECC";
2429        break;
2430     case 27:
2431         switch (sel) {
2432         /* ignored */
2433         case 0 ... 3:
2434             rn = "CacheErr";
2435             break;
2436         default:
2437             goto die;
2438         }
2439         break;
2440     case 28:
2441         switch (sel) {
2442         case 0:
2443         case 2:
2444         case 4:
2445         case 6:
2446             gen_op_mfc0_taglo();
2447             rn = "TagLo";
2448             break;
2449         case 1:
2450         case 3:
2451         case 5:
2452         case 7:
2453             gen_op_mfc0_datalo();
2454             rn = "DataLo";
2455             break;
2456         default:
2457             goto die;
2458         }
2459         break;
2460     case 29:
2461         switch (sel) {
2462         case 0:
2463         case 2:
2464         case 4:
2465         case 6:
2466             gen_op_mfc0_taghi();
2467             rn = "TagHi";
2468             break;
2469         case 1:
2470         case 3:
2471         case 5:
2472         case 7:
2473             gen_op_mfc0_datahi();
2474             rn = "DataHi";
2475             break;
2476         default:
2477             goto die;
2478         }
2479         break;
2480     case 30:
2481         switch (sel) {
2482         case 0:
2483             gen_op_mfc0_errorepc();
2484             rn = "ErrorEPC";
2485             break;
2486         default:
2487             goto die;
2488         }
2489         break;
2490     case 31:
2491         switch (sel) {
2492         case 0:
2493             gen_op_mfc0_desave(); /* EJTAG support */
2494             rn = "DESAVE";
2495             break;
2496         default:
2497             goto die;
2498         }
2499         break;
2500     default:
2501        goto die;
2502     }
2503 #if defined MIPS_DEBUG_DISAS
2504     if (loglevel & CPU_LOG_TB_IN_ASM) {
2505         fprintf(logfile, "mfc0 %s (reg %d sel %d)\n",
2506                 rn, reg, sel);
2507     }
2508 #endif
2509     return;
2510
2511 die:
2512 #if defined MIPS_DEBUG_DISAS
2513     if (loglevel & CPU_LOG_TB_IN_ASM) {
2514         fprintf(logfile, "mfc0 %s (reg %d sel %d)\n",
2515                 rn, reg, sel);
2516     }
2517 #endif
2518     generate_exception(ctx, EXCP_RI);
2519 }
2520
2521 static void gen_mtc0 (CPUState *env, DisasContext *ctx, int reg, int sel)
2522 {
2523     const char *rn = "invalid";
2524
2525     if (sel != 0)
2526         check_insn(env, ctx, ISA_MIPS32);
2527
2528     switch (reg) {
2529     case 0:
2530         switch (sel) {
2531         case 0:
2532            gen_op_mtc0_index();
2533             rn = "Index";
2534             break;
2535         case 1:
2536             check_mips_mt(env, ctx);
2537             gen_op_mtc0_mvpcontrol();
2538             rn = "MVPControl";
2539             break;
2540         case 2:
2541             check_mips_mt(env, ctx);
2542             /* ignored */
2543             rn = "MVPConf0";
2544             break;
2545         case 3:
2546             check_mips_mt(env, ctx);
2547             /* ignored */
2548             rn = "MVPConf1";
2549             break;
2550         default:
2551             goto die;
2552         }
2553         break;
2554     case 1:
2555         switch (sel) {
2556         case 0:
2557             /* ignored */
2558             rn = "Random";
2559             break;
2560         case 1:
2561             check_mips_mt(env, ctx);
2562             gen_op_mtc0_vpecontrol();
2563             rn = "VPEControl";
2564             break;
2565         case 2:
2566             check_mips_mt(env, ctx);
2567             gen_op_mtc0_vpeconf0();
2568             rn = "VPEConf0";
2569             break;
2570         case 3:
2571             check_mips_mt(env, ctx);
2572             gen_op_mtc0_vpeconf1();
2573             rn = "VPEConf1";
2574             break;
2575         case 4:
2576             check_mips_mt(env, ctx);
2577             gen_op_mtc0_yqmask();
2578             rn = "YQMask";
2579             break;
2580         case 5:
2581             check_mips_mt(env, ctx);
2582             gen_op_mtc0_vpeschedule();
2583             rn = "VPESchedule";
2584             break;
2585         case 6:
2586             check_mips_mt(env, ctx);
2587             gen_op_mtc0_vpeschefback();
2588             rn = "VPEScheFBack";
2589             break;
2590         case 7:
2591             check_mips_mt(env, ctx);
2592             gen_op_mtc0_vpeopt();
2593             rn = "VPEOpt";
2594             break;
2595         default:
2596             goto die;
2597         }
2598         break;
2599     case 2:
2600         switch (sel) {
2601         case 0:
2602             gen_op_mtc0_entrylo0();
2603             rn = "EntryLo0";
2604             break;
2605         case 1:
2606             check_mips_mt(env, ctx);
2607             gen_op_mtc0_tcstatus();
2608             rn = "TCStatus";
2609             break;
2610         case 2:
2611             check_mips_mt(env, ctx);
2612             gen_op_mtc0_tcbind();
2613             rn = "TCBind";
2614             break;
2615         case 3:
2616             check_mips_mt(env, ctx);
2617             gen_op_mtc0_tcrestart();
2618             rn = "TCRestart";
2619             break;
2620         case 4:
2621             check_mips_mt(env, ctx);
2622             gen_op_mtc0_tchalt();
2623             rn = "TCHalt";
2624             break;
2625         case 5:
2626             check_mips_mt(env, ctx);
2627             gen_op_mtc0_tccontext();
2628             rn = "TCContext";
2629             break;
2630         case 6:
2631             check_mips_mt(env, ctx);
2632             gen_op_mtc0_tcschedule();
2633             rn = "TCSchedule";
2634             break;
2635         case 7:
2636             check_mips_mt(env, ctx);
2637             gen_op_mtc0_tcschefback();
2638             rn = "TCScheFBack";
2639             break;
2640         default:
2641             goto die;
2642         }
2643         break;
2644     case 3:
2645         switch (sel) {
2646         case 0:
2647             gen_op_mtc0_entrylo1();
2648             rn = "EntryLo1";
2649             break;
2650         default:
2651             goto die;
2652         }
2653         break;
2654     case 4:
2655         switch (sel) {
2656         case 0:
2657             gen_op_mtc0_context();
2658             rn = "Context";
2659             break;
2660         case 1:
2661 //            gen_op_mtc0_contextconfig(); /* SmartMIPS ASE */
2662             rn = "ContextConfig";
2663 //            break;
2664         default:
2665             goto die;
2666         }
2667         break;
2668     case 5:
2669         switch (sel) {
2670         case 0:
2671             gen_op_mtc0_pagemask();
2672             rn = "PageMask";
2673             break;
2674         case 1:
2675             check_insn(env, ctx, ISA_MIPS32R2);
2676             gen_op_mtc0_pagegrain();
2677             rn = "PageGrain";
2678             break;
2679         default:
2680             goto die;
2681         }
2682         break;
2683     case 6:
2684         switch (sel) {
2685         case 0:
2686             gen_op_mtc0_wired();
2687             rn = "Wired";
2688             break;
2689         case 1:
2690             check_insn(env, ctx, ISA_MIPS32R2);
2691             gen_op_mtc0_srsconf0();
2692             rn = "SRSConf0";
2693             break;
2694         case 2:
2695             check_insn(env, ctx, ISA_MIPS32R2);
2696             gen_op_mtc0_srsconf1();
2697             rn = "SRSConf1";
2698             break;
2699         case 3:
2700             check_insn(env, ctx, ISA_MIPS32R2);
2701             gen_op_mtc0_srsconf2();
2702             rn = "SRSConf2";
2703             break;
2704         case 4:
2705             check_insn(env, ctx, ISA_MIPS32R2);
2706             gen_op_mtc0_srsconf3();
2707             rn = "SRSConf3";
2708             break;
2709         case 5:
2710             check_insn(env, ctx, ISA_MIPS32R2);
2711             gen_op_mtc0_srsconf4();
2712             rn = "SRSConf4";
2713             break;
2714         default:
2715             goto die;
2716         }
2717         break;
2718     case 7:
2719         switch (sel) {
2720         case 0:
2721             check_insn(env, ctx, ISA_MIPS32R2);
2722             gen_op_mtc0_hwrena();
2723             rn = "HWREna";
2724             break;
2725         default:
2726             goto die;
2727         }
2728         break;
2729     case 8:
2730         /* ignored */
2731         rn = "BadVaddr";
2732         break;
2733     case 9:
2734         switch (sel) {
2735         case 0:
2736             gen_op_mtc0_count();
2737             rn = "Count";
2738             break;
2739         /* 6,7 are implementation dependent */
2740         default:
2741             goto die;
2742         }
2743         /* Stop translation as we may have switched the execution mode */
2744         ctx->bstate = BS_STOP;
2745         break;
2746     case 10:
2747         switch (sel) {
2748         case 0:
2749             gen_op_mtc0_entryhi();
2750             rn = "EntryHi";
2751             break;
2752         default:
2753             goto die;
2754         }
2755         break;
2756     case 11:
2757         switch (sel) {
2758         case 0:
2759             gen_op_mtc0_compare();
2760             rn = "Compare";
2761             break;
2762         /* 6,7 are implementation dependent */
2763         default:
2764             goto die;
2765         }
2766         /* Stop translation as we may have switched the execution mode */
2767         ctx->bstate = BS_STOP;
2768         break;
2769     case 12:
2770         switch (sel) {
2771         case 0:
2772             gen_op_mtc0_status();
2773             /* BS_STOP isn't good enough here, hflags may have changed. */
2774             gen_save_pc(ctx->pc + 4);
2775             ctx->bstate = BS_EXCP;
2776             rn = "Status";
2777             break;
2778         case 1:
2779             check_insn(env, ctx, ISA_MIPS32R2);
2780             gen_op_mtc0_intctl();
2781             /* Stop translation as we may have switched the execution mode */
2782             ctx->bstate = BS_STOP;
2783             rn = "IntCtl";
2784             break;
2785         case 2:
2786             check_insn(env, ctx, ISA_MIPS32R2);
2787             gen_op_mtc0_srsctl();
2788             /* Stop translation as we may have switched the execution mode */
2789             ctx->bstate = BS_STOP;
2790             rn = "SRSCtl";
2791             break;
2792         case 3:
2793             check_insn(env, ctx, ISA_MIPS32R2);
2794             gen_op_mtc0_srsmap();
2795             /* Stop translation as we may have switched the execution mode */
2796             ctx->bstate = BS_STOP;
2797             rn = "SRSMap";
2798             break;
2799         default:
2800             goto die;
2801         }
2802         break;
2803     case 13:
2804         switch (sel) {
2805         case 0:
2806             gen_op_mtc0_cause();
2807             rn = "Cause";
2808             break;
2809         default:
2810             goto die;
2811         }
2812         /* Stop translation as we may have switched the execution mode */
2813         ctx->bstate = BS_STOP;
2814         break;
2815     case 14:
2816         switch (sel) {
2817         case 0:
2818             gen_op_mtc0_epc();
2819             rn = "EPC";
2820             break;
2821         default:
2822             goto die;
2823         }
2824         break;
2825     case 15:
2826         switch (sel) {
2827         case 0:
2828             /* ignored */
2829             rn = "PRid";
2830             break;
2831         case 1:
2832             check_insn(env, ctx, ISA_MIPS32R2);
2833             gen_op_mtc0_ebase();
2834             rn = "EBase";
2835             break;
2836         default:
2837             goto die;
2838         }
2839         break;
2840     case 16:
2841         switch (sel) {
2842         case 0:
2843             gen_op_mtc0_config0();
2844             rn = "Config";
2845             /* Stop translation as we may have switched the execution mode */
2846             ctx->bstate = BS_STOP;
2847             break;
2848         case 1:
2849             /* ignored, read only */
2850             rn = "Config1";
2851             break;
2852         case 2:
2853             gen_op_mtc0_config2();
2854             rn = "Config2";
2855             /* Stop translation as we may have switched the execution mode */
2856             ctx->bstate = BS_STOP;
2857             break;
2858         case 3:
2859             /* ignored, read only */
2860             rn = "Config3";
2861             break;
2862         /* 4,5 are reserved */
2863         /* 6,7 are implementation dependent */
2864         case 6:
2865             /* ignored */
2866             rn = "Config6";
2867             break;
2868         case 7:
2869             /* ignored */
2870             rn = "Config7";
2871             break;
2872         default:
2873             rn = "Invalid config selector";
2874             goto die;
2875         }
2876         break;
2877     case 17:
2878         switch (sel) {
2879         case 0:
2880             /* ignored */
2881             rn = "LLAddr";
2882             break;
2883         default:
2884             goto die;
2885         }
2886         break;
2887     case 18:
2888         switch (sel) {
2889         case 0 ... 7:
2890             gen_op_mtc0_watchlo(sel);
2891             rn = "WatchLo";
2892             break;
2893         default:
2894             goto die;
2895         }
2896         break;
2897     case 19:
2898         switch (sel) {
2899         case 0 ... 7:
2900             gen_op_mtc0_watchhi(sel);
2901             rn = "WatchHi";
2902             break;
2903         default:
2904             goto die;
2905         }
2906         break;
2907     case 20:
2908         switch (sel) {
2909         case 0:
2910 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
2911             check_insn(env, ctx, ISA_MIPS3);
2912             gen_op_mtc0_xcontext();
2913             rn = "XContext";
2914             break;
2915 #endif
2916         default:
2917             goto die;
2918         }
2919         break;
2920     case 21:
2921        /* Officially reserved, but sel 0 is used for R1x000 framemask */
2922         switch (sel) {
2923         case 0:
2924             gen_op_mtc0_framemask();
2925             rn = "Framemask";
2926             break;
2927         default:
2928             goto die;
2929         }
2930         break;
2931     case 22:
2932         /* ignored */
2933         rn = "Diagnostic"; /* implementation dependent */
2934         break;
2935     case 23:
2936         switch (sel) {
2937         case 0:
2938             gen_op_mtc0_debug(); /* EJTAG support */
2939             /* BS_STOP isn't good enough here, hflags may have changed. */
2940             gen_save_pc(ctx->pc + 4);
2941             ctx->bstate = BS_EXCP;
2942             rn = "Debug";
2943             break;
2944         case 1:
2945 //            gen_op_mtc0_tracecontrol(); /* PDtrace support */
2946             rn = "TraceControl";
2947             /* Stop translation as we may have switched the execution mode */
2948             ctx->bstate = BS_STOP;
2949 //            break;
2950         case 2:
2951 //            gen_op_mtc0_tracecontrol2(); /* PDtrace support */
2952             rn = "TraceControl2";
2953             /* Stop translation as we may have switched the execution mode */
2954             ctx->bstate = BS_STOP;
2955 //            break;
2956         case 3:
2957             /* Stop translation as we may have switched the execution mode */
2958             ctx->bstate = BS_STOP;
2959 //            gen_op_mtc0_usertracedata(); /* PDtrace support */
2960             rn = "UserTraceData";
2961             /* Stop translation as we may have switched the execution mode */
2962             ctx->bstate = BS_STOP;
2963 //            break;
2964         case 4:
2965 //            gen_op_mtc0_debug(); /* PDtrace support */
2966             /* Stop translation as we may have switched the execution mode */
2967             ctx->bstate = BS_STOP;
2968             rn = "TraceBPC";
2969 //            break;
2970         default:
2971             goto die;
2972         }
2973         break;
2974     case 24:
2975         switch (sel) {
2976         case 0:
2977             gen_op_mtc0_depc(); /* EJTAG support */
2978             rn = "DEPC";
2979             break;
2980         default:
2981             goto die;
2982         }
2983         break;
2984     case 25:
2985         switch (sel) {
2986         case 0:
2987             gen_op_mtc0_performance0();
2988             rn = "Performance0";
2989             break;
2990         case 1:
2991 //            gen_op_mtc0_performance1();
2992             rn = "Performance1";
2993 //            break;
2994         case 2:
2995 //            gen_op_mtc0_performance2();
2996             rn = "Performance2";
2997 //            break;
2998         case 3:
2999 //            gen_op_mtc0_performance3();
3000             rn = "Performance3";
3001 //            break;
3002         case 4:
3003 //            gen_op_mtc0_performance4();
3004             rn = "Performance4";
3005 //            break;
3006         case 5:
3007 //            gen_op_mtc0_performance5();
3008             rn = "Performance5";
3009 //            break;
3010         case 6:
3011 //            gen_op_mtc0_performance6();
3012             rn = "Performance6";
3013 //            break;
3014         case 7:
3015 //            gen_op_mtc0_performance7();
3016             rn = "Performance7";
3017 //            break;
3018         default:
3019             goto die;
3020         }
3021        break;
3022     case 26:
3023         /* ignored */
3024         rn = "ECC";
3025         break;
3026     case 27:
3027         switch (sel) {
3028         case 0 ... 3:
3029             /* ignored */
3030             rn = "CacheErr";
3031             break;
3032         default:
3033             goto die;
3034         }
3035        break;
3036     case 28:
3037         switch (sel) {
3038         case 0:
3039         case 2:
3040         case 4:
3041         case 6:
3042             gen_op_mtc0_taglo();
3043             rn = "TagLo";
3044             break;
3045         case 1:
3046         case 3:
3047         case 5:
3048         case 7:
3049             gen_op_mtc0_datalo();
3050             rn = "DataLo";
3051             break;
3052         default:
3053             goto die;
3054         }
3055         break;
3056     case 29:
3057         switch (sel) {
3058         case 0:
3059         case 2:
3060         case 4:
3061         case 6:
3062             gen_op_mtc0_taghi();
3063             rn = "TagHi";
3064             break;
3065         case 1:
3066         case 3:
3067         case 5:
3068         case 7:
3069             gen_op_mtc0_datahi();
3070             rn = "DataHi";
3071             break;
3072         default:
3073             rn = "invalid sel";
3074             goto die;
3075         }
3076        break;
3077     case 30:
3078         switch (sel) {
3079         case 0:
3080             gen_op_mtc0_errorepc();
3081             rn = "ErrorEPC";
3082             break;
3083         default:
3084             goto die;
3085         }
3086         break;
3087     case 31:
3088         switch (sel) {
3089         case 0:
3090             gen_op_mtc0_desave(); /* EJTAG support */
3091             rn = "DESAVE";
3092             break;
3093         default:
3094             goto die;
3095         }
3096         /* Stop translation as we may have switched the execution mode */
3097         ctx->bstate = BS_STOP;
3098         break;
3099     default:
3100        goto die;
3101     }
3102 #if defined MIPS_DEBUG_DISAS
3103     if (loglevel & CPU_LOG_TB_IN_ASM) {
3104         fprintf(logfile, "mtc0 %s (reg %d sel %d)\n",
3105                 rn, reg, sel);
3106     }
3107 #endif
3108     return;
3109
3110 die:
3111 #if defined MIPS_DEBUG_DISAS
3112     if (loglevel & CPU_LOG_TB_IN_ASM) {
3113         fprintf(logfile, "mtc0 %s (reg %d sel %d)\n",
3114                 rn, reg, sel);
3115     }
3116 #endif
3117     generate_exception(ctx, EXCP_RI);
3118 }
3119
3120 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
3121 static void gen_dmfc0 (CPUState *env, DisasContext *ctx, int reg, int sel)
3122 {
3123     const char *rn = "invalid";
3124
3125     if (sel != 0)
3126         check_insn(env, ctx, ISA_MIPS64);
3127
3128     switch (reg) {
3129     case 0:
3130         switch (sel) {
3131         case 0:
3132             gen_op_mfc0_index();
3133             rn = "Index";
3134             break;
3135         case 1:
3136             check_mips_mt(env, ctx);
3137             gen_op_mfc0_mvpcontrol();
3138             rn = "MVPControl";
3139             break;
3140         case 2:
3141             check_mips_mt(env, ctx);
3142             gen_op_mfc0_mvpconf0();
3143             rn = "MVPConf0";
3144             break;
3145         case 3:
3146             check_mips_mt(env, ctx);
3147             gen_op_mfc0_mvpconf1();
3148             rn = "MVPConf1";
3149             break;
3150         default:
3151             goto die;
3152         }
3153         break;
3154     case 1:
3155         switch (sel) {
3156         case 0:
3157             gen_op_mfc0_random();
3158             rn = "Random";
3159             break;
3160         case 1:
3161             check_mips_mt(env, ctx);
3162             gen_op_mfc0_vpecontrol();
3163             rn = "VPEControl";
3164             break;
3165         case 2:
3166             check_mips_mt(env, ctx);
3167             gen_op_mfc0_vpeconf0();
3168             rn = "VPEConf0";
3169             break;
3170         case 3:
3171             check_mips_mt(env, ctx);
3172             gen_op_mfc0_vpeconf1();
3173             rn = "VPEConf1";
3174             break;
3175         case 4:
3176             check_mips_mt(env, ctx);
3177             gen_op_dmfc0_yqmask();
3178             rn = "YQMask";
3179             break;
3180         case 5:
3181             check_mips_mt(env, ctx);
3182             gen_op_dmfc0_vpeschedule();
3183             rn = "VPESchedule";
3184             break;
3185         case 6:
3186             check_mips_mt(env, ctx);
3187             gen_op_dmfc0_vpeschefback();
3188             rn = "VPEScheFBack";
3189             break;
3190         case 7:
3191             check_mips_mt(env, ctx);
3192             gen_op_mfc0_vpeopt();
3193             rn = "VPEOpt";
3194             break;
3195         default:
3196             goto die;
3197         }
3198         break;
3199     case 2:
3200         switch (sel) {
3201         case 0:
3202             gen_op_dmfc0_entrylo0();
3203             rn = "EntryLo0";
3204             break;
3205         case 1:
3206             check_mips_mt(env, ctx);
3207             gen_op_mfc0_tcstatus();
3208             rn = "TCStatus";
3209             break;
3210         case 2:
3211             check_mips_mt(env, ctx);
3212             gen_op_mfc0_tcbind();
3213             rn = "TCBind";
3214             break;
3215         case 3:
3216             check_mips_mt(env, ctx);
3217             gen_op_dmfc0_tcrestart();
3218             rn = "TCRestart";
3219             break;
3220         case 4:
3221             check_mips_mt(env, ctx);
3222             gen_op_dmfc0_tchalt();
3223             rn = "TCHalt";
3224             break;
3225         case 5:
3226             check_mips_mt(env, ctx);
3227             gen_op_dmfc0_tccontext();
3228             rn = "TCContext";
3229             break;
3230         case 6:
3231             check_mips_mt(env, ctx);
3232             gen_op_dmfc0_tcschedule();
3233             rn = "TCSchedule";
3234             break;
3235         case 7:
3236             check_mips_mt(env, ctx);
3237             gen_op_dmfc0_tcschefback();
3238             rn = "TCScheFBack";
3239             break;
3240         default:
3241             goto die;
3242         }
3243         break;
3244     case 3:
3245         switch (sel) {
3246         case 0:
3247             gen_op_dmfc0_entrylo1();
3248             rn = "EntryLo1";
3249             break;
3250         default:
3251             goto die;
3252         }
3253         break;
3254     case 4:
3255         switch (sel) {
3256         case 0:
3257             gen_op_dmfc0_context();
3258             rn = "Context";
3259             break;
3260         case 1:
3261 //            gen_op_dmfc0_contextconfig(); /* SmartMIPS ASE */
3262             rn = "ContextConfig";
3263 //            break;
3264         default:
3265             goto die;
3266         }
3267         break;
3268     case 5:
3269         switch (sel) {
3270         case 0:
3271             gen_op_mfc0_pagemask();
3272             rn = "PageMask";
3273             break;
3274         case 1:
3275             check_insn(env, ctx, ISA_MIPS32R2);
3276             gen_op_mfc0_pagegrain();
3277             rn = "PageGrain";
3278             break;
3279         default:
3280             goto die;
3281         }
3282         break;
3283     case 6:
3284         switch (sel) {
3285         case 0:
3286             gen_op_mfc0_wired();
3287             rn = "Wired";
3288             break;
3289         case 1:
3290             check_insn(env, ctx, ISA_MIPS32R2);
3291             gen_op_mfc0_srsconf0();
3292             rn = "SRSConf0";
3293             break;
3294         case 2:
3295             check_insn(env, ctx, ISA_MIPS32R2);
3296             gen_op_mfc0_srsconf1();
3297             rn = "SRSConf1";
3298             break;
3299         case 3:
3300             check_insn(env, ctx, ISA_MIPS32R2);
3301             gen_op_mfc0_srsconf2();
3302             rn = "SRSConf2";
3303             break;
3304         case 4:
3305             check_insn(env, ctx, ISA_MIPS32R2);
3306             gen_op_mfc0_srsconf3();
3307             rn = "SRSConf3";
3308             break;
3309         case 5:
3310             check_insn(env, ctx, ISA_MIPS32R2);
3311             gen_op_mfc0_srsconf4();
3312             rn = "SRSConf4";
3313             break;
3314         default:
3315             goto die;
3316         }
3317         break;
3318     case 7:
3319         switch (sel) {
3320         case 0:
3321             check_insn(env, ctx, ISA_MIPS32R2);
3322             gen_op_mfc0_hwrena();
3323             rn = "HWREna";
3324             break;
3325         default:
3326             goto die;
3327         }
3328         break;
3329     case 8:
3330         switch (sel) {
3331         case 0:
3332             gen_op_dmfc0_badvaddr();
3333             rn = "BadVaddr";
3334             break;
3335         default:
3336             goto die;
3337         }
3338         break;
3339     case 9:
3340         switch (sel) {
3341         case 0:
3342             gen_op_mfc0_count();
3343             rn = "Count";
3344             break;
3345         /* 6,7 are implementation dependent */
3346         default:
3347             goto die;
3348         }
3349         break;
3350     case 10:
3351         switch (sel) {
3352         case 0:
3353             gen_op_dmfc0_entryhi();
3354             rn = "EntryHi";
3355             break;
3356         default:
3357             goto die;
3358         }
3359         break;
3360     case 11:
3361         switch (sel) {
3362         case 0:
3363             gen_op_mfc0_compare();
3364             rn = "Compare";
3365             break;
3366         /* 6,7 are implementation dependent */
3367         default:
3368             goto die;
3369         }
3370         break;
3371     case 12:
3372         switch (sel) {
3373         case 0:
3374             gen_op_mfc0_status();
3375             rn = "Status";
3376             break;
3377         case 1:
3378             check_insn(env, ctx, ISA_MIPS32R2);
3379             gen_op_mfc0_intctl();
3380             rn = "IntCtl";
3381             break;
3382         case 2:
3383             check_insn(env, ctx, ISA_MIPS32R2);
3384             gen_op_mfc0_srsctl();
3385             rn = "SRSCtl";
3386             break;
3387         case 3:
3388             check_insn(env, ctx, ISA_MIPS32R2);
3389             gen_op_mfc0_srsmap();
3390             rn = "SRSMap";
3391             break;
3392         default:
3393             goto die;
3394         }
3395         break;
3396     case 13:
3397         switch (sel) {
3398         case 0:
3399             gen_op_mfc0_cause();
3400             rn = "Cause";
3401             break;
3402         default:
3403             goto die;
3404         }
3405         break;
3406     case 14:
3407         switch (sel) {
3408         case 0:
3409             gen_op_dmfc0_epc();
3410             rn = "EPC";
3411             break;
3412         default:
3413             goto die;
3414         }
3415         break;
3416     case 15:
3417         switch (sel) {
3418         case 0:
3419             gen_op_mfc0_prid();
3420             rn = "PRid";
3421             break;
3422         case 1:
3423             check_insn(env, ctx, ISA_MIPS32R2);
3424             gen_op_mfc0_ebase();
3425             rn = "EBase";
3426             break;
3427         default:
3428             goto die;
3429         }
3430         break;
3431     case 16:
3432         switch (sel) {
3433         case 0:
3434             gen_op_mfc0_config0();
3435             rn = "Config";
3436             break;
3437         case 1:
3438             gen_op_mfc0_config1();
3439             rn = "Config1";
3440             break;
3441         case 2:
3442             gen_op_mfc0_config2();
3443             rn = "Config2";
3444             break;
3445         case 3:
3446             gen_op_mfc0_config3();
3447             rn = "Config3";
3448             break;
3449        /* 6,7 are implementation dependent */
3450         default:
3451             goto die;
3452         }
3453         break;
3454     case 17:
3455         switch (sel) {
3456         case 0:
3457             gen_op_dmfc0_lladdr();
3458             rn = "LLAddr";
3459             break;
3460         default:
3461             goto die;
3462         }
3463         break;
3464     case 18:
3465         switch (sel) {
3466         case 0 ... 7:
3467             gen_op_dmfc0_watchlo(sel);
3468             rn = "WatchLo";
3469             break;
3470         default:
3471             goto die;
3472         }
3473         break;
3474     case 19:
3475         switch (sel) {
3476         case 0 ... 7:
3477             gen_op_mfc0_watchhi(sel);
3478             rn = "WatchHi";
3479             break;
3480         default:
3481             goto die;
3482         }
3483         break;
3484     case 20:
3485         switch (sel) {
3486         case 0:
3487             check_insn(env, ctx, ISA_MIPS3);
3488             gen_op_dmfc0_xcontext();
3489             rn = "XContext";
3490             break;
3491         default:
3492             goto die;
3493         }
3494         break;
3495     case 21:
3496        /* Officially reserved, but sel 0 is used for R1x000 framemask */
3497         switch (sel) {
3498         case 0:
3499             gen_op_mfc0_framemask();
3500             rn = "Framemask";
3501             break;
3502         default:
3503             goto die;
3504         }
3505         break;
3506     case 22:
3507         /* ignored */
3508         rn = "'Diagnostic"; /* implementation dependent */
3509         break;
3510     case 23:
3511         switch (sel) {
3512         case 0:
3513             gen_op_mfc0_debug(); /* EJTAG support */
3514             rn = "Debug";
3515             break;
3516         case 1:
3517 //            gen_op_dmfc0_tracecontrol(); /* PDtrace support */
3518             rn = "TraceControl";
3519 //            break;
3520         case 2:
3521 //            gen_op_dmfc0_tracecontrol2(); /* PDtrace support */
3522             rn = "TraceControl2";
3523 //            break;
3524         case 3:
3525 //            gen_op_dmfc0_usertracedata(); /* PDtrace support */
3526             rn = "UserTraceData";
3527 //            break;
3528         case 4:
3529 //            gen_op_dmfc0_debug(); /* PDtrace support */
3530             rn = "TraceBPC";
3531 //            break;
3532         default:
3533             goto die;
3534         }
3535         break;
3536     case 24:
3537         switch (sel) {
3538         case 0:
3539             gen_op_dmfc0_depc(); /* EJTAG support */
3540             rn = "DEPC";
3541             break;
3542         default:
3543             goto die;
3544         }
3545         break;
3546     case 25:
3547         switch (sel) {
3548         case 0:
3549             gen_op_mfc0_performance0();
3550             rn = "Performance0";
3551             break;
3552         case 1:
3553 //            gen_op_dmfc0_performance1();
3554             rn = "Performance1";
3555 //            break;
3556         case 2:
3557 //            gen_op_dmfc0_performance2();
3558             rn = "Performance2";
3559 //            break;
3560         case 3:
3561 //            gen_op_dmfc0_performance3();
3562             rn = "Performance3";
3563 //            break;
3564         case 4:
3565 //            gen_op_dmfc0_performance4();
3566             rn = "Performance4";
3567 //            break;
3568         case 5:
3569 //            gen_op_dmfc0_performance5();
3570             rn = "Performance5";
3571 //            break;
3572         case 6:
3573 //            gen_op_dmfc0_performance6();
3574             rn = "Performance6";
3575 //            break;
3576         case 7:
3577 //            gen_op_dmfc0_performance7();
3578             rn = "Performance7";
3579 //            break;
3580         default:
3581             goto die;
3582         }
3583         break;
3584     case 26:
3585        rn = "ECC";
3586        break;
3587     case 27:
3588         switch (sel) {
3589         /* ignored */
3590         case 0 ... 3:
3591             rn = "CacheErr";
3592             break;
3593         default:
3594             goto die;
3595         }
3596         break;
3597     case 28:
3598         switch (sel) {
3599         case 0:
3600         case 2:
3601         case 4:
3602         case 6:
3603             gen_op_mfc0_taglo();
3604             rn = "TagLo";
3605             break;
3606         case 1:
3607         case 3:
3608         case 5:
3609         case 7:
3610             gen_op_mfc0_datalo();
3611             rn = "DataLo";
3612             break;
3613         default:
3614             goto die;
3615         }
3616         break;
3617     case 29:
3618         switch (sel) {
3619         case 0:
3620         case 2:
3621         case 4:
3622         case 6:
3623             gen_op_mfc0_taghi();
3624             rn = "TagHi";
3625             break;
3626         case 1:
3627         case 3:
3628         case 5:
3629         case 7:
3630             gen_op_mfc0_datahi();
3631             rn = "DataHi";
3632             break;
3633         default:
3634             goto die;
3635         }
3636         break;
3637     case 30:
3638         switch (sel) {
3639         case 0:
3640             gen_op_dmfc0_errorepc();
3641             rn = "ErrorEPC";
3642             break;
3643         default:
3644             goto die;
3645         }
3646         break;
3647     case 31:
3648         switch (sel) {
3649         case 0:
3650             gen_op_mfc0_desave(); /* EJTAG support */
3651             rn = "DESAVE";
3652             break;
3653         default:
3654             goto die;
3655         }
3656         break;
3657     default:
3658         goto die;
3659     }
3660 #if defined MIPS_DEBUG_DISAS
3661     if (loglevel & CPU_LOG_TB_IN_ASM) {
3662         fprintf(logfile, "dmfc0 %s (reg %d sel %d)\n",
3663                 rn, reg, sel);
3664     }
3665 #endif
3666     return;
3667
3668 die:
3669 #if defined MIPS_DEBUG_DISAS
3670     if (loglevel & CPU_LOG_TB_IN_ASM) {
3671         fprintf(logfile, "dmfc0 %s (reg %d sel %d)\n",
3672                 rn, reg, sel);
3673     }
3674 #endif
3675     generate_exception(ctx, EXCP_RI);
3676 }
3677
3678 static void gen_dmtc0 (CPUState *env, DisasContext *ctx, int reg, int sel)
3679 {
3680     const char *rn = "invalid";
3681
3682     if (sel != 0)
3683         check_insn(env, ctx, ISA_MIPS64);
3684
3685     switch (reg) {
3686     case 0:
3687         switch (sel) {
3688         case 0:
3689             gen_op_mtc0_index();
3690             rn = "Index";
3691             break;
3692         case 1:
3693             check_mips_mt(env, ctx);
3694             gen_op_mtc0_mvpcontrol();
3695             rn = "MVPControl";
3696             break;
3697         case 2:
3698             check_mips_mt(env, ctx);
3699             /* ignored */
3700             rn = "MVPConf0";
3701             break;
3702         case 3:
3703             check_mips_mt(env, ctx);
3704             /* ignored */
3705             rn = "MVPConf1";
3706             break;
3707         default:
3708             goto die;
3709         }
3710         break;
3711     case 1:
3712         switch (sel) {
3713         case 0:
3714             /* ignored */
3715             rn = "Random";
3716             break;
3717         case 1:
3718             check_mips_mt(env, ctx);
3719             gen_op_mtc0_vpecontrol();
3720             rn = "VPEControl";
3721             break;
3722         case 2:
3723             check_mips_mt(env, ctx);
3724             gen_op_mtc0_vpeconf0();
3725             rn = "VPEConf0";
3726             break;
3727         case 3:
3728             check_mips_mt(env, ctx);
3729             gen_op_mtc0_vpeconf1();
3730             rn = "VPEConf1";
3731             break;
3732         case 4:
3733             check_mips_mt(env, ctx);
3734             gen_op_mtc0_yqmask();
3735             rn = "YQMask";
3736             break;
3737         case 5:
3738             check_mips_mt(env, ctx);
3739             gen_op_mtc0_vpeschedule();
3740             rn = "VPESchedule";
3741             break;
3742         case 6:
3743             check_mips_mt(env, ctx);
3744             gen_op_mtc0_vpeschefback();
3745             rn = "VPEScheFBack";
3746             break;
3747         case 7:
3748             check_mips_mt(env, ctx);
3749             gen_op_mtc0_vpeopt();
3750             rn = "VPEOpt";
3751             break;
3752         default:
3753             goto die;
3754         }
3755         break;
3756     case 2:
3757         switch (sel) {
3758         case 0:
3759             gen_op_mtc0_entrylo0();
3760             rn = "EntryLo0";
3761             break;
3762         case 1:
3763             check_mips_mt(env, ctx);
3764             gen_op_mtc0_tcstatus();
3765             rn = "TCStatus";
3766             break;
3767         case 2:
3768             check_mips_mt(env, ctx);
3769             gen_op_mtc0_tcbind();
3770             rn = "TCBind";
3771             break;
3772         case 3:
3773             check_mips_mt(env, ctx);
3774             gen_op_mtc0_tcrestart();
3775             rn = "TCRestart";
3776             break;
3777         case 4:
3778             check_mips_mt(env, ctx);
3779             gen_op_mtc0_tchalt();
3780             rn = "TCHalt";
3781             break;
3782         case 5:
3783             check_mips_mt(env, ctx);
3784             gen_op_mtc0_tccontext();
3785             rn = "TCContext";
3786             break;
3787         case 6:
3788             check_mips_mt(env, ctx);
3789             gen_op_mtc0_tcschedule();
3790             rn = "TCSchedule";
3791             break;
3792         case 7:
3793             check_mips_mt(env, ctx);
3794             gen_op_mtc0_tcschefback();
3795             rn = "TCScheFBack";
3796             break;
3797         default:
3798             goto die;
3799         }
3800         break;
3801     case 3:
3802         switch (sel) {
3803         case 0:
3804             gen_op_mtc0_entrylo1();
3805             rn = "EntryLo1";
3806             break;
3807         default:
3808             goto die;
3809         }
3810         break;
3811     case 4:
3812         switch (sel) {
3813         case 0:
3814             gen_op_mtc0_context();
3815             rn = "Context";
3816             break;
3817         case 1:
3818 //           gen_op_mtc0_contextconfig(); /* SmartMIPS ASE */
3819             rn = "ContextConfig";
3820 //           break;
3821         default:
3822             goto die;
3823         }
3824         break;
3825     case 5:
3826         switch (sel) {
3827         case 0:
3828             gen_op_mtc0_pagemask();
3829             rn = "PageMask";
3830             break;
3831         case 1:
3832             check_insn(env, ctx, ISA_MIPS32R2);
3833             gen_op_mtc0_pagegrain();
3834             rn = "PageGrain";
3835             break;
3836         default:
3837             goto die;
3838         }
3839         break;
3840     case 6:
3841         switch (sel) {
3842         case 0:
3843             gen_op_mtc0_wired();
3844             rn = "Wired";
3845             break;
3846         case 1:
3847             check_insn(env, ctx, ISA_MIPS32R2);
3848             gen_op_mtc0_srsconf0();
3849             rn = "SRSConf0";
3850             break;
3851         case 2:
3852             check_insn(env, ctx, ISA_MIPS32R2);
3853             gen_op_mtc0_srsconf1();
3854             rn = "SRSConf1";
3855             break;
3856         case 3:
3857             check_insn(env, ctx, ISA_MIPS32R2);
3858             gen_op_mtc0_srsconf2();
3859             rn = "SRSConf2";
3860             break;
3861         case 4:
3862             check_insn(env, ctx, ISA_MIPS32R2);
3863             gen_op_mtc0_srsconf3();
3864             rn = "SRSConf3";
3865             break;
3866         case 5:
3867             check_insn(env, ctx, ISA_MIPS32R2);
3868             gen_op_mtc0_srsconf4();
3869             rn = "SRSConf4";
3870             break;
3871         default:
3872             goto die;
3873         }
3874         break;
3875     case 7:
3876         switch (sel) {
3877         case 0:
3878             check_insn(env, ctx, ISA_MIPS32R2);
3879             gen_op_mtc0_hwrena();
3880             rn = "HWREna";
3881             break;
3882         default:
3883             goto die;
3884         }
3885         break;
3886     case 8:
3887         /* ignored */
3888         rn = "BadVaddr";
3889         break;
3890     case 9:
3891         switch (sel) {
3892         case 0:
3893             gen_op_mtc0_count();
3894             rn = "Count";
3895             break;
3896         /* 6,7 are implementation dependent */
3897         default:
3898             goto die;
3899         }
3900         /* Stop translation as we may have switched the execution mode */
3901         ctx->bstate = BS_STOP;
3902         break;
3903     case 10:
3904         switch (sel) {
3905         case 0:
3906             gen_op_mtc0_entryhi();
3907             rn = "EntryHi";
3908             break;
3909         default:
3910             goto die;
3911         }
3912         break;
3913     case 11:
3914         switch (sel) {
3915         case 0:
3916             gen_op_mtc0_compare();
3917             rn = "Compare";
3918             break;
3919         /* 6,7 are implementation dependent */
3920         default:
3921             goto die;
3922         }
3923         /* Stop translation as we may have switched the execution mode */
3924         ctx->bstate = BS_STOP;
3925         break;
3926     case 12:
3927         switch (sel) {
3928         case 0:
3929             gen_op_mtc0_status();
3930             /* BS_STOP isn't good enough here, hflags may have changed. */
3931             gen_save_pc(ctx->pc + 4);
3932             ctx->bstate = BS_EXCP;
3933             rn = "Status";
3934             break;
3935         case 1:
3936             check_insn(env, ctx, ISA_MIPS32R2);
3937             gen_op_mtc0_intctl();
3938             /* Stop translation as we may have switched the execution mode */
3939             ctx->bstate = BS_STOP;
3940             rn = "IntCtl";
3941             break;
3942         case 2:
3943             check_insn(env, ctx, ISA_MIPS32R2);
3944             gen_op_mtc0_srsctl();
3945             /* Stop translation as we may have switched the execution mode */
3946             ctx->bstate = BS_STOP;
3947             rn = "SRSCtl";
3948             break;
3949         case 3:
3950             check_insn(env, ctx, ISA_MIPS32R2);
3951             gen_op_mtc0_srsmap();
3952             /* Stop translation as we may have switched the execution mode */
3953             ctx->bstate = BS_STOP;
3954             rn = "SRSMap";
3955             break;
3956         default:
3957             goto die;
3958         }
3959         break;
3960     case 13:
3961         switch (sel) {
3962         case 0:
3963             gen_op_mtc0_cause();
3964             rn = "Cause";
3965             break;
3966         default:
3967             goto die;
3968         }
3969         /* Stop translation as we may have switched the execution mode */
3970         ctx->bstate = BS_STOP;
3971         break;
3972     case 14:
3973         switch (sel) {
3974         case 0:
3975             gen_op_mtc0_epc();
3976             rn = "EPC";
3977             break;
3978         default:
3979             goto die;
3980         }
3981         break;
3982     case 15:
3983         switch (sel) {
3984         case 0:
3985             /* ignored */
3986             rn = "PRid";
3987             break;
3988         case 1:
3989             check_insn(env, ctx, ISA_MIPS32R2);
3990             gen_op_mtc0_ebase();
3991             rn = "EBase";
3992             break;
3993         default:
3994             goto die;
3995         }
3996         break;
3997     case 16:
3998         switch (sel) {
3999         case 0:
4000             gen_op_mtc0_config0();
4001             rn = "Config";
4002             /* Stop translation as we may have switched the execution mode */
4003             ctx->bstate = BS_STOP;
4004             break;
4005         case 1:
4006             /* ignored */
4007             rn = "Config1";
4008             break;
4009         case 2:
4010             gen_op_mtc0_config2();
4011             rn = "Config2";
4012             /* Stop translation as we may have switched the execution mode */
4013             ctx->bstate = BS_STOP;
4014             break;
4015         case 3:
4016             /* ignored */
4017             rn = "Config3";
4018             break;
4019         /* 6,7 are implementation dependent */
4020         default:
4021             rn = "Invalid config selector";
4022             goto die;
4023         }
4024         break;
4025     case 17:
4026         switch (sel) {
4027         case 0:
4028             /* ignored */
4029             rn = "LLAddr";
4030             break;
4031         default:
4032             goto die;
4033         }
4034         break;
4035     case 18:
4036         switch (sel) {
4037         case 0 ... 7:
4038             gen_op_mtc0_watchlo(sel);
4039             rn = "WatchLo";
4040             break;
4041         default:
4042             goto die;
4043         }
4044         break;
4045     case 19:
4046         switch (sel) {
4047         case 0 ... 7:
4048             gen_op_mtc0_watchhi(sel);
4049             rn = "WatchHi";
4050             break;
4051         default:
4052             goto die;
4053         }
4054         break;
4055     case 20:
4056         switch (sel) {
4057         case 0:
4058             check_insn(env, ctx, ISA_MIPS3);
4059             gen_op_mtc0_xcontext();
4060             rn = "XContext";
4061             break;
4062         default:
4063             goto die;
4064         }
4065         break;
4066     case 21:
4067        /* Officially reserved, but sel 0 is used for R1x000 framemask */
4068         switch (sel) {
4069         case 0:
4070             gen_op_mtc0_framemask();
4071             rn = "Framemask";
4072             break;
4073         default:
4074             goto die;
4075         }
4076         break;
4077     case 22:
4078         /* ignored */
4079         rn = "Diagnostic"; /* implementation dependent */
4080         break;
4081     case 23:
4082         switch (sel) {
4083         case 0:
4084             gen_op_mtc0_debug(); /* EJTAG support */
4085             /* BS_STOP isn't good enough here, hflags may have changed. */
4086             gen_save_pc(ctx->pc + 4);
4087             ctx->bstate = BS_EXCP;
4088             rn = "Debug";
4089             break;
4090         case 1:
4091 //            gen_op_mtc0_tracecontrol(); /* PDtrace support */
4092             /* Stop translation as we may have switched the execution mode */
4093             ctx->bstate = BS_STOP;
4094             rn = "TraceControl";
4095 //            break;
4096         case 2:
4097 //            gen_op_mtc0_tracecontrol2(); /* PDtrace support */
4098             /* Stop translation as we may have switched the execution mode */
4099             ctx->bstate = BS_STOP;
4100             rn = "TraceControl2";
4101 //            break;
4102         case 3:
4103 //            gen_op_mtc0_usertracedata(); /* PDtrace support */
4104             /* Stop translation as we may have switched the execution mode */
4105             ctx->bstate = BS_STOP;
4106             rn = "UserTraceData";
4107 //            break;
4108         case 4:
4109 //            gen_op_mtc0_debug(); /* PDtrace support */
4110             /* Stop translation as we may have switched the execution mode */
4111             ctx->bstate = BS_STOP;
4112             rn = "TraceBPC";
4113 //            break;
4114         default:
4115             goto die;
4116         }
4117         break;
4118     case 24:
4119         switch (sel) {
4120         case 0:
4121             gen_op_mtc0_depc(); /* EJTAG support */
4122             rn = "DEPC";
4123             break;
4124         default:
4125             goto die;
4126         }
4127         break;
4128     case 25:
4129         switch (sel) {
4130         case 0:
4131             gen_op_mtc0_performance0();
4132             rn = "Performance0";
4133             break;
4134         case 1:
4135 //            gen_op_mtc0_performance1();
4136             rn = "Performance1";
4137 //            break;
4138         case 2:
4139 //            gen_op_mtc0_performance2();
4140             rn = "Performance2";
4141 //            break;
4142         case 3:
4143 //            gen_op_mtc0_performance3();
4144             rn = "Performance3";
4145 //            break;
4146         case 4:
4147 //            gen_op_mtc0_performance4();
4148             rn = "Performance4";
4149 //            break;
4150         case 5:
4151 //            gen_op_mtc0_performance5();
4152             rn = "Performance5";
4153 //            break;
4154         case 6:
4155 //            gen_op_mtc0_performance6();
4156             rn = "Performance6";
4157 //            break;
4158         case 7:
4159 //            gen_op_mtc0_performance7();
4160             rn = "Performance7";
4161 //            break;
4162         default:
4163             goto die;
4164         }
4165         break;
4166     case 26:
4167         /* ignored */
4168         rn = "ECC";
4169         break;
4170     case 27:
4171         switch (sel) {
4172         case 0 ... 3:
4173             /* ignored */
4174             rn = "CacheErr";
4175             break;
4176         default:
4177             goto die;
4178         }
4179         break;
4180     case 28:
4181         switch (sel) {
4182         case 0:
4183         case 2:
4184         case 4:
4185         case 6:
4186             gen_op_mtc0_taglo();
4187             rn = "TagLo";
4188             break;
4189         case 1:
4190         case 3:
4191         case 5:
4192         case 7:
4193             gen_op_mtc0_datalo();
4194             rn = "DataLo";
4195             break;
4196         default:
4197             goto die;
4198         }
4199         break;
4200     case 29:
4201         switch (sel) {
4202         case 0:
4203         case 2:
4204         case 4:
4205         case 6:
4206             gen_op_mtc0_taghi();
4207             rn = "TagHi";
4208             break;
4209         case 1:
4210         case 3:
4211         case 5:
4212         case 7:
4213             gen_op_mtc0_datahi();
4214             rn = "DataHi";
4215             break;
4216         default:
4217             rn = "invalid sel";
4218             goto die;
4219         }
4220         break;
4221     case 30:
4222         switch (sel) {
4223         case 0:
4224             gen_op_mtc0_errorepc();
4225             rn = "ErrorEPC";
4226             break;
4227         default:
4228             goto die;
4229         }
4230         break;
4231     case 31:
4232         switch (sel) {
4233         case 0:
4234             gen_op_mtc0_desave(); /* EJTAG support */
4235             rn = "DESAVE";
4236             break;
4237         default:
4238             goto die;
4239         }
4240         /* Stop translation as we may have switched the execution mode */
4241         ctx->bstate = BS_STOP;
4242         break;
4243     default:
4244         goto die;
4245     }
4246 #if defined MIPS_DEBUG_DISAS
4247     if (loglevel & CPU_LOG_TB_IN_ASM) {
4248         fprintf(logfile, "dmtc0 %s (reg %d sel %d)\n",
4249                 rn, reg, sel);
4250     }
4251 #endif
4252     return;
4253
4254 die:
4255 #if defined MIPS_DEBUG_DISAS
4256     if (loglevel & CPU_LOG_TB_IN_ASM) {
4257         fprintf(logfile, "dmtc0 %s (reg %d sel %d)\n",
4258                 rn, reg, sel);
4259     }
4260 #endif
4261     generate_exception(ctx, EXCP_RI);
4262 }
4263 #endif /* TARGET_MIPSN32 || TARGET_MIPS64 */
4264
4265 static void gen_mftr(CPUState *env, DisasContext *ctx, int rt,
4266                      int u, int sel, int h)
4267 {
4268     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
4269
4270     if ((env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP)) == 0 &&
4271         ((env->CP0_TCBind[other_tc] & (0xf << CP0TCBd_CurVPE)) !=
4272          (env->CP0_TCBind[env->current_tc] & (0xf << CP0TCBd_CurVPE))))
4273         gen_op_set_T0(-1);
4274     else if ((env->CP0_VPEControl & (0xff << CP0VPECo_TargTC)) >
4275              (env->mvp->CP0_MVPConf0 & (0xff << CP0MVPC0_PTC)))
4276         gen_op_set_T0(-1);
4277     else if (u == 0) {
4278         switch (rt) {
4279         case 2:
4280             switch (sel) {
4281             case 1:
4282                 gen_op_mftc0_tcstatus();
4283                 break;
4284             case 2:
4285                 gen_op_mftc0_tcbind();
4286                 break;
4287             case 3:
4288                 gen_op_mftc0_tcrestart();
4289                 break;
4290             case 4:
4291                 gen_op_mftc0_tchalt();
4292                 break;
4293             case 5:
4294                 gen_op_mftc0_tccontext();
4295                 break;
4296             case 6:
4297                 gen_op_mftc0_tcschedule();
4298                 break;
4299             case 7:
4300                 gen_op_mftc0_tcschefback();
4301                 break;
4302             default:
4303                 gen_mfc0(env, ctx, rt, sel);
4304                 break;
4305             }
4306             break;
4307         case 10:
4308             switch (sel) {
4309             case 0:
4310                 gen_op_mftc0_entryhi();
4311                 break;
4312             default:
4313                 gen_mfc0(env, ctx, rt, sel);
4314                 break;
4315             }
4316         case 12:
4317             switch (sel) {
4318             case 0:
4319                 gen_op_mftc0_status();
4320                 break;
4321             default:
4322                 gen_mfc0(env, ctx, rt, sel);
4323                 break;
4324             }
4325         case 23:
4326             switch (sel) {
4327             case 0:
4328                 gen_op_mftc0_debug();
4329                 break;
4330             default:
4331                 gen_mfc0(env, ctx, rt, sel);
4332                 break;
4333             }
4334             break;
4335         default:
4336             gen_mfc0(env, ctx, rt, sel);
4337         }
4338     } else switch (sel) {
4339     /* GPR registers. */
4340     case 0:
4341         gen_op_mftgpr(rt);
4342         break;
4343     /* Auxiliary CPU registers */
4344     case 1:
4345         switch (rt) {
4346         case 0:
4347             gen_op_mftlo(0);
4348             break;
4349         case 1:
4350             gen_op_mfthi(0);
4351             break;
4352         case 2:
4353             gen_op_mftacx(0);
4354             break;
4355         case 4:
4356             gen_op_mftlo(1);
4357             break;
4358         case 5:
4359             gen_op_mfthi(1);
4360             break;
4361         case 6:
4362             gen_op_mftacx(1);
4363             break;
4364         case 8:
4365             gen_op_mftlo(2);
4366             break;
4367         case 9:
4368             gen_op_mfthi(2);
4369             break;
4370         case 10:
4371             gen_op_mftacx(2);
4372             break;
4373         case 12:
4374             gen_op_mftlo(3);
4375             break;
4376         case 13:
4377             gen_op_mfthi(3);
4378             break;
4379         case 14:
4380             gen_op_mftacx(3);
4381             break;
4382         case 16:
4383             gen_op_mftdsp();
4384             break;
4385         default:
4386             goto die;
4387         }
4388         break;
4389     /* Floating point (COP1). */
4390     case 2:
4391         /* XXX: For now we support only a single FPU context. */
4392         if (h == 0) {
4393             GEN_LOAD_FREG_FTN(WT0, rt);
4394             gen_op_mfc1();
4395         } else {
4396             GEN_LOAD_FREG_FTN(WTH0, rt);
4397             gen_op_mfhc1();
4398         }
4399         break;
4400     case 3:
4401         /* XXX: For now we support only a single FPU context. */
4402         gen_op_cfc1(rt);
4403         break;
4404     /* COP2: Not implemented. */
4405     case 4:
4406     case 5:
4407         /* fall through */
4408     default:
4409         goto die;
4410     }
4411 #if defined MIPS_DEBUG_DISAS
4412     if (loglevel & CPU_LOG_TB_IN_ASM) {
4413         fprintf(logfile, "mftr (reg %d u %d sel %d h %d)\n",
4414                 rt, u, sel, h);
4415     }
4416 #endif
4417     return;
4418
4419 die:
4420 #if defined MIPS_DEBUG_DISAS
4421     if (loglevel & CPU_LOG_TB_IN_ASM) {
4422         fprintf(logfile, "mftr (reg %d u %d sel %d h %d)\n",
4423                 rt, u, sel, h);
4424     }
4425 #endif
4426     generate_exception(ctx, EXCP_RI);
4427 }
4428
4429 static void gen_mttr(CPUState *env, DisasContext *ctx, int rd,
4430                      int u, int sel, int h)
4431 {
4432     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
4433
4434     if ((env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP)) == 0 &&
4435         ((env->CP0_TCBind[other_tc] & (0xf << CP0TCBd_CurVPE)) !=
4436          (env->CP0_TCBind[env->current_tc] & (0xf << CP0TCBd_CurVPE))))
4437         /* NOP */ ;
4438     else if ((env->CP0_VPEControl & (0xff << CP0VPECo_TargTC)) >
4439              (env->mvp->CP0_MVPConf0 & (0xff << CP0MVPC0_PTC)))
4440         /* NOP */ ;
4441     else if (u == 0) {
4442         switch (rd) {
4443         case 2:
4444             switch (sel) {
4445             case 1:
4446                 gen_op_mttc0_tcstatus();
4447                 break;
4448             case 2:
4449                 gen_op_mttc0_tcbind();
4450                 break;
4451             case 3:
4452                 gen_op_mttc0_tcrestart();
4453                 break;
4454             case 4:
4455                 gen_op_mttc0_tchalt();
4456                 break;
4457             case 5:
4458                 gen_op_mttc0_tccontext();
4459                 break;
4460             case 6:
4461                 gen_op_mttc0_tcschedule();
4462                 break;
4463             case 7:
4464                 gen_op_mttc0_tcschefback();
4465                 break;
4466             default:
4467                 gen_mtc0(env, ctx, rd, sel);
4468                 break;
4469             }
4470             break;
4471         case 10:
4472             switch (sel) {
4473             case 0:
4474                 gen_op_mttc0_entryhi();
4475                 break;
4476             default:
4477                 gen_mtc0(env, ctx, rd, sel);
4478                 break;
4479             }
4480         case 12:
4481             switch (sel) {
4482             case 0:
4483                 gen_op_mttc0_status();
4484                 break;
4485             default:
4486                 gen_mtc0(env, ctx, rd, sel);
4487                 break;
4488             }
4489         case 23:
4490             switch (sel) {
4491             case 0:
4492                 gen_op_mttc0_debug();
4493                 break;
4494             default:
4495                 gen_mtc0(env, ctx, rd, sel);
4496                 break;
4497             }
4498             break;
4499         default:
4500             gen_mtc0(env, ctx, rd, sel);
4501         }
4502     } else switch (sel) {
4503     /* GPR registers. */
4504     case 0:
4505         gen_op_mttgpr(rd);
4506         break;
4507     /* Auxiliary CPU registers */
4508     case 1:
4509         switch (rd) {
4510         case 0:
4511             gen_op_mttlo(0);
4512             break;
4513         case 1:
4514             gen_op_mtthi(0);
4515             break;
4516         case 2:
4517             gen_op_mttacx(0);
4518             break;
4519         case 4:
4520             gen_op_mttlo(1);
4521             break;
4522         case 5:
4523             gen_op_mtthi(1);
4524             break;
4525         case 6:
4526             gen_op_mttacx(1);
4527             break;
4528         case 8:
4529             gen_op_mttlo(2);
4530             break;
4531         case 9:
4532             gen_op_mtthi(2);
4533             break;
4534         case 10:
4535             gen_op_mttacx(2);
4536             break;
4537         case 12:
4538             gen_op_mttlo(3);
4539             break;
4540         case 13:
4541             gen_op_mtthi(3);
4542             break;
4543         case 14:
4544             gen_op_mttacx(3);
4545             break;
4546         case 16:
4547             gen_op_mttdsp();
4548             break;
4549         default:
4550             goto die;
4551         }
4552         break;
4553     /* Floating point (COP1). */
4554     case 2:
4555         /* XXX: For now we support only a single FPU context. */
4556         if (h == 0) {
4557             gen_op_mtc1();
4558             GEN_STORE_FTN_FREG(rd, WT0);
4559         } else {
4560             gen_op_mthc1();
4561             GEN_STORE_FTN_FREG(rd, WTH0);
4562         }
4563         break;
4564     case 3:
4565         /* XXX: For now we support only a single FPU context. */
4566         gen_op_ctc1(rd);
4567         break;
4568     /* COP2: Not implemented. */
4569     case 4:
4570     case 5:
4571         /* fall through */
4572     default:
4573         goto die;
4574     }
4575 #if defined MIPS_DEBUG_DISAS
4576     if (loglevel & CPU_LOG_TB_IN_ASM) {
4577         fprintf(logfile, "mttr (reg %d u %d sel %d h %d)\n",
4578                 rd, u, sel, h);
4579     }
4580 #endif
4581     return;
4582
4583 die:
4584 #if defined MIPS_DEBUG_DISAS
4585     if (loglevel & CPU_LOG_TB_IN_ASM) {
4586         fprintf(logfile, "mttr (reg %d u %d sel %d h %d)\n",
4587                 rd, u, sel, h);
4588     }
4589 #endif
4590     generate_exception(ctx, EXCP_RI);
4591 }
4592
4593 static void gen_cp0 (CPUState *env, DisasContext *ctx, uint32_t opc, int rt, int rd)
4594 {
4595     const char *opn = "ldst";
4596
4597     switch (opc) {
4598     case OPC_MFC0:
4599         if (rt == 0) {
4600             /* Treat as NOP. */
4601             return;
4602         }
4603         gen_mfc0(env, ctx, rd, ctx->opcode & 0x7);
4604         gen_op_store_T0_gpr(rt);
4605         opn = "mfc0";
4606         break;
4607     case OPC_MTC0:
4608         GEN_LOAD_REG_TN(T0, rt);
4609         save_cpu_state(ctx, 1);
4610         gen_mtc0(env, ctx, rd, ctx->opcode & 0x7);
4611         opn = "mtc0";
4612         break;
4613 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
4614     case OPC_DMFC0:
4615         check_insn(env, ctx, ISA_MIPS3);
4616         if (rt == 0) {
4617             /* Treat as NOP. */
4618             return;
4619         }
4620         gen_dmfc0(env, ctx, rd, ctx->opcode & 0x7);
4621         gen_op_store_T0_gpr(rt);
4622         opn = "dmfc0";
4623         break;
4624     case OPC_DMTC0:
4625         check_insn(env, ctx, ISA_MIPS3);
4626         GEN_LOAD_REG_TN(T0, rt);
4627         save_cpu_state(ctx, 1);
4628         gen_dmtc0(env, ctx, rd, ctx->opcode & 0x7);
4629         opn = "dmtc0";
4630         break;
4631 #endif
4632     case OPC_MFTR:
4633         check_mips_mt(env, ctx);
4634         if (rd == 0) {
4635             /* Treat as NOP. */
4636             return;
4637         }
4638         gen_mftr(env, ctx, rt, (ctx->opcode >> 5) & 1,
4639                  ctx->opcode & 0x7, (ctx->opcode >> 4) & 1);
4640         gen_op_store_T0_gpr(rd);
4641         opn = "mftr";
4642         break;
4643     case OPC_MTTR:
4644         check_mips_mt(env, ctx);
4645         GEN_LOAD_REG_TN(T0, rt);
4646         gen_mttr(env, ctx, rd, (ctx->opcode >> 5) & 1,
4647                  ctx->opcode & 0x7, (ctx->opcode >> 4) & 1);
4648         opn = "mttr";
4649         break;
4650     case OPC_TLBWI:
4651         opn = "tlbwi";
4652         if (!env->tlb->do_tlbwi)
4653             goto die;
4654         gen_op_tlbwi();
4655         break;
4656     case OPC_TLBWR:
4657         opn = "tlbwr";
4658         if (!env->tlb->do_tlbwr)
4659             goto die;
4660         gen_op_tlbwr();
4661         break;
4662     case OPC_TLBP:
4663         opn = "tlbp";
4664         if (!env->tlb->do_tlbp)
4665             goto die;
4666         gen_op_tlbp();
4667         break;
4668     case OPC_TLBR:
4669         opn = "tlbr";
4670         if (!env->tlb->do_tlbr)
4671             goto die;
4672         gen_op_tlbr();
4673         break;
4674     case OPC_ERET:
4675         opn = "eret";
4676         check_insn(env, ctx, ISA_MIPS2);
4677         save_cpu_state(ctx, 1);
4678         gen_op_eret();
4679         ctx->bstate = BS_EXCP;
4680         break;
4681     case OPC_DERET:
4682         opn = "deret";
4683         check_insn(env, ctx, ISA_MIPS32);
4684         if (!(ctx->hflags & MIPS_HFLAG_DM)) {
4685             MIPS_INVAL(opn);
4686             generate_exception(ctx, EXCP_RI);
4687         } else {
4688             save_cpu_state(ctx, 1);
4689             gen_op_deret();
4690             ctx->bstate = BS_EXCP;
4691         }
4692         break;
4693     case OPC_WAIT:
4694         opn = "wait";
4695         check_insn(env, ctx, ISA_MIPS3 | ISA_MIPS32);
4696         /* If we get an exception, we want to restart at next instruction */
4697         ctx->pc += 4;
4698         save_cpu_state(ctx, 1);
4699         ctx->pc -= 4;
4700         gen_op_wait();
4701         ctx->bstate = BS_EXCP;
4702         break;
4703     default:
4704  die:
4705         MIPS_INVAL(opn);
4706         generate_exception(ctx, EXCP_RI);
4707         return;
4708     }
4709     MIPS_DEBUG("%s %s %d", opn, regnames[rt], rd);
4710 }
4711
4712 /* CP1 Branches (before delay slot) */
4713 static void gen_compute_branch1 (CPUState *env, DisasContext *ctx, uint32_t op,
4714                                  int32_t cc, int32_t offset)
4715 {
4716     target_ulong btarget;
4717     const char *opn = "cp1 cond branch";
4718
4719     if (cc != 0)
4720         check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
4721
4722     btarget = ctx->pc + 4 + offset;
4723
4724     switch (op) {
4725     case OPC_BC1F:
4726         gen_op_bc1f(cc);
4727         opn = "bc1f";
4728         goto not_likely;
4729     case OPC_BC1FL:
4730         gen_op_bc1f(cc);
4731         opn = "bc1fl";
4732         goto likely;
4733     case OPC_BC1T:
4734         gen_op_bc1t(cc);
4735         opn = "bc1t";
4736         goto not_likely;
4737     case OPC_BC1TL:
4738         gen_op_bc1t(cc);
4739         opn = "bc1tl";
4740     likely:
4741         ctx->hflags |= MIPS_HFLAG_BL;
4742         gen_op_set_bcond();
4743         gen_op_save_bcond();
4744         break;
4745     case OPC_BC1FANY2:
4746         gen_op_bc1any2f(cc);
4747         opn = "bc1any2f";
4748         goto not_likely;
4749     case OPC_BC1TANY2:
4750         gen_op_bc1any2t(cc);
4751         opn = "bc1any2t";
4752         goto not_likely;
4753     case OPC_BC1FANY4:
4754         gen_op_bc1any4f(cc);
4755         opn = "bc1any4f";
4756         goto not_likely;
4757     case OPC_BC1TANY4:
4758         gen_op_bc1any4t(cc);
4759         opn = "bc1any4t";
4760     not_likely:
4761         ctx->hflags |= MIPS_HFLAG_BC;
4762         gen_op_set_bcond();
4763         break;
4764     default:
4765         MIPS_INVAL(opn);
4766         generate_exception (ctx, EXCP_RI);
4767         return;
4768     }
4769     MIPS_DEBUG("%s: cond %02x target " TARGET_FMT_lx, opn,
4770                ctx->hflags, btarget);
4771     ctx->btarget = btarget;
4772 }
4773
4774 /* Coprocessor 1 (FPU) */
4775
4776 #define FOP(func, fmt) (((fmt) << 21) | (func))
4777
4778 static void gen_cp1 (DisasContext *ctx, uint32_t opc, int rt, int fs)
4779 {
4780     const char *opn = "cp1 move";
4781
4782     switch (opc) {
4783     case OPC_MFC1:
4784         GEN_LOAD_FREG_FTN(WT0, fs);
4785         gen_op_mfc1();
4786         GEN_STORE_TN_REG(rt, T0);
4787         opn = "mfc1";
4788         break;
4789     case OPC_MTC1:
4790         GEN_LOAD_REG_TN(T0, rt);
4791         gen_op_mtc1();
4792         GEN_STORE_FTN_FREG(fs, WT0);
4793         opn = "mtc1";
4794         break;
4795     case OPC_CFC1:
4796         gen_op_cfc1(fs);
4797         GEN_STORE_TN_REG(rt, T0);
4798         opn = "cfc1";
4799         break;
4800     case OPC_CTC1:
4801         GEN_LOAD_REG_TN(T0, rt);
4802         gen_op_ctc1(fs);
4803         opn = "ctc1";
4804         break;
4805     case OPC_DMFC1:
4806         GEN_LOAD_FREG_FTN(DT0, fs);
4807         gen_op_dmfc1();
4808         GEN_STORE_TN_REG(rt, T0);
4809         opn = "dmfc1";
4810         break;
4811     case OPC_DMTC1:
4812         GEN_LOAD_REG_TN(T0, rt);
4813         gen_op_dmtc1();
4814         GEN_STORE_FTN_FREG(fs, DT0);
4815         opn = "dmtc1";
4816         break;
4817     case OPC_MFHC1:
4818         GEN_LOAD_FREG_FTN(WTH0, fs);
4819         gen_op_mfhc1();
4820         GEN_STORE_TN_REG(rt, T0);
4821         opn = "mfhc1";
4822         break;
4823     case OPC_MTHC1:
4824         GEN_LOAD_REG_TN(T0, rt);
4825         gen_op_mthc1();
4826         GEN_STORE_FTN_FREG(fs, WTH0);
4827         opn = "mthc1";
4828         break;
4829     default:
4830         MIPS_INVAL(opn);
4831         generate_exception (ctx, EXCP_RI);
4832         return;
4833     }
4834     MIPS_DEBUG("%s %s %s", opn, regnames[rt], fregnames[fs]);
4835 }
4836
4837 static void gen_movci (DisasContext *ctx, int rd, int rs, int cc, int tf)
4838 {
4839     uint32_t ccbit;
4840
4841     GEN_LOAD_REG_TN(T0, rd);
4842     GEN_LOAD_REG_TN(T1, rs);
4843     if (cc) {
4844         ccbit = 1 << (24 + cc);
4845     } else
4846         ccbit = 1 << 23;
4847     if (!tf)
4848         gen_op_movf(ccbit);
4849     else
4850         gen_op_movt(ccbit);
4851     GEN_STORE_TN_REG(rd, T0);
4852 }
4853
4854 #define GEN_MOVCF(fmt)                                                \
4855 static void glue(gen_movcf_, fmt) (DisasContext *ctx, int cc, int tf) \
4856 {                                                                     \
4857     uint32_t ccbit;                                                   \
4858                                                                       \
4859     if (cc) {                                                         \
4860         ccbit = 1 << (24 + cc);                                       \
4861     } else                                                            \
4862         ccbit = 1 << 23;                                              \
4863     if (!tf)                                                          \
4864         glue(gen_op_float_movf_, fmt)(ccbit);                         \
4865     else                                                              \
4866         glue(gen_op_float_movt_, fmt)(ccbit);                         \
4867 }
4868 GEN_MOVCF(d);
4869 GEN_MOVCF(s);
4870 GEN_MOVCF(ps);
4871 #undef GEN_MOVCF
4872
4873 static void gen_farith (DisasContext *ctx, uint32_t op1,
4874                         int ft, int fs, int fd, int cc)
4875 {
4876     const char *opn = "farith";
4877     const char *condnames[] = {
4878             "c.f",
4879             "c.un",
4880             "c.eq",
4881             "c.ueq",
4882             "c.olt",
4883             "c.ult",
4884             "c.ole",
4885             "c.ule",
4886             "c.sf",
4887             "c.ngle",
4888             "c.seq",
4889             "c.ngl",
4890             "c.lt",
4891             "c.nge",
4892             "c.le",
4893             "c.ngt",
4894     };
4895     const char *condnames_abs[] = {
4896             "cabs.f",
4897             "cabs.un",
4898             "cabs.eq",
4899             "cabs.ueq",
4900             "cabs.olt",
4901             "cabs.ult",
4902             "cabs.ole",
4903             "cabs.ule",
4904             "cabs.sf",
4905             "cabs.ngle",
4906             "cabs.seq",
4907             "cabs.ngl",
4908             "cabs.lt",
4909             "cabs.nge",
4910             "cabs.le",
4911             "cabs.ngt",
4912     };
4913     enum { BINOP, CMPOP, OTHEROP } optype = OTHEROP;
4914     uint32_t func = ctx->opcode & 0x3f;
4915
4916     switch (ctx->opcode & FOP(0x3f, 0x1f)) {
4917     case FOP(0, 16):
4918         GEN_LOAD_FREG_FTN(WT0, fs);
4919         GEN_LOAD_FREG_FTN(WT1, ft);
4920         gen_op_float_add_s();
4921         GEN_STORE_FTN_FREG(fd, WT2);
4922         opn = "add.s";
4923         optype = BINOP;
4924         break;
4925     case FOP(1, 16):
4926         GEN_LOAD_FREG_FTN(WT0, fs);
4927         GEN_LOAD_FREG_FTN(WT1, ft);
4928         gen_op_float_sub_s();
4929         GEN_STORE_FTN_FREG(fd, WT2);
4930         opn = "sub.s";
4931         optype = BINOP;
4932         break;
4933     case FOP(2, 16):
4934         GEN_LOAD_FREG_FTN(WT0, fs);
4935         GEN_LOAD_FREG_FTN(WT1, ft);
4936         gen_op_float_mul_s();
4937         GEN_STORE_FTN_FREG(fd, WT2);
4938         opn = "mul.s";
4939         optype = BINOP;
4940         break;
4941     case FOP(3, 16):
4942         GEN_LOAD_FREG_FTN(WT0, fs);
4943         GEN_LOAD_FREG_FTN(WT1, ft);
4944         gen_op_float_div_s();
4945         GEN_STORE_FTN_FREG(fd, WT2);
4946         opn = "div.s";
4947         optype = BINOP;
4948         break;
4949     case FOP(4, 16):
4950         GEN_LOAD_FREG_FTN(WT0, fs);
4951         gen_op_float_sqrt_s();
4952         GEN_STORE_FTN_FREG(fd, WT2);
4953         opn = "sqrt.s";
4954         break;
4955     case FOP(5, 16):
4956         GEN_LOAD_FREG_FTN(WT0, fs);
4957         gen_op_float_abs_s();
4958         GEN_STORE_FTN_FREG(fd, WT2);
4959         opn = "abs.s";
4960         break;
4961     case FOP(6, 16):
4962         GEN_LOAD_FREG_FTN(WT0, fs);
4963         gen_op_float_mov_s();
4964         GEN_STORE_FTN_FREG(fd, WT2);
4965         opn = "mov.s";
4966         break;
4967     case FOP(7, 16):
4968         GEN_LOAD_FREG_FTN(WT0, fs);
4969         gen_op_float_chs_s();
4970         GEN_STORE_FTN_FREG(fd, WT2);
4971         opn = "neg.s";
4972         break;
4973     case FOP(8, 16):
4974         check_cp1_64bitmode(ctx);
4975         GEN_LOAD_FREG_FTN(WT0, fs);
4976         gen_op_float_roundl_s();
4977         GEN_STORE_FTN_FREG(fd, DT2);
4978         opn = "round.l.s";
4979         break;
4980     case FOP(9, 16):
4981         check_cp1_64bitmode(ctx);
4982         GEN_LOAD_FREG_FTN(WT0, fs);
4983         gen_op_float_truncl_s();
4984         GEN_STORE_FTN_FREG(fd, DT2);
4985         opn = "trunc.l.s";
4986         break;
4987     case FOP(10, 16):
4988         check_cp1_64bitmode(ctx);
4989         GEN_LOAD_FREG_FTN(WT0, fs);
4990         gen_op_float_ceill_s();
4991         GEN_STORE_FTN_FREG(fd, DT2);
4992         opn = "ceil.l.s";
4993         break;
4994     case FOP(11, 16):
4995         check_cp1_64bitmode(ctx);
4996         GEN_LOAD_FREG_FTN(WT0, fs);
4997         gen_op_float_floorl_s();
4998         GEN_STORE_FTN_FREG(fd, DT2);
4999         opn = "floor.l.s";
5000         break;
5001     case FOP(12, 16):
5002         GEN_LOAD_FREG_FTN(WT0, fs);
5003         gen_op_float_roundw_s();
5004         GEN_STORE_FTN_FREG(fd, WT2);
5005         opn = "round.w.s";
5006         break;
5007     case FOP(13, 16):
5008         GEN_LOAD_FREG_FTN(WT0, fs);
5009         gen_op_float_truncw_s();
5010         GEN_STORE_FTN_FREG(fd, WT2);
5011         opn = "trunc.w.s";
5012         break;
5013     case FOP(14, 16):
5014         GEN_LOAD_FREG_FTN(WT0, fs);
5015         gen_op_float_ceilw_s();
5016         GEN_STORE_FTN_FREG(fd, WT2);
5017         opn = "ceil.w.s";
5018         break;
5019     case FOP(15, 16):
5020         GEN_LOAD_FREG_FTN(WT0, fs);
5021         gen_op_float_floorw_s();
5022         GEN_STORE_FTN_FREG(fd, WT2);
5023         opn = "floor.w.s";
5024         break;
5025     case FOP(17, 16):
5026         GEN_LOAD_REG_TN(T0, ft);
5027         GEN_LOAD_FREG_FTN(WT0, fs);
5028         GEN_LOAD_FREG_FTN(WT2, fd);
5029         gen_movcf_s(ctx, (ft >> 2) & 0x7, ft & 0x1);
5030         GEN_STORE_FTN_FREG(fd, WT2);
5031         opn = "movcf.s";
5032         break;
5033     case FOP(18, 16):
5034         GEN_LOAD_REG_TN(T0, ft);
5035         GEN_LOAD_FREG_FTN(WT0, fs);
5036         GEN_LOAD_FREG_FTN(WT2, fd);
5037         gen_op_float_movz_s();
5038         GEN_STORE_FTN_FREG(fd, WT2);
5039         opn = "movz.s";
5040         break;
5041     case FOP(19, 16):
5042         GEN_LOAD_REG_TN(T0, ft);
5043         GEN_LOAD_FREG_FTN(WT0, fs);
5044         GEN_LOAD_FREG_FTN(WT2, fd);
5045         gen_op_float_movn_s();
5046         GEN_STORE_FTN_FREG(fd, WT2);
5047         opn = "movn.s";
5048         break;
5049     case FOP(21, 16):
5050         GEN_LOAD_FREG_FTN(WT0, fs);
5051         gen_op_float_recip_s();
5052         GEN_STORE_FTN_FREG(fd, WT2);
5053         opn = "recip.s";
5054         break;
5055     case FOP(22, 16):
5056         GEN_LOAD_FREG_FTN(WT0, fs);
5057         gen_op_float_rsqrt_s();
5058         GEN_STORE_FTN_FREG(fd, WT2);
5059         opn = "rsqrt.s";
5060         break;
5061     case FOP(28, 16):
5062         check_cp1_64bitmode(ctx);
5063         GEN_LOAD_FREG_FTN(WT0, fs);
5064         GEN_LOAD_FREG_FTN(WT2, fd);
5065         gen_op_float_recip2_s();
5066         GEN_STORE_FTN_FREG(fd, WT2);
5067         opn = "recip2.s";
5068         break;
5069     case FOP(29, 16):
5070         check_cp1_64bitmode(ctx);
5071         GEN_LOAD_FREG_FTN(WT0, fs);
5072         gen_op_float_recip1_s();
5073         GEN_STORE_FTN_FREG(fd, WT2);
5074         opn = "recip1.s";
5075         break;
5076     case FOP(30, 16):
5077         check_cp1_64bitmode(ctx);
5078         GEN_LOAD_FREG_FTN(WT0, fs);
5079         gen_op_float_rsqrt1_s();
5080         GEN_STORE_FTN_FREG(fd, WT2);
5081         opn = "rsqrt1.s";
5082         break;
5083     case FOP(31, 16):
5084         check_cp1_64bitmode(ctx);
5085         GEN_LOAD_FREG_FTN(WT0, fs);
5086         GEN_LOAD_FREG_FTN(WT2, ft);
5087         gen_op_float_rsqrt2_s();
5088         GEN_STORE_FTN_FREG(fd, WT2);
5089         opn = "rsqrt2.s";
5090         break;
5091     case FOP(33, 16):
5092         check_cp1_registers(ctx, fd);
5093         GEN_LOAD_FREG_FTN(WT0, fs);
5094         gen_op_float_cvtd_s();
5095         GEN_STORE_FTN_FREG(fd, DT2);
5096         opn = "cvt.d.s";
5097         break;
5098     case FOP(36, 16):
5099         GEN_LOAD_FREG_FTN(WT0, fs);
5100         gen_op_float_cvtw_s();
5101         GEN_STORE_FTN_FREG(fd, WT2);
5102         opn = "cvt.w.s";
5103         break;
5104     case FOP(37, 16):
5105         check_cp1_64bitmode(ctx);
5106         GEN_LOAD_FREG_FTN(WT0, fs);
5107         gen_op_float_cvtl_s();
5108         GEN_STORE_FTN_FREG(fd, DT2);
5109         opn = "cvt.l.s";
5110         break;
5111     case FOP(38, 16):
5112         check_cp1_64bitmode(ctx);
5113         GEN_LOAD_FREG_FTN(WT1, fs);
5114         GEN_LOAD_FREG_FTN(WT0, ft);
5115         gen_op_float_cvtps_s();
5116         GEN_STORE_FTN_FREG(fd, DT2);
5117         opn = "cvt.ps.s";
5118         break;
5119     case FOP(48, 16):
5120     case FOP(49, 16):
5121     case FOP(50, 16):
5122     case FOP(51, 16):
5123     case FOP(52, 16):
5124     case FOP(53, 16):
5125     case FOP(54, 16):
5126     case FOP(55, 16):
5127     case FOP(56, 16):
5128     case FOP(57, 16):
5129     case FOP(58, 16):
5130     case FOP(59, 16):
5131     case FOP(60, 16):
5132     case FOP(61, 16):
5133     case FOP(62, 16):
5134     case FOP(63, 16):
5135         GEN_LOAD_FREG_FTN(WT0, fs);
5136         GEN_LOAD_FREG_FTN(WT1, ft);
5137         if (ctx->opcode & (1 << 6)) {
5138             check_cp1_64bitmode(ctx);
5139             gen_cmpabs_s(func-48, cc);
5140             opn = condnames_abs[func-48];
5141         } else {
5142             gen_cmp_s(func-48, cc);
5143             opn = condnames[func-48];
5144         }
5145         break;
5146     case FOP(0, 17):
5147         check_cp1_registers(ctx, fs | ft | fd);
5148         GEN_LOAD_FREG_FTN(DT0, fs);
5149         GEN_LOAD_FREG_FTN(DT1, ft);
5150         gen_op_float_add_d();
5151         GEN_STORE_FTN_FREG(fd, DT2);
5152         opn = "add.d";
5153         optype = BINOP;
5154         break;
5155     case FOP(1, 17):
5156         check_cp1_registers(ctx, fs | ft | fd);
5157         GEN_LOAD_FREG_FTN(DT0, fs);
5158         GEN_LOAD_FREG_FTN(DT1, ft);
5159         gen_op_float_sub_d();
5160         GEN_STORE_FTN_FREG(fd, DT2);
5161         opn = "sub.d";
5162         optype = BINOP;
5163         break;
5164     case FOP(2, 17):
5165         check_cp1_registers(ctx, fs | ft | fd);
5166         GEN_LOAD_FREG_FTN(DT0, fs);
5167         GEN_LOAD_FREG_FTN(DT1, ft);
5168         gen_op_float_mul_d();
5169         GEN_STORE_FTN_FREG(fd, DT2);
5170         opn = "mul.d";
5171         optype = BINOP;
5172         break;
5173     case FOP(3, 17):
5174         check_cp1_registers(ctx, fs | ft | fd);
5175         GEN_LOAD_FREG_FTN(DT0, fs);
5176         GEN_LOAD_FREG_FTN(DT1, ft);
5177         gen_op_float_div_d();
5178         GEN_STORE_FTN_FREG(fd, DT2);
5179         opn = "div.d";
5180         optype = BINOP;
5181         break;
5182     case FOP(4, 17):
5183         check_cp1_registers(ctx, fs | fd);
5184         GEN_LOAD_FREG_FTN(DT0, fs);
5185         gen_op_float_sqrt_d();
5186         GEN_STORE_FTN_FREG(fd, DT2);
5187         opn = "sqrt.d";
5188         break;
5189     case FOP(5, 17):
5190         check_cp1_registers(ctx, fs | fd);
5191         GEN_LOAD_FREG_FTN(DT0, fs);
5192         gen_op_float_abs_d();
5193         GEN_STORE_FTN_FREG(fd, DT2);
5194         opn = "abs.d";
5195         break;
5196     case FOP(6, 17):
5197         check_cp1_registers(ctx, fs | fd);
5198         GEN_LOAD_FREG_FTN(DT0, fs);
5199         gen_op_float_mov_d();
5200         GEN_STORE_FTN_FREG(fd, DT2);
5201         opn = "mov.d";
5202         break;
5203     case FOP(7, 17):
5204         check_cp1_registers(ctx, fs | fd);
5205         GEN_LOAD_FREG_FTN(DT0, fs);
5206         gen_op_float_chs_d();
5207         GEN_STORE_FTN_FREG(fd, DT2);
5208         opn = "neg.d";
5209         break;
5210     case FOP(8, 17):
5211         check_cp1_64bitmode(ctx);
5212         GEN_LOAD_FREG_FTN(DT0, fs);
5213         gen_op_float_roundl_d();
5214         GEN_STORE_FTN_FREG(fd, DT2);
5215         opn = "round.l.d";
5216         break;
5217     case FOP(9, 17):
5218         check_cp1_64bitmode(ctx);
5219         GEN_LOAD_FREG_FTN(DT0, fs);
5220         gen_op_float_truncl_d();
5221         GEN_STORE_FTN_FREG(fd, DT2);
5222         opn = "trunc.l.d";
5223         break;
5224     case FOP(10, 17):
5225         check_cp1_64bitmode(ctx);
5226         GEN_LOAD_FREG_FTN(DT0, fs);
5227         gen_op_float_ceill_d();
5228         GEN_STORE_FTN_FREG(fd, DT2);
5229         opn = "ceil.l.d";
5230         break;
5231     case FOP(11, 17):
5232         check_cp1_64bitmode(ctx);
5233         GEN_LOAD_FREG_FTN(DT0, fs);
5234         gen_op_float_floorl_d();
5235         GEN_STORE_FTN_FREG(fd, DT2);
5236         opn = "floor.l.d";
5237         break;
5238     case FOP(12, 17):
5239         check_cp1_registers(ctx, fs);
5240         GEN_LOAD_FREG_FTN(DT0, fs);
5241         gen_op_float_roundw_d();
5242         GEN_STORE_FTN_FREG(fd, WT2);
5243         opn = "round.w.d";
5244         break;
5245     case FOP(13, 17):
5246         check_cp1_registers(ctx, fs);
5247         GEN_LOAD_FREG_FTN(DT0, fs);
5248         gen_op_float_truncw_d();
5249         GEN_STORE_FTN_FREG(fd, WT2);
5250         opn = "trunc.w.d";
5251         break;
5252     case FOP(14, 17):
5253         check_cp1_registers(ctx, fs);
5254         GEN_LOAD_FREG_FTN(DT0, fs);
5255         gen_op_float_ceilw_d();
5256         GEN_STORE_FTN_FREG(fd, WT2);
5257         opn = "ceil.w.d";
5258         break;
5259     case FOP(15, 17):
5260         check_cp1_registers(ctx, fs);
5261         GEN_LOAD_FREG_FTN(DT0, fs);
5262         gen_op_float_floorw_d();
5263         GEN_STORE_FTN_FREG(fd, WT2);
5264         opn = "floor.w.d";
5265         break;
5266     case FOP(17, 17):
5267         GEN_LOAD_REG_TN(T0, ft);
5268         GEN_LOAD_FREG_FTN(DT0, fs);
5269         GEN_LOAD_FREG_FTN(DT2, fd);
5270         gen_movcf_d(ctx, (ft >> 2) & 0x7, ft & 0x1);
5271         GEN_STORE_FTN_FREG(fd, DT2);
5272         opn = "movcf.d";
5273         break;
5274     case FOP(18, 17):
5275         GEN_LOAD_REG_TN(T0, ft);
5276         GEN_LOAD_FREG_FTN(DT0, fs);
5277         GEN_LOAD_FREG_FTN(DT2, fd);
5278         gen_op_float_movz_d();
5279         GEN_STORE_FTN_FREG(fd, DT2);
5280         opn = "movz.d";
5281         break;
5282     case FOP(19, 17):
5283         GEN_LOAD_REG_TN(T0, ft);
5284         GEN_LOAD_FREG_FTN(DT0, fs);
5285         GEN_LOAD_FREG_FTN(DT2, fd);
5286         gen_op_float_movn_d();
5287         GEN_STORE_FTN_FREG(fd, DT2);
5288         opn = "movn.d";
5289         break;
5290     case FOP(21, 17):
5291         check_cp1_registers(ctx, fs | fd);
5292         GEN_LOAD_FREG_FTN(DT0, fs);
5293         gen_op_float_recip_d();
5294         GEN_STORE_FTN_FREG(fd, DT2);
5295         opn = "recip.d";
5296         break;
5297     case FOP(22, 17):
5298         check_cp1_registers(ctx, fs | fd);
5299         GEN_LOAD_FREG_FTN(DT0, fs);
5300         gen_op_float_rsqrt_d();
5301         GEN_STORE_FTN_FREG(fd, DT2);
5302         opn = "rsqrt.d";
5303         break;
5304     case FOP(28, 17):
5305         check_cp1_64bitmode(ctx);
5306         GEN_LOAD_FREG_FTN(DT0, fs);
5307         GEN_LOAD_FREG_FTN(DT2, ft);
5308         gen_op_float_recip2_d();
5309         GEN_STORE_FTN_FREG(fd, DT2);
5310         opn = "recip2.d";
5311         break;
5312     case FOP(29, 17):
5313         check_cp1_64bitmode(ctx);
5314         GEN_LOAD_FREG_FTN(DT0, fs);
5315         gen_op_float_recip1_d();
5316         GEN_STORE_FTN_FREG(fd, DT2);
5317         opn = "recip1.d";
5318         break;
5319     case FOP(30, 17):
5320         check_cp1_64bitmode(ctx);
5321         GEN_LOAD_FREG_FTN(DT0, fs);
5322         gen_op_float_rsqrt1_d();
5323         GEN_STORE_FTN_FREG(fd, DT2);
5324         opn = "rsqrt1.d";
5325         break;
5326     case FOP(31, 17):
5327         check_cp1_64bitmode(ctx);
5328         GEN_LOAD_FREG_FTN(DT0, fs);
5329         GEN_LOAD_FREG_FTN(DT2, ft);
5330         gen_op_float_rsqrt2_d();
5331         GEN_STORE_FTN_FREG(fd, DT2);
5332         opn = "rsqrt2.d";
5333         break;
5334     case FOP(48, 17):
5335     case FOP(49, 17):
5336     case FOP(50, 17):
5337     case FOP(51, 17):
5338     case FOP(52, 17):
5339     case FOP(53, 17):
5340     case FOP(54, 17):
5341     case FOP(55, 17):
5342     case FOP(56, 17):
5343     case FOP(57, 17):
5344     case FOP(58, 17):
5345     case FOP(59, 17):
5346     case FOP(60, 17):
5347     case FOP(61, 17):
5348     case FOP(62, 17):
5349     case FOP(63, 17):
5350         GEN_LOAD_FREG_FTN(DT0, fs);
5351         GEN_LOAD_FREG_FTN(DT1, ft);
5352         if (ctx->opcode & (1 << 6)) {
5353             check_cp1_64bitmode(ctx);
5354             gen_cmpabs_d(func-48, cc);
5355             opn = condnames_abs[func-48];
5356         } else {
5357             check_cp1_registers(ctx, fs | ft);
5358             gen_cmp_d(func-48, cc);
5359             opn = condnames[func-48];
5360         }
5361         break;
5362     case FOP(32, 17):
5363         check_cp1_registers(ctx, fs);
5364         GEN_LOAD_FREG_FTN(DT0, fs);
5365         gen_op_float_cvts_d();
5366         GEN_STORE_FTN_FREG(fd, WT2);
5367         opn = "cvt.s.d";
5368         break;
5369     case FOP(36, 17):
5370         check_cp1_registers(ctx, fs);
5371         GEN_LOAD_FREG_FTN(DT0, fs);
5372         gen_op_float_cvtw_d();
5373         GEN_STORE_FTN_FREG(fd, WT2);
5374         opn = "cvt.w.d";
5375         break;
5376     case FOP(37, 17):
5377         check_cp1_64bitmode(ctx);
5378         GEN_LOAD_FREG_FTN(DT0, fs);
5379         gen_op_float_cvtl_d();
5380         GEN_STORE_FTN_FREG(fd, DT2);
5381         opn = "cvt.l.d";
5382         break;
5383     case FOP(32, 20):
5384         GEN_LOAD_FREG_FTN(WT0, fs);
5385         gen_op_float_cvts_w();
5386         GEN_STORE_FTN_FREG(fd, WT2);
5387         opn = "cvt.s.w";
5388         break;
5389     case FOP(33, 20):
5390         check_cp1_registers(ctx, fd);
5391         GEN_LOAD_FREG_FTN(WT0, fs);
5392         gen_op_float_cvtd_w();
5393         GEN_STORE_FTN_FREG(fd, DT2);
5394         opn = "cvt.d.w";
5395         break;
5396     case FOP(32, 21):
5397         check_cp1_64bitmode(ctx);
5398         GEN_LOAD_FREG_FTN(DT0, fs);
5399         gen_op_float_cvts_l();
5400         GEN_STORE_FTN_FREG(fd, WT2);
5401         opn = "cvt.s.l";
5402         break;
5403     case FOP(33, 21):
5404         check_cp1_64bitmode(ctx);
5405         GEN_LOAD_FREG_FTN(DT0, fs);
5406         gen_op_float_cvtd_l();
5407         GEN_STORE_FTN_FREG(fd, DT2);
5408         opn = "cvt.d.l";
5409         break;
5410     case FOP(38, 20):
5411     case FOP(38, 21):
5412         check_cp1_64bitmode(ctx);
5413         GEN_LOAD_FREG_FTN(WT0, fs);
5414         GEN_LOAD_FREG_FTN(WTH0, fs);
5415         gen_op_float_cvtps_pw();
5416         GEN_STORE_FTN_FREG(fd, WT2);
5417         GEN_STORE_FTN_FREG(fd, WTH2);
5418         opn = "cvt.ps.pw";
5419         break;
5420     case FOP(0, 22):
5421         check_cp1_64bitmode(ctx);
5422         GEN_LOAD_FREG_FTN(WT0, fs);
5423         GEN_LOAD_FREG_FTN(WTH0, fs);
5424         GEN_LOAD_FREG_FTN(WT1, ft);
5425         GEN_LOAD_FREG_FTN(WTH1, ft);
5426         gen_op_float_add_ps();
5427         GEN_STORE_FTN_FREG(fd, WT2);
5428         GEN_STORE_FTN_FREG(fd, WTH2);
5429         opn = "add.ps";
5430         break;
5431     case FOP(1, 22):
5432         check_cp1_64bitmode(ctx);
5433         GEN_LOAD_FREG_FTN(WT0, fs);
5434         GEN_LOAD_FREG_FTN(WTH0, fs);
5435         GEN_LOAD_FREG_FTN(WT1, ft);
5436         GEN_LOAD_FREG_FTN(WTH1, ft);
5437         gen_op_float_sub_ps();
5438         GEN_STORE_FTN_FREG(fd, WT2);
5439         GEN_STORE_FTN_FREG(fd, WTH2);
5440         opn = "sub.ps";
5441         break;
5442     case FOP(2, 22):
5443         check_cp1_64bitmode(ctx);
5444         GEN_LOAD_FREG_FTN(WT0, fs);
5445         GEN_LOAD_FREG_FTN(WTH0, fs);
5446         GEN_LOAD_FREG_FTN(WT1, ft);
5447         GEN_LOAD_FREG_FTN(WTH1, ft);
5448         gen_op_float_mul_ps();
5449         GEN_STORE_FTN_FREG(fd, WT2);
5450         GEN_STORE_FTN_FREG(fd, WTH2);
5451         opn = "mul.ps";
5452         break;
5453     case FOP(5, 22):
5454         check_cp1_64bitmode(ctx);
5455         GEN_LOAD_FREG_FTN(WT0, fs);
5456         GEN_LOAD_FREG_FTN(WTH0, fs);
5457         gen_op_float_abs_ps();
5458         GEN_STORE_FTN_FREG(fd, WT2);
5459         GEN_STORE_FTN_FREG(fd, WTH2);
5460         opn = "abs.ps";
5461         break;
5462     case FOP(6, 22):
5463         check_cp1_64bitmode(ctx);
5464         GEN_LOAD_FREG_FTN(WT0, fs);
5465         GEN_LOAD_FREG_FTN(WTH0, fs);
5466         gen_op_float_mov_ps();
5467         GEN_STORE_FTN_FREG(fd, WT2);
5468         GEN_STORE_FTN_FREG(fd, WTH2);
5469         opn = "mov.ps";
5470         break;
5471     case FOP(7, 22):
5472         check_cp1_64bitmode(ctx);
5473         GEN_LOAD_FREG_FTN(WT0, fs);
5474         GEN_LOAD_FREG_FTN(WTH0, fs);
5475         gen_op_float_chs_ps();
5476         GEN_STORE_FTN_FREG(fd, WT2);
5477         GEN_STORE_FTN_FREG(fd, WTH2);
5478         opn = "neg.ps";
5479         break;
5480     case FOP(17, 22):
5481         check_cp1_64bitmode(ctx);
5482         GEN_LOAD_REG_TN(T0, ft);
5483         GEN_LOAD_FREG_FTN(WT0, fs);
5484         GEN_LOAD_FREG_FTN(WTH0, fs);
5485         GEN_LOAD_FREG_FTN(WT2, fd);
5486         GEN_LOAD_FREG_FTN(WTH2, fd);
5487         gen_movcf_ps(ctx, (ft >> 2) & 0x7, ft & 0x1);
5488         GEN_STORE_FTN_FREG(fd, WT2);
5489         GEN_STORE_FTN_FREG(fd, WTH2);
5490         opn = "movcf.ps";
5491         break;
5492     case FOP(18, 22):
5493         check_cp1_64bitmode(ctx);
5494         GEN_LOAD_REG_TN(T0, ft);
5495         GEN_LOAD_FREG_FTN(WT0, fs);
5496         GEN_LOAD_FREG_FTN(WTH0, fs);
5497         GEN_LOAD_FREG_FTN(WT2, fd);
5498         GEN_LOAD_FREG_FTN(WTH2, fd);
5499         gen_op_float_movz_ps();
5500         GEN_STORE_FTN_FREG(fd, WT2);
5501         GEN_STORE_FTN_FREG(fd, WTH2);
5502         opn = "movz.ps";
5503         break;
5504     case FOP(19, 22):
5505         check_cp1_64bitmode(ctx);
5506         GEN_LOAD_REG_TN(T0, ft);
5507         GEN_LOAD_FREG_FTN(WT0, fs);
5508         GEN_LOAD_FREG_FTN(WTH0, fs);
5509         GEN_LOAD_FREG_FTN(WT2, fd);
5510         GEN_LOAD_FREG_FTN(WTH2, fd);
5511         gen_op_float_movn_ps();
5512         GEN_STORE_FTN_FREG(fd, WT2);
5513         GEN_STORE_FTN_FREG(fd, WTH2);
5514         opn = "movn.ps";
5515         break;
5516     case FOP(24, 22):
5517         check_cp1_64bitmode(ctx);
5518         GEN_LOAD_FREG_FTN(WT0, ft);
5519         GEN_LOAD_FREG_FTN(WTH0, ft);
5520         GEN_LOAD_FREG_FTN(WT1, fs);
5521         GEN_LOAD_FREG_FTN(WTH1, fs);
5522         gen_op_float_addr_ps();
5523         GEN_STORE_FTN_FREG(fd, WT2);
5524         GEN_STORE_FTN_FREG(fd, WTH2);
5525         opn = "addr.ps";
5526         break;
5527     case FOP(26, 22):
5528         check_cp1_64bitmode(ctx);
5529         GEN_LOAD_FREG_FTN(WT0, ft);
5530         GEN_LOAD_FREG_FTN(WTH0, ft);
5531         GEN_LOAD_FREG_FTN(WT1, fs);
5532         GEN_LOAD_FREG_FTN(WTH1, fs);
5533         gen_op_float_mulr_ps();
5534         GEN_STORE_FTN_FREG(fd, WT2);
5535         GEN_STORE_FTN_FREG(fd, WTH2);
5536         opn = "mulr.ps";
5537         break;
5538     case FOP(28, 22):
5539         check_cp1_64bitmode(ctx);
5540         GEN_LOAD_FREG_FTN(WT0, fs);
5541         GEN_LOAD_FREG_FTN(WTH0, fs);
5542         GEN_LOAD_FREG_FTN(WT2, fd);
5543         GEN_LOAD_FREG_FTN(WTH2, fd);
5544         gen_op_float_recip2_ps();
5545         GEN_STORE_FTN_FREG(fd, WT2);
5546         GEN_STORE_FTN_FREG(fd, WTH2);
5547         opn = "recip2.ps";
5548         break;
5549     case FOP(29, 22):
5550         check_cp1_64bitmode(ctx);
5551         GEN_LOAD_FREG_FTN(WT0, fs);
5552         GEN_LOAD_FREG_FTN(WTH0, fs);
5553         gen_op_float_recip1_ps();
5554         GEN_STORE_FTN_FREG(fd, WT2);
5555         GEN_STORE_FTN_FREG(fd, WTH2);
5556         opn = "recip1.ps";
5557         break;
5558     case FOP(30, 22):
5559         check_cp1_64bitmode(ctx);
5560         GEN_LOAD_FREG_FTN(WT0, fs);
5561         GEN_LOAD_FREG_FTN(WTH0, fs);
5562         gen_op_float_rsqrt1_ps();
5563         GEN_STORE_FTN_FREG(fd, WT2);
5564         GEN_STORE_FTN_FREG(fd, WTH2);
5565         opn = "rsqrt1.ps";
5566         break;
5567     case FOP(31, 22):
5568         check_cp1_64bitmode(ctx);
5569         GEN_LOAD_FREG_FTN(WT0, fs);
5570         GEN_LOAD_FREG_FTN(WTH0, fs);
5571         GEN_LOAD_FREG_FTN(WT2, ft);
5572         GEN_LOAD_FREG_FTN(WTH2, ft);
5573         gen_op_float_rsqrt2_ps();
5574         GEN_STORE_FTN_FREG(fd, WT2);
5575         GEN_STORE_FTN_FREG(fd, WTH2);
5576         opn = "rsqrt2.ps";
5577         break;
5578     case FOP(32, 22):
5579         check_cp1_64bitmode(ctx);
5580         GEN_LOAD_FREG_FTN(WTH0, fs);
5581         gen_op_float_cvts_pu();
5582         GEN_STORE_FTN_FREG(fd, WT2);
5583         opn = "cvt.s.pu";
5584         break;
5585     case FOP(36, 22):
5586         check_cp1_64bitmode(ctx);
5587         GEN_LOAD_FREG_FTN(WT0, fs);
5588         GEN_LOAD_FREG_FTN(WTH0, fs);
5589         gen_op_float_cvtpw_ps();
5590         GEN_STORE_FTN_FREG(fd, WT2);
5591         GEN_STORE_FTN_FREG(fd, WTH2);
5592         opn = "cvt.pw.ps";
5593         break;
5594     case FOP(40, 22):
5595         check_cp1_64bitmode(ctx);
5596         GEN_LOAD_FREG_FTN(WT0, fs);
5597         gen_op_float_cvts_pl();
5598         GEN_STORE_FTN_FREG(fd, WT2);
5599         opn = "cvt.s.pl";
5600         break;
5601     case FOP(44, 22):
5602         check_cp1_64bitmode(ctx);
5603         GEN_LOAD_FREG_FTN(WT0, fs);
5604         GEN_LOAD_FREG_FTN(WT1, ft);
5605         gen_op_float_pll_ps();
5606         GEN_STORE_FTN_FREG(fd, DT2);
5607         opn = "pll.ps";
5608         break;
5609     case FOP(45, 22):
5610         check_cp1_64bitmode(ctx);
5611         GEN_LOAD_FREG_FTN(WT0, fs);
5612         GEN_LOAD_FREG_FTN(WTH1, ft);
5613         gen_op_float_plu_ps();
5614         GEN_STORE_FTN_FREG(fd, DT2);
5615         opn = "plu.ps";
5616         break;
5617     case FOP(46, 22):
5618         check_cp1_64bitmode(ctx);
5619         GEN_LOAD_FREG_FTN(WTH0, fs);
5620         GEN_LOAD_FREG_FTN(WT1, ft);
5621         gen_op_float_pul_ps();
5622         GEN_STORE_FTN_FREG(fd, DT2);
5623         opn = "pul.ps";
5624         break;
5625     case FOP(47, 22):
5626         check_cp1_64bitmode(ctx);
5627         GEN_LOAD_FREG_FTN(WTH0, fs);
5628         GEN_LOAD_FREG_FTN(WTH1, ft);
5629         gen_op_float_puu_ps();
5630         GEN_STORE_FTN_FREG(fd, DT2);
5631         opn = "puu.ps";
5632         break;
5633     case FOP(48, 22):
5634     case FOP(49, 22):
5635     case FOP(50, 22):
5636     case FOP(51, 22):
5637     case FOP(52, 22):
5638     case FOP(53, 22):
5639     case FOP(54, 22):
5640     case FOP(55, 22):
5641     case FOP(56, 22):
5642     case FOP(57, 22):
5643     case FOP(58, 22):
5644     case FOP(59, 22):
5645     case FOP(60, 22):
5646     case FOP(61, 22):
5647     case FOP(62, 22):
5648     case FOP(63, 22):
5649         check_cp1_64bitmode(ctx);
5650         GEN_LOAD_FREG_FTN(WT0, fs);
5651         GEN_LOAD_FREG_FTN(WTH0, fs);
5652         GEN_LOAD_FREG_FTN(WT1, ft);
5653         GEN_LOAD_FREG_FTN(WTH1, ft);
5654         if (ctx->opcode & (1 << 6)) {
5655             gen_cmpabs_ps(func-48, cc);
5656             opn = condnames_abs[func-48];
5657         } else {
5658             gen_cmp_ps(func-48, cc);
5659             opn = condnames[func-48];
5660         }
5661         break;
5662     default:
5663         MIPS_INVAL(opn);
5664         generate_exception (ctx, EXCP_RI);
5665         return;
5666     }
5667     switch (optype) {
5668     case BINOP:
5669         MIPS_DEBUG("%s %s, %s, %s", opn, fregnames[fd], fregnames[fs], fregnames[ft]);
5670         break;
5671     case CMPOP:
5672         MIPS_DEBUG("%s %s,%s", opn, fregnames[fs], fregnames[ft]);
5673         break;
5674     default:
5675         MIPS_DEBUG("%s %s,%s", opn, fregnames[fd], fregnames[fs]);
5676         break;
5677     }
5678 }
5679
5680 /* Coprocessor 3 (FPU) */
5681 static void gen_flt3_ldst (DisasContext *ctx, uint32_t opc,
5682                            int fd, int fs, int base, int index)
5683 {
5684     const char *opn = "extended float load/store";
5685     int store = 0;
5686
5687     /* All of those work only on 64bit FPUs. */
5688     check_cp1_64bitmode(ctx);
5689     if (base == 0) {
5690         if (index == 0)
5691             gen_op_reset_T0();
5692         else
5693             GEN_LOAD_REG_TN(T0, index);
5694     } else if (index == 0) {
5695         GEN_LOAD_REG_TN(T0, base);
5696     } else {
5697         GEN_LOAD_REG_TN(T0, base);
5698         GEN_LOAD_REG_TN(T1, index);
5699         gen_op_addr_add();
5700     }
5701     /* Don't do NOP if destination is zero: we must perform the actual
5702        memory access. */
5703     switch (opc) {
5704     case OPC_LWXC1:
5705         op_ldst(lwc1);
5706         GEN_STORE_FTN_FREG(fd, WT0);
5707         opn = "lwxc1";
5708         break;
5709     case OPC_LDXC1:
5710         op_ldst(ldc1);
5711         GEN_STORE_FTN_FREG(fd, DT0);
5712         opn = "ldxc1";
5713         break;
5714     case OPC_LUXC1:
5715         op_ldst(luxc1);
5716         GEN_STORE_FTN_FREG(fd, DT0);
5717         opn = "luxc1";
5718         break;
5719     case OPC_SWXC1:
5720         GEN_LOAD_FREG_FTN(WT0, fs);
5721         op_ldst(swc1);
5722         opn = "swxc1";
5723         store = 1;
5724         break;
5725     case OPC_SDXC1:
5726         GEN_LOAD_FREG_FTN(DT0, fs);
5727         op_ldst(sdc1);
5728         opn = "sdxc1";
5729         store = 1;
5730         break;
5731     case OPC_SUXC1:
5732         GEN_LOAD_FREG_FTN(DT0, fs);
5733         op_ldst(suxc1);
5734         opn = "suxc1";
5735         store = 1;
5736         break;
5737     default:
5738         MIPS_INVAL(opn);
5739         generate_exception(ctx, EXCP_RI);
5740         return;
5741     }
5742     MIPS_DEBUG("%s %s, %s(%s)", opn, fregnames[store ? fs : fd],
5743                regnames[index], regnames[base]);
5744 }
5745
5746 static void gen_flt3_arith (DisasContext *ctx, uint32_t opc,
5747                             int fd, int fr, int fs, int ft)
5748 {
5749     const char *opn = "flt3_arith";
5750
5751     /* All of those work only on 64bit FPUs. */
5752     check_cp1_64bitmode(ctx);
5753     switch (opc) {
5754     case OPC_ALNV_PS:
5755         GEN_LOAD_REG_TN(T0, fr);
5756         GEN_LOAD_FREG_FTN(DT0, fs);
5757         GEN_LOAD_FREG_FTN(DT1, ft);
5758         gen_op_float_alnv_ps();
5759         GEN_STORE_FTN_FREG(fd, DT2);
5760         opn = "alnv.ps";
5761         break;
5762     case OPC_MADD_S:
5763         GEN_LOAD_FREG_FTN(WT0, fs);
5764         GEN_LOAD_FREG_FTN(WT1, ft);
5765         GEN_LOAD_FREG_FTN(WT2, fr);
5766         gen_op_float_muladd_s();
5767         GEN_STORE_FTN_FREG(fd, WT2);
5768         opn = "madd.s";
5769         break;
5770     case OPC_MADD_D:
5771         GEN_LOAD_FREG_FTN(DT0, fs);
5772         GEN_LOAD_FREG_FTN(DT1, ft);
5773         GEN_LOAD_FREG_FTN(DT2, fr);
5774         gen_op_float_muladd_d();
5775         GEN_STORE_FTN_FREG(fd, DT2);
5776         opn = "madd.d";
5777         break;
5778     case OPC_MADD_PS:
5779         GEN_LOAD_FREG_FTN(WT0, fs);
5780         GEN_LOAD_FREG_FTN(WTH0, fs);
5781         GEN_LOAD_FREG_FTN(WT1, ft);
5782         GEN_LOAD_FREG_FTN(WTH1, ft);
5783         GEN_LOAD_FREG_FTN(WT2, fr);
5784         GEN_LOAD_FREG_FTN(WTH2, fr);
5785         gen_op_float_muladd_ps();
5786         GEN_STORE_FTN_FREG(fd, WT2);
5787         GEN_STORE_FTN_FREG(fd, WTH2);
5788         opn = "madd.ps";
5789         break;
5790     case OPC_MSUB_S:
5791         GEN_LOAD_FREG_FTN(WT0, fs);
5792         GEN_LOAD_FREG_FTN(WT1, ft);
5793         GEN_LOAD_FREG_FTN(WT2, fr);
5794         gen_op_float_mulsub_s();
5795         GEN_STORE_FTN_FREG(fd, WT2);
5796         opn = "msub.s";
5797         break;
5798     case OPC_MSUB_D:
5799         GEN_LOAD_FREG_FTN(DT0, fs);
5800         GEN_LOAD_FREG_FTN(DT1, ft);
5801         GEN_LOAD_FREG_FTN(DT2, fr);
5802         gen_op_float_mulsub_d();
5803         GEN_STORE_FTN_FREG(fd, DT2);
5804         opn = "msub.d";
5805         break;
5806     case OPC_MSUB_PS:
5807         GEN_LOAD_FREG_FTN(WT0, fs);
5808         GEN_LOAD_FREG_FTN(WTH0, fs);
5809         GEN_LOAD_FREG_FTN(WT1, ft);
5810         GEN_LOAD_FREG_FTN(WTH1, ft);
5811         GEN_LOAD_FREG_FTN(WT2, fr);
5812         GEN_LOAD_FREG_FTN(WTH2, fr);
5813         gen_op_float_mulsub_ps();
5814         GEN_STORE_FTN_FREG(fd, WT2);
5815         GEN_STORE_FTN_FREG(fd, WTH2);
5816         opn = "msub.ps";
5817         break;
5818     case OPC_NMADD_S:
5819         GEN_LOAD_FREG_FTN(WT0, fs);
5820         GEN_LOAD_FREG_FTN(WT1, ft);
5821         GEN_LOAD_FREG_FTN(WT2, fr);
5822         gen_op_float_nmuladd_s();
5823         GEN_STORE_FTN_FREG(fd, WT2);
5824         opn = "nmadd.s";
5825         break;
5826     case OPC_NMADD_D:
5827         GEN_LOAD_FREG_FTN(DT0, fs);
5828         GEN_LOAD_FREG_FTN(DT1, ft);
5829         GEN_LOAD_FREG_FTN(DT2, fr);
5830         gen_op_float_nmuladd_d();
5831         GEN_STORE_FTN_FREG(fd, DT2);
5832         opn = "nmadd.d";
5833         break;
5834     case OPC_NMADD_PS:
5835         GEN_LOAD_FREG_FTN(WT0, fs);
5836         GEN_LOAD_FREG_FTN(WTH0, fs);
5837         GEN_LOAD_FREG_FTN(WT1, ft);
5838         GEN_LOAD_FREG_FTN(WTH1, ft);
5839         GEN_LOAD_FREG_FTN(WT2, fr);
5840         GEN_LOAD_FREG_FTN(WTH2, fr);
5841         gen_op_float_nmuladd_ps();
5842         GEN_STORE_FTN_FREG(fd, WT2);
5843         GEN_STORE_FTN_FREG(fd, WTH2);
5844         opn = "nmadd.ps";
5845         break;
5846     case OPC_NMSUB_S:
5847         GEN_LOAD_FREG_FTN(WT0, fs);
5848         GEN_LOAD_FREG_FTN(WT1, ft);
5849         GEN_LOAD_FREG_FTN(WT2, fr);
5850         gen_op_float_nmulsub_s();
5851         GEN_STORE_FTN_FREG(fd, WT2);
5852         opn = "nmsub.s";
5853         break;
5854     case OPC_NMSUB_D:
5855         GEN_LOAD_FREG_FTN(DT0, fs);
5856         GEN_LOAD_FREG_FTN(DT1, ft);
5857         GEN_LOAD_FREG_FTN(DT2, fr);
5858         gen_op_float_nmulsub_d();
5859         GEN_STORE_FTN_FREG(fd, DT2);
5860         opn = "nmsub.d";
5861         break;
5862     case OPC_NMSUB_PS:
5863         GEN_LOAD_FREG_FTN(WT0, fs);
5864         GEN_LOAD_FREG_FTN(WTH0, fs);
5865         GEN_LOAD_FREG_FTN(WT1, ft);
5866         GEN_LOAD_FREG_FTN(WTH1, ft);
5867         GEN_LOAD_FREG_FTN(WT2, fr);
5868         GEN_LOAD_FREG_FTN(WTH2, fr);
5869         gen_op_float_nmulsub_ps();
5870         GEN_STORE_FTN_FREG(fd, WT2);
5871         GEN_STORE_FTN_FREG(fd, WTH2);
5872         opn = "nmsub.ps";
5873         break;
5874     default:
5875         MIPS_INVAL(opn);
5876         generate_exception (ctx, EXCP_RI);
5877         return;
5878     }
5879     MIPS_DEBUG("%s %s, %s, %s, %s", opn, fregnames[fd], fregnames[fr],
5880                fregnames[fs], fregnames[ft]);
5881 }
5882
5883 /* ISA extensions (ASEs) */
5884 /* MIPS16 extension to MIPS32 */
5885 /* SmartMIPS extension to MIPS32 */
5886
5887 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
5888
5889 /* MDMX extension to MIPS64 */
5890 /* MIPS-3D extension to MIPS64 */
5891
5892 #endif
5893
5894 static void decode_opc (CPUState *env, DisasContext *ctx)
5895 {
5896     int32_t offset;
5897     int rs, rt, rd, sa;
5898     uint32_t op, op1, op2;
5899     int16_t imm;
5900
5901     /* make sure instructions are on a word boundary */
5902     if (ctx->pc & 0x3) {
5903         env->CP0_BadVAddr = ctx->pc;
5904         generate_exception(ctx, EXCP_AdEL);
5905         return;
5906     }
5907
5908     if ((ctx->hflags & MIPS_HFLAG_BMASK) == MIPS_HFLAG_BL) {
5909         int l1;
5910         /* Handle blikely not taken case */
5911         MIPS_DEBUG("blikely condition (" TARGET_FMT_lx ")", ctx->pc + 4);
5912         l1 = gen_new_label();
5913         gen_op_jnz_T2(l1);
5914         gen_op_save_state(ctx->hflags & ~MIPS_HFLAG_BMASK);
5915         gen_goto_tb(ctx, 1, ctx->pc + 4);
5916         gen_set_label(l1);
5917     }
5918     op = MASK_OP_MAJOR(ctx->opcode);
5919     rs = (ctx->opcode >> 21) & 0x1f;
5920     rt = (ctx->opcode >> 16) & 0x1f;
5921     rd = (ctx->opcode >> 11) & 0x1f;
5922     sa = (ctx->opcode >> 6) & 0x1f;
5923     imm = (int16_t)ctx->opcode;
5924     switch (op) {
5925     case OPC_SPECIAL:
5926         op1 = MASK_SPECIAL(ctx->opcode);
5927         switch (op1) {
5928         case OPC_SLL:          /* Arithmetic with immediate */
5929         case OPC_SRL ... OPC_SRA:
5930             gen_arith_imm(env, ctx, op1, rd, rt, sa);
5931             break;
5932         case OPC_MOVZ ... OPC_MOVN:
5933             check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
5934         case OPC_SLLV:         /* Arithmetic */
5935         case OPC_SRLV ... OPC_SRAV:
5936         case OPC_ADD ... OPC_NOR:
5937         case OPC_SLT ... OPC_SLTU:
5938             gen_arith(env, ctx, op1, rd, rs, rt);
5939             break;
5940         case OPC_MULT ... OPC_DIVU:
5941             gen_muldiv(ctx, op1, rs, rt);
5942             break;
5943         case OPC_JR ... OPC_JALR:
5944             gen_compute_branch(ctx, op1, rs, rd, sa);
5945             return;
5946         case OPC_TGE ... OPC_TEQ: /* Traps */
5947         case OPC_TNE:
5948             gen_trap(ctx, op1, rs, rt, -1);
5949             break;
5950         case OPC_MFHI:          /* Move from HI/LO */
5951         case OPC_MFLO:
5952             gen_HILO(ctx, op1, rd);
5953             break;
5954         case OPC_MTHI:
5955         case OPC_MTLO:          /* Move to HI/LO */
5956             gen_HILO(ctx, op1, rs);
5957             break;
5958         case OPC_PMON:          /* Pmon entry point, also R4010 selsl */
5959 #ifdef MIPS_STRICT_STANDARD
5960             MIPS_INVAL("PMON / selsl");
5961             generate_exception(ctx, EXCP_RI);
5962 #else
5963             gen_op_pmon(sa);
5964 #endif
5965             break;
5966         case OPC_SYSCALL:
5967             generate_exception(ctx, EXCP_SYSCALL);
5968             break;
5969         case OPC_BREAK:
5970             generate_exception(ctx, EXCP_BREAK);
5971             break;
5972         case OPC_SPIM:
5973 #ifdef MIPS_STRICT_STANDARD
5974             MIPS_INVAL("SPIM");
5975             generate_exception(ctx, EXCP_RI);
5976 #else
5977            /* Implemented as RI exception for now. */
5978             MIPS_INVAL("spim (unofficial)");
5979             generate_exception(ctx, EXCP_RI);
5980 #endif
5981             break;
5982         case OPC_SYNC:
5983             /* Treat as NOP. */
5984             break;
5985
5986         case OPC_MOVCI:
5987             check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
5988             if (env->CP0_Config1 & (1 << CP0C1_FP)) {
5989                 save_cpu_state(ctx, 1);
5990                 check_cp1_enabled(ctx);
5991                 gen_movci(ctx, rd, rs, (ctx->opcode >> 18) & 0x7,
5992                           (ctx->opcode >> 16) & 1);
5993             } else {
5994                 generate_exception_err(ctx, EXCP_CpU, 1);
5995             }
5996             break;
5997
5998 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
5999        /* MIPS64 specific opcodes */
6000         case OPC_DSLL:
6001         case OPC_DSRL ... OPC_DSRA:
6002         case OPC_DSLL32:
6003         case OPC_DSRL32 ... OPC_DSRA32:
6004             check_insn(env, ctx, ISA_MIPS3);
6005             check_mips_64(ctx);
6006             gen_arith_imm(env, ctx, op1, rd, rt, sa);
6007             break;
6008         case OPC_DSLLV:
6009         case OPC_DSRLV ... OPC_DSRAV:
6010         case OPC_DADD ... OPC_DSUBU:
6011             check_insn(env, ctx, ISA_MIPS3);
6012             check_mips_64(ctx);
6013             gen_arith(env, ctx, op1, rd, rs, rt);
6014             break;
6015         case OPC_DMULT ... OPC_DDIVU:
6016             check_insn(env, ctx, ISA_MIPS3);
6017             check_mips_64(ctx);
6018             gen_muldiv(ctx, op1, rs, rt);
6019             break;
6020 #endif
6021         default:            /* Invalid */
6022             MIPS_INVAL("special");
6023             generate_exception(ctx, EXCP_RI);
6024             break;
6025         }
6026         break;
6027     case OPC_SPECIAL2:
6028         op1 = MASK_SPECIAL2(ctx->opcode);
6029         switch (op1) {
6030         case OPC_MADD ... OPC_MADDU: /* Multiply and add/sub */
6031         case OPC_MSUB ... OPC_MSUBU:
6032             check_insn(env, ctx, ISA_MIPS32);
6033             gen_muldiv(ctx, op1, rs, rt);
6034             break;
6035         case OPC_MUL:
6036             gen_arith(env, ctx, op1, rd, rs, rt);
6037             break;
6038         case OPC_CLZ ... OPC_CLO:
6039             check_insn(env, ctx, ISA_MIPS32);
6040             gen_cl(ctx, op1, rd, rs);
6041             break;
6042         case OPC_SDBBP:
6043             /* XXX: not clear which exception should be raised
6044              *      when in debug mode...
6045              */
6046             check_insn(env, ctx, ISA_MIPS32);
6047             if (!(ctx->hflags & MIPS_HFLAG_DM)) {
6048                 generate_exception(ctx, EXCP_DBp);
6049             } else {
6050                 generate_exception(ctx, EXCP_DBp);
6051             }
6052             /* Treat as NOP. */
6053             break;
6054 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
6055         case OPC_DCLZ ... OPC_DCLO:
6056             check_insn(env, ctx, ISA_MIPS64);
6057             check_mips_64(ctx);
6058             gen_cl(ctx, op1, rd, rs);
6059             break;
6060 #endif
6061         default:            /* Invalid */
6062             MIPS_INVAL("special2");
6063             generate_exception(ctx, EXCP_RI);
6064             break;
6065         }
6066         break;
6067     case OPC_SPECIAL3:
6068          op1 = MASK_SPECIAL3(ctx->opcode);
6069          switch (op1) {
6070          case OPC_EXT:
6071          case OPC_INS:
6072              check_insn(env, ctx, ISA_MIPS32R2);
6073              gen_bitops(ctx, op1, rt, rs, sa, rd);
6074              break;
6075          case OPC_BSHFL:
6076              check_insn(env, ctx, ISA_MIPS32R2);
6077              op2 = MASK_BSHFL(ctx->opcode);
6078              switch (op2) {
6079              case OPC_WSBH:
6080                  GEN_LOAD_REG_TN(T1, rt);
6081                  gen_op_wsbh();
6082                  break;
6083              case OPC_SEB:
6084                  GEN_LOAD_REG_TN(T1, rt);
6085                  gen_op_seb();
6086                  break;
6087              case OPC_SEH:
6088                  GEN_LOAD_REG_TN(T1, rt);
6089                  gen_op_seh();
6090                  break;
6091              default:            /* Invalid */
6092                  MIPS_INVAL("bshfl");
6093                  generate_exception(ctx, EXCP_RI);
6094                  break;
6095             }
6096             GEN_STORE_TN_REG(rd, T0);
6097             break;
6098         case OPC_RDHWR:
6099             check_insn(env, ctx, ISA_MIPS32R2);
6100             switch (rd) {
6101             case 0:
6102                 save_cpu_state(ctx, 1);
6103                 gen_op_rdhwr_cpunum();
6104                 break;
6105             case 1:
6106                 save_cpu_state(ctx, 1);
6107                 gen_op_rdhwr_synci_step();
6108                 break;
6109             case 2:
6110                 save_cpu_state(ctx, 1);
6111                 gen_op_rdhwr_cc();
6112                 break;
6113             case 3:
6114                 save_cpu_state(ctx, 1);
6115                 gen_op_rdhwr_ccres();
6116                 break;
6117             case 29:
6118 #if defined (CONFIG_USER_ONLY)
6119                 gen_op_tls_value();
6120                 break;
6121 #endif
6122             default:            /* Invalid */
6123                 MIPS_INVAL("rdhwr");
6124                 generate_exception(ctx, EXCP_RI);
6125                 break;
6126             }
6127             GEN_STORE_TN_REG(rt, T0);
6128             break;
6129         case OPC_FORK:
6130             check_mips_mt(env, ctx);
6131             GEN_LOAD_REG_TN(T0, rt);
6132             GEN_LOAD_REG_TN(T1, rs);
6133             gen_op_fork();
6134             break;
6135         case OPC_YIELD:
6136             check_mips_mt(env, ctx);
6137             GEN_LOAD_REG_TN(T0, rs);
6138             gen_op_yield();
6139             GEN_STORE_TN_REG(rd, T0);
6140             break;
6141 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
6142         case OPC_DEXTM ... OPC_DEXT:
6143         case OPC_DINSM ... OPC_DINS:
6144             check_insn(env, ctx, ISA_MIPS64R2);
6145             check_mips_64(ctx);
6146             gen_bitops(ctx, op1, rt, rs, sa, rd);
6147             break;
6148         case OPC_DBSHFL:
6149             check_insn(env, ctx, ISA_MIPS64R2);
6150             check_mips_64(ctx);
6151             op2 = MASK_DBSHFL(ctx->opcode);
6152             switch (op2) {
6153             case OPC_DSBH:
6154                 GEN_LOAD_REG_TN(T1, rt);
6155                 gen_op_dsbh();
6156                 break;
6157             case OPC_DSHD:
6158                 GEN_LOAD_REG_TN(T1, rt);
6159                 gen_op_dshd();
6160                 break;
6161             default:            /* Invalid */
6162                 MIPS_INVAL("dbshfl");
6163                 generate_exception(ctx, EXCP_RI);
6164                 break;
6165             }
6166             GEN_STORE_TN_REG(rd, T0);
6167 #endif
6168         default:            /* Invalid */
6169             MIPS_INVAL("special3");
6170             generate_exception(ctx, EXCP_RI);
6171             break;
6172         }
6173         break;
6174     case OPC_REGIMM:
6175         op1 = MASK_REGIMM(ctx->opcode);
6176         switch (op1) {
6177         case OPC_BLTZ ... OPC_BGEZL: /* REGIMM branches */
6178         case OPC_BLTZAL ... OPC_BGEZALL:
6179             gen_compute_branch(ctx, op1, rs, -1, imm << 2);
6180             return;
6181         case OPC_TGEI ... OPC_TEQI: /* REGIMM traps */
6182         case OPC_TNEI:
6183             gen_trap(ctx, op1, rs, -1, imm);
6184             break;
6185         case OPC_SYNCI:
6186             check_insn(env, ctx, ISA_MIPS32R2);
6187             /* Treat as NOP. */
6188             break;
6189         default:            /* Invalid */
6190             MIPS_INVAL("regimm");
6191             generate_exception(ctx, EXCP_RI);
6192             break;
6193         }
6194         break;
6195     case OPC_CP0:
6196         check_cp0_enabled(ctx);
6197         op1 = MASK_CP0(ctx->opcode);
6198         switch (op1) {
6199         case OPC_MFC0:
6200         case OPC_MTC0:
6201         case OPC_MFTR:
6202         case OPC_MTTR:
6203 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
6204         case OPC_DMFC0:
6205         case OPC_DMTC0:
6206 #endif
6207             gen_cp0(env, ctx, op1, rt, rd);
6208             break;
6209         case OPC_C0_FIRST ... OPC_C0_LAST:
6210             gen_cp0(env, ctx, MASK_C0(ctx->opcode), rt, rd);
6211             break;
6212         case OPC_MFMC0:
6213             op2 = MASK_MFMC0(ctx->opcode);
6214             switch (op2) {
6215             case OPC_DMT:
6216                 check_mips_mt(env, ctx);
6217                 gen_op_dmt();
6218                 break;
6219             case OPC_EMT:
6220                 check_mips_mt(env, ctx);
6221                 gen_op_emt();
6222                 break;
6223             case OPC_DVPE:
6224                 check_mips_mt(env, ctx);
6225                 gen_op_dvpe();
6226                 break;
6227             case OPC_EVPE:
6228                 check_mips_mt(env, ctx);
6229                 gen_op_evpe();
6230                 break;
6231             case OPC_DI:
6232                 check_insn(env, ctx, ISA_MIPS32R2);
6233                 save_cpu_state(ctx, 1);
6234                 gen_op_di();
6235                 /* Stop translation as we may have switched the execution mode */
6236                 ctx->bstate = BS_STOP;
6237                 break;
6238             case OPC_EI:
6239                 check_insn(env, ctx, ISA_MIPS32R2);
6240                 save_cpu_state(ctx, 1);
6241                 gen_op_ei();
6242                 /* Stop translation as we may have switched the execution mode */
6243                 ctx->bstate = BS_STOP;
6244                 break;
6245             default:            /* Invalid */
6246                 MIPS_INVAL("mfmc0");
6247                 generate_exception(ctx, EXCP_RI);
6248                 break;
6249             }
6250             GEN_STORE_TN_REG(rt, T0);
6251             break;
6252         case OPC_RDPGPR:
6253             check_insn(env, ctx, ISA_MIPS32R2);
6254             GEN_LOAD_SRSREG_TN(T0, rt);
6255             GEN_STORE_TN_REG(rd, T0);
6256             break;
6257         case OPC_WRPGPR:
6258             check_insn(env, ctx, ISA_MIPS32R2);
6259             GEN_LOAD_REG_TN(T0, rt);
6260             GEN_STORE_TN_SRSREG(rd, T0);
6261             break;
6262         default:
6263             MIPS_INVAL("cp0");
6264             generate_exception(ctx, EXCP_RI);
6265             break;
6266         }
6267         break;
6268     case OPC_ADDI ... OPC_LUI: /* Arithmetic with immediate opcode */
6269          gen_arith_imm(env, ctx, op, rt, rs, imm);
6270          break;
6271     case OPC_J ... OPC_JAL: /* Jump */
6272          offset = (int32_t)(ctx->opcode & 0x3FFFFFF) << 2;
6273          gen_compute_branch(ctx, op, rs, rt, offset);
6274          return;
6275     case OPC_BEQ ... OPC_BGTZ: /* Branch */
6276     case OPC_BEQL ... OPC_BGTZL:
6277          gen_compute_branch(ctx, op, rs, rt, imm << 2);
6278          return;
6279     case OPC_LB ... OPC_LWR: /* Load and stores */
6280     case OPC_SB ... OPC_SW:
6281     case OPC_SWR:
6282     case OPC_LL:
6283     case OPC_SC:
6284          gen_ldst(ctx, op, rt, rs, imm);
6285          break;
6286     case OPC_CACHE:
6287         check_insn(env, ctx, ISA_MIPS3 | ISA_MIPS32);
6288         /* Treat as NOP. */
6289         break;
6290     case OPC_PREF:
6291         check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
6292         /* Treat as NOP. */
6293         break;
6294
6295     /* Floating point (COP1). */
6296     case OPC_LWC1:
6297     case OPC_LDC1:
6298     case OPC_SWC1:
6299     case OPC_SDC1:
6300         if (env->CP0_Config1 & (1 << CP0C1_FP)) {
6301             save_cpu_state(ctx, 1);
6302             check_cp1_enabled(ctx);
6303             gen_flt_ldst(ctx, op, rt, rs, imm);
6304         } else {
6305             generate_exception_err(ctx, EXCP_CpU, 1);
6306         }
6307         break;
6308
6309     case OPC_CP1:
6310         if (env->CP0_Config1 & (1 << CP0C1_FP)) {
6311             save_cpu_state(ctx, 1);
6312             check_cp1_enabled(ctx);
6313             op1 = MASK_CP1(ctx->opcode);
6314             switch (op1) {
6315             case OPC_MFHC1:
6316             case OPC_MTHC1:
6317                 check_insn(env, ctx, ISA_MIPS32R2);
6318             case OPC_MFC1:
6319             case OPC_CFC1:
6320             case OPC_MTC1:
6321             case OPC_CTC1:
6322                 gen_cp1(ctx, op1, rt, rd);
6323                 break;
6324 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
6325             case OPC_DMFC1:
6326             case OPC_DMTC1:
6327                 check_insn(env, ctx, ISA_MIPS3);
6328                 gen_cp1(ctx, op1, rt, rd);
6329                 break;
6330 #endif
6331             case OPC_BC1:
6332             case OPC_BC1ANY2:
6333             case OPC_BC1ANY4:
6334                 gen_compute_branch1(env, ctx, MASK_BC1(ctx->opcode),
6335                                     (rt >> 2) & 0x7, imm << 2);
6336                 return;
6337             case OPC_S_FMT:
6338             case OPC_D_FMT:
6339             case OPC_W_FMT:
6340             case OPC_L_FMT:
6341             case OPC_PS_FMT:
6342                 gen_farith(ctx, MASK_CP1_FUNC(ctx->opcode), rt, rd, sa,
6343                            (imm >> 8) & 0x7);
6344                 break;
6345             default:
6346                 MIPS_INVAL("cp1");
6347                 generate_exception (ctx, EXCP_RI);
6348                 break;
6349             }
6350         } else {
6351             generate_exception_err(ctx, EXCP_CpU, 1);
6352         }
6353         break;
6354
6355     /* COP2.  */
6356     case OPC_LWC2:
6357     case OPC_LDC2:
6358     case OPC_SWC2:
6359     case OPC_SDC2:
6360     case OPC_CP2:
6361         /* COP2: Not implemented. */
6362         generate_exception_err(ctx, EXCP_CpU, 2);
6363         break;
6364
6365     case OPC_CP3:
6366         if (env->CP0_Config1 & (1 << CP0C1_FP)) {
6367             save_cpu_state(ctx, 1);
6368             check_cp1_enabled(ctx);
6369             op1 = MASK_CP3(ctx->opcode);
6370             switch (op1) {
6371             case OPC_LWXC1:
6372             case OPC_LDXC1:
6373             case OPC_LUXC1:
6374             case OPC_SWXC1:
6375             case OPC_SDXC1:
6376             case OPC_SUXC1:
6377                 gen_flt3_ldst(ctx, op1, sa, rd, rs, rt);
6378                 break;
6379             case OPC_PREFX:
6380                 /* Treat as NOP. */
6381                 break;
6382             case OPC_ALNV_PS:
6383             case OPC_MADD_S:
6384             case OPC_MADD_D:
6385             case OPC_MADD_PS:
6386             case OPC_MSUB_S:
6387             case OPC_MSUB_D:
6388             case OPC_MSUB_PS:
6389             case OPC_NMADD_S:
6390             case OPC_NMADD_D:
6391             case OPC_NMADD_PS:
6392             case OPC_NMSUB_S:
6393             case OPC_NMSUB_D:
6394             case OPC_NMSUB_PS:
6395                 gen_flt3_arith(ctx, op1, sa, rs, rd, rt);
6396                 break;
6397             default:
6398                 MIPS_INVAL("cp3");
6399                 generate_exception (ctx, EXCP_RI);
6400                 break;
6401             }
6402         } else {
6403             generate_exception_err(ctx, EXCP_CpU, 1);
6404         }
6405         break;
6406
6407 #if defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)
6408     /* MIPS64 opcodes */
6409     case OPC_LWU:
6410     case OPC_LDL ... OPC_LDR:
6411     case OPC_SDL ... OPC_SDR:
6412     case OPC_LLD:
6413     case OPC_LD:
6414     case OPC_SCD:
6415     case OPC_SD:
6416         check_insn(env, ctx, ISA_MIPS3);
6417         check_mips_64(ctx);
6418         gen_ldst(ctx, op, rt, rs, imm);
6419         break;
6420     case OPC_DADDI ... OPC_DADDIU:
6421         check_insn(env, ctx, ISA_MIPS3);
6422         check_mips_64(ctx);
6423         gen_arith_imm(env, ctx, op, rt, rs, imm);
6424         break;
6425 #endif
6426     case OPC_JALX:
6427         check_insn(env, ctx, ASE_MIPS16);
6428         /* MIPS16: Not implemented. */
6429     case OPC_MDMX:
6430         check_insn(env, ctx, ASE_MDMX);
6431         /* MDMX: Not implemented. */
6432     default:            /* Invalid */
6433         MIPS_INVAL("major opcode");
6434         generate_exception(ctx, EXCP_RI);
6435         break;
6436     }
6437     if (ctx->hflags & MIPS_HFLAG_BMASK) {
6438         int hflags = ctx->hflags & MIPS_HFLAG_BMASK;
6439         /* Branches completion */
6440         ctx->hflags &= ~MIPS_HFLAG_BMASK;
6441         ctx->bstate = BS_BRANCH;
6442         save_cpu_state(ctx, 0);
6443         switch (hflags) {
6444         case MIPS_HFLAG_B:
6445             /* unconditional branch */
6446             MIPS_DEBUG("unconditional branch");
6447             gen_goto_tb(ctx, 0, ctx->btarget);
6448             break;
6449         case MIPS_HFLAG_BL:
6450             /* blikely taken case */
6451             MIPS_DEBUG("blikely branch taken");
6452             gen_goto_tb(ctx, 0, ctx->btarget);
6453             break;
6454         case MIPS_HFLAG_BC:
6455             /* Conditional branch */
6456             MIPS_DEBUG("conditional branch");
6457             {
6458               int l1;
6459               l1 = gen_new_label();
6460               gen_op_jnz_T2(l1);
6461               gen_goto_tb(ctx, 1, ctx->pc + 4);
6462               gen_set_label(l1);
6463               gen_goto_tb(ctx, 0, ctx->btarget);
6464             }
6465             break;
6466         case MIPS_HFLAG_BR:
6467             /* unconditional branch to register */
6468             MIPS_DEBUG("branch to register");
6469             gen_op_breg();
6470             gen_op_reset_T0();
6471             gen_op_exit_tb();
6472             break;
6473         default:
6474             MIPS_DEBUG("unknown branch");
6475             break;
6476         }
6477     }
6478 }
6479
6480 static inline int
6481 gen_intermediate_code_internal (CPUState *env, TranslationBlock *tb,
6482                                 int search_pc)
6483 {
6484     DisasContext ctx;
6485     target_ulong pc_start;
6486     uint16_t *gen_opc_end;
6487     int j, lj = -1;
6488
6489     if (search_pc && loglevel)
6490         fprintf (logfile, "search pc %d\n", search_pc);
6491
6492     pc_start = tb->pc;
6493     gen_opc_ptr = gen_opc_buf;
6494     gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
6495     gen_opparam_ptr = gen_opparam_buf;
6496     nb_gen_labels = 0;
6497     ctx.pc = pc_start;
6498     ctx.saved_pc = -1;
6499     ctx.tb = tb;
6500     ctx.bstate = BS_NONE;
6501     /* Restore delay slot state from the tb context.  */
6502     ctx.hflags = (uint32_t)tb->flags; /* FIXME: maybe use 64 bits here? */
6503     restore_cpu_state(env, &ctx);
6504 #if defined(CONFIG_USER_ONLY)
6505     ctx.mem_idx = 0;
6506 #else
6507     ctx.mem_idx = !((ctx.hflags & MIPS_HFLAG_MODE) == MIPS_HFLAG_UM);
6508 #endif
6509 #ifdef DEBUG_DISAS
6510     if (loglevel & CPU_LOG_TB_CPU) {
6511         fprintf(logfile, "------------------------------------------------\n");
6512         /* FIXME: This may print out stale hflags from env... */
6513         cpu_dump_state(env, logfile, fprintf, 0);
6514     }
6515 #endif
6516 #ifdef MIPS_DEBUG_DISAS
6517     if (loglevel & CPU_LOG_TB_IN_ASM)
6518         fprintf(logfile, "\ntb %p super %d cond %04x\n",
6519                 tb, ctx.mem_idx, ctx.hflags);
6520 #endif
6521     while (ctx.bstate == BS_NONE && gen_opc_ptr < gen_opc_end) {
6522         if (env->nb_breakpoints > 0) {
6523             for(j = 0; j < env->nb_breakpoints; j++) {
6524                 if (env->breakpoints[j] == ctx.pc) {
6525                     save_cpu_state(&ctx, 1);
6526                     ctx.bstate = BS_BRANCH;
6527                     gen_op_debug();
6528                     /* Include the breakpoint location or the tb won't
6529                      * be flushed when it must be.  */
6530                     ctx.pc += 4;
6531                     goto done_generating;
6532                 }
6533             }
6534         }
6535
6536         if (search_pc) {
6537             j = gen_opc_ptr - gen_opc_buf;
6538             if (lj < j) {
6539                 lj++;
6540                 while (lj < j)
6541                     gen_opc_instr_start[lj++] = 0;
6542             }
6543             gen_opc_pc[lj] = ctx.pc;
6544             gen_opc_hflags[lj] = ctx.hflags & MIPS_HFLAG_BMASK;
6545             gen_opc_instr_start[lj] = 1;
6546         }
6547         ctx.opcode = ldl_code(ctx.pc);
6548         decode_opc(env, &ctx);
6549         ctx.pc += 4;
6550
6551         if (env->singlestep_enabled)
6552             break;
6553
6554         if ((ctx.pc & (TARGET_PAGE_SIZE - 1)) == 0)
6555             break;
6556
6557 #if defined (MIPS_SINGLE_STEP)
6558         break;
6559 #endif
6560     }
6561     if (env->singlestep_enabled) {
6562         save_cpu_state(&ctx, ctx.bstate == BS_NONE);
6563         gen_op_debug();
6564     } else {
6565         switch (ctx.bstate) {
6566         case BS_STOP:
6567             gen_op_interrupt_restart();
6568             gen_goto_tb(&ctx, 0, ctx.pc);
6569             break;
6570         case BS_NONE:
6571             save_cpu_state(&ctx, 0);
6572             gen_goto_tb(&ctx, 0, ctx.pc);
6573             break;
6574         case BS_EXCP:
6575             gen_op_interrupt_restart();
6576             gen_op_reset_T0();
6577             gen_op_exit_tb();
6578             break;
6579         case BS_BRANCH:
6580         default:
6581             break;
6582         }
6583     }
6584 done_generating:
6585     *gen_opc_ptr = INDEX_op_end;
6586     if (search_pc) {
6587         j = gen_opc_ptr - gen_opc_buf;
6588         lj++;
6589         while (lj <= j)
6590             gen_opc_instr_start[lj++] = 0;
6591     } else {
6592         tb->size = ctx.pc - pc_start;
6593     }
6594 #ifdef DEBUG_DISAS
6595 #if defined MIPS_DEBUG_DISAS
6596     if (loglevel & CPU_LOG_TB_IN_ASM)
6597         fprintf(logfile, "\n");
6598 #endif
6599     if (loglevel & CPU_LOG_TB_IN_ASM) {
6600         fprintf(logfile, "IN: %s\n", lookup_symbol(pc_start));
6601         target_disas(logfile, pc_start, ctx.pc - pc_start, 0);
6602         fprintf(logfile, "\n");
6603     }
6604     if (loglevel & CPU_LOG_TB_OP) {
6605         fprintf(logfile, "OP:\n");
6606         dump_ops(gen_opc_buf, gen_opparam_buf);
6607         fprintf(logfile, "\n");
6608     }
6609     if (loglevel & CPU_LOG_TB_CPU) {
6610         fprintf(logfile, "---------------- %d %08x\n", ctx.bstate, ctx.hflags);
6611     }
6612 #endif
6613
6614     return 0;
6615 }
6616
6617 int gen_intermediate_code (CPUState *env, struct TranslationBlock *tb)
6618 {
6619     return gen_intermediate_code_internal(env, tb, 0);
6620 }
6621
6622 int gen_intermediate_code_pc (CPUState *env, struct TranslationBlock *tb)
6623 {
6624     return gen_intermediate_code_internal(env, tb, 1);
6625 }
6626
6627 void fpu_dump_state(CPUState *env, FILE *f,
6628                     int (*fpu_fprintf)(FILE *f, const char *fmt, ...),
6629                     int flags)
6630 {
6631     int i;
6632     int is_fpu64 = !!(env->hflags & MIPS_HFLAG_F64);
6633
6634 #define printfpr(fp)                                                        \
6635     do {                                                                    \
6636         if (is_fpu64)                                                       \
6637             fpu_fprintf(f, "w:%08x d:%016lx fd:%13g fs:%13g psu: %13g\n",   \
6638                         (fp)->w[FP_ENDIAN_IDX], (fp)->d, (fp)->fd,          \
6639                         (fp)->fs[FP_ENDIAN_IDX], (fp)->fs[!FP_ENDIAN_IDX]); \
6640         else {                                                              \
6641             fpr_t tmp;                                                      \
6642             tmp.w[FP_ENDIAN_IDX] = (fp)->w[FP_ENDIAN_IDX];                  \
6643             tmp.w[!FP_ENDIAN_IDX] = ((fp) + 1)->w[FP_ENDIAN_IDX];           \
6644             fpu_fprintf(f, "w:%08x d:%016lx fd:%13g fs:%13g psu:%13g\n",    \
6645                         tmp.w[FP_ENDIAN_IDX], tmp.d, tmp.fd,                \
6646                         tmp.fs[FP_ENDIAN_IDX], tmp.fs[!FP_ENDIAN_IDX]);     \
6647         }                                                                   \
6648     } while(0)
6649
6650
6651     fpu_fprintf(f, "CP1 FCR0 0x%08x  FCR31 0x%08x  SR.FR %d  fp_status 0x%08x(0x%02x)\n",
6652                 env->fpu->fcr0, env->fpu->fcr31, is_fpu64, env->fpu->fp_status,
6653                 get_float_exception_flags(&env->fpu->fp_status));
6654     fpu_fprintf(f, "FT0: "); printfpr(&env->fpu->ft0);
6655     fpu_fprintf(f, "FT1: "); printfpr(&env->fpu->ft1);
6656     fpu_fprintf(f, "FT2: "); printfpr(&env->fpu->ft2);
6657     for (i = 0; i < 32; (is_fpu64) ? i++ : (i += 2)) {
6658         fpu_fprintf(f, "%3s: ", fregnames[i]);
6659         printfpr(&env->fpu->fpr[i]);
6660     }
6661
6662 #undef printfpr
6663 }
6664
6665 void dump_fpu (CPUState *env)
6666 {
6667     if (loglevel) {
6668        fprintf(logfile, "pc=0x" TARGET_FMT_lx " HI=0x" TARGET_FMT_lx " LO=0x" TARGET_FMT_lx " ds %04x " TARGET_FMT_lx " %d\n",
6669                env->PC[env->current_tc], env->HI[0][env->current_tc], env->LO[0][env->current_tc], env->hflags, env->btarget, env->bcond);
6670        fpu_dump_state(env, logfile, fprintf, 0);
6671     }
6672 }
6673
6674 #if (defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)) && defined(MIPS_DEBUG_SIGN_EXTENSIONS)
6675 /* Debug help: The architecture requires 32bit code to maintain proper
6676    sign-extened values on 64bit machines.  */
6677
6678 #define SIGN_EXT_P(val) ((((val) & ~0x7fffffff) == 0) || (((val) & ~0x7fffffff) == ~0x7fffffff))
6679
6680 void cpu_mips_check_sign_extensions (CPUState *env, FILE *f,
6681                      int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
6682                      int flags)
6683 {
6684     int i;
6685
6686     if (!SIGN_EXT_P(env->PC[env->current_tc]))
6687         cpu_fprintf(f, "BROKEN: pc=0x" TARGET_FMT_lx "\n", env->PC[env->current_tc]);
6688     if (!SIGN_EXT_P(env->HI[env->current_tc]))
6689         cpu_fprintf(f, "BROKEN: HI=0x" TARGET_FMT_lx "\n", env->HI[env->current_tc]);
6690     if (!SIGN_EXT_P(env->LO[env->current_tc]))
6691         cpu_fprintf(f, "BROKEN: LO=0x" TARGET_FMT_lx "\n", env->LO[env->current_tc]);
6692     if (!SIGN_EXT_P(env->btarget))
6693         cpu_fprintf(f, "BROKEN: btarget=0x" TARGET_FMT_lx "\n", env->btarget);
6694
6695     for (i = 0; i < 32; i++) {
6696         if (!SIGN_EXT_P(env->gpr[i][env->current_tc]))
6697             cpu_fprintf(f, "BROKEN: %s=0x" TARGET_FMT_lx "\n", regnames[i], env->gpr[i][env->current_tc]);
6698     }
6699
6700     if (!SIGN_EXT_P(env->CP0_EPC))
6701         cpu_fprintf(f, "BROKEN: EPC=0x" TARGET_FMT_lx "\n", env->CP0_EPC);
6702     if (!SIGN_EXT_P(env->CP0_LLAddr))
6703         cpu_fprintf(f, "BROKEN: LLAddr=0x" TARGET_FMT_lx "\n", env->CP0_LLAddr);
6704 }
6705 #endif
6706
6707 void cpu_dump_state (CPUState *env, FILE *f,
6708                      int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
6709                      int flags)
6710 {
6711     int i;
6712
6713     cpu_fprintf(f, "pc=0x" TARGET_FMT_lx " HI=0x" TARGET_FMT_lx " LO=0x" TARGET_FMT_lx " ds %04x " TARGET_FMT_lx " %d\n",
6714                 env->PC[env->current_tc], env->HI[env->current_tc], env->LO[env->current_tc], env->hflags, env->btarget, env->bcond);
6715     for (i = 0; i < 32; i++) {
6716         if ((i & 3) == 0)
6717             cpu_fprintf(f, "GPR%02d:", i);
6718         cpu_fprintf(f, " %s " TARGET_FMT_lx, regnames[i], env->gpr[i][env->current_tc]);
6719         if ((i & 3) == 3)
6720             cpu_fprintf(f, "\n");
6721     }
6722
6723     cpu_fprintf(f, "CP0 Status  0x%08x Cause   0x%08x EPC    0x" TARGET_FMT_lx "\n",
6724                 env->CP0_Status, env->CP0_Cause, env->CP0_EPC);
6725     cpu_fprintf(f, "    Config0 0x%08x Config1 0x%08x LLAddr 0x" TARGET_FMT_lx "\n",
6726                 env->CP0_Config0, env->CP0_Config1, env->CP0_LLAddr);
6727     if (env->hflags & MIPS_HFLAG_FPU)
6728         fpu_dump_state(env, f, cpu_fprintf, flags);
6729 #if (defined(TARGET_MIPSN32) || defined(TARGET_MIPS64)) && defined(MIPS_DEBUG_SIGN_EXTENSIONS)
6730     cpu_mips_check_sign_extensions(env, f, cpu_fprintf, flags);
6731 #endif
6732 }
6733
6734 CPUMIPSState *cpu_mips_init (void)
6735 {
6736     CPUMIPSState *env;
6737
6738     env = qemu_mallocz(sizeof(CPUMIPSState));
6739     if (!env)
6740         return NULL;
6741     cpu_exec_init(env);
6742     cpu_reset(env);
6743     return env;
6744 }
6745
6746 void cpu_reset (CPUMIPSState *env)
6747 {
6748     memset(env, 0, offsetof(CPUMIPSState, breakpoints));
6749
6750     tlb_flush(env, 1);
6751
6752     /* Minimal init */
6753 #if !defined(CONFIG_USER_ONLY)
6754     if (env->hflags & MIPS_HFLAG_BMASK) {
6755         /* If the exception was raised from a delay slot,
6756          * come back to the jump.  */
6757         env->CP0_ErrorEPC = env->PC[env->current_tc] - 4;
6758     } else {
6759         env->CP0_ErrorEPC = env->PC[env->current_tc];
6760     }
6761     env->PC[env->current_tc] = (int32_t)0xBFC00000;
6762     env->CP0_Wired = 0;
6763     /* SMP not implemented */
6764     env->CP0_EBase = 0x80000000;
6765     env->CP0_Status = (1 << CP0St_BEV) | (1 << CP0St_ERL);
6766     /* vectored interrupts not implemented, timer on int 7,
6767        no performance counters. */
6768     env->CP0_IntCtl = 0xe0000000;
6769     {
6770         int i;
6771
6772         for (i = 0; i < 7; i++) {
6773             env->CP0_WatchLo[i] = 0;
6774             env->CP0_WatchHi[i] = 0x80000000;
6775         }
6776         env->CP0_WatchLo[7] = 0;
6777         env->CP0_WatchHi[7] = 0;
6778     }
6779     /* Count register increments in debug mode, EJTAG version 1 */
6780     env->CP0_Debug = (1 << CP0DB_CNT) | (0x1 << CP0DB_VER);
6781 #endif
6782     env->exception_index = EXCP_NONE;
6783 #if defined(CONFIG_USER_ONLY)
6784     env->hflags = MIPS_HFLAG_UM;
6785     env->user_mode_only = 1;
6786 #else
6787     env->hflags = MIPS_HFLAG_CP0;
6788 #endif
6789 }
6790
6791 #include "translate_init.c"