vcs.maemo.org Git - qemu/blob - 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., 51 Franklin Street, Fifth Floor, Boston MA  02110-1301 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 #include "tcg-op.h"
  33 #include "qemu-common.h"
  34
  35 #include "helper.h"
  36 #define GEN_HELPER 1
  37 #include "helper.h"
  38
  39 //#define MIPS_DEBUG_DISAS
  40 //#define MIPS_DEBUG_SIGN_EXTENSIONS
  41 //#define MIPS_SINGLE_STEP
  42
  43 /* MIPS major opcodes */
  44 #define MASK_OP_MAJOR(op)  (op & (0x3F << 26))
  45
  46 enum {
  47     /* indirect opcode tables */
  48     OPC_SPECIAL  = (0x00 << 26),
  49     OPC_REGIMM   = (0x01 << 26),
  50     OPC_CP0      = (0x10 << 26),
  51     OPC_CP1      = (0x11 << 26),
  52     OPC_CP2      = (0x12 << 26),
  53     OPC_CP3      = (0x13 << 26),
  54     OPC_SPECIAL2 = (0x1C << 26),
  55     OPC_SPECIAL3 = (0x1F << 26),
  56     /* arithmetic with immediate */
  57     OPC_ADDI     = (0x08 << 26),
  58     OPC_ADDIU    = (0x09 << 26),
  59     OPC_SLTI     = (0x0A << 26),
  60     OPC_SLTIU    = (0x0B << 26),
  61     OPC_ANDI     = (0x0C << 26),
  62     OPC_ORI      = (0x0D << 26),
  63     OPC_XORI     = (0x0E << 26),
  64     OPC_LUI      = (0x0F << 26),
  65     OPC_DADDI    = (0x18 << 26),
  66     OPC_DADDIU   = (0x19 << 26),
  67     /* Jump and branches */
  68     OPC_J        = (0x02 << 26),
  69     OPC_JAL      = (0x03 << 26),
  70     OPC_BEQ      = (0x04 << 26),  /* Unconditional if rs = rt = 0 (B) */
  71     OPC_BEQL     = (0x14 << 26),
  72     OPC_BNE      = (0x05 << 26),
  73     OPC_BNEL     = (0x15 << 26),
  74     OPC_BLEZ     = (0x06 << 26),
  75     OPC_BLEZL    = (0x16 << 26),
  76     OPC_BGTZ     = (0x07 << 26),
  77     OPC_BGTZL    = (0x17 << 26),
  78     OPC_JALX     = (0x1D << 26),  /* MIPS 16 only */
  79     /* Load and stores */
  80     OPC_LDL      = (0x1A << 26),
  81     OPC_LDR      = (0x1B << 26),
  82     OPC_LB       = (0x20 << 26),
  83     OPC_LH       = (0x21 << 26),
  84     OPC_LWL      = (0x22 << 26),
  85     OPC_LW       = (0x23 << 26),
  86     OPC_LBU      = (0x24 << 26),
  87     OPC_LHU      = (0x25 << 26),
  88     OPC_LWR      = (0x26 << 26),
  89     OPC_LWU      = (0x27 << 26),
  90     OPC_SB       = (0x28 << 26),
  91     OPC_SH       = (0x29 << 26),
  92     OPC_SWL      = (0x2A << 26),
  93     OPC_SW       = (0x2B << 26),
  94     OPC_SDL      = (0x2C << 26),
  95     OPC_SDR      = (0x2D << 26),
  96     OPC_SWR      = (0x2E << 26),
  97     OPC_LL       = (0x30 << 26),
  98     OPC_LLD      = (0x34 << 26),
  99     OPC_LD       = (0x37 << 26),
 100     OPC_SC       = (0x38 << 26),
 101     OPC_SCD      = (0x3C << 26),
 102     OPC_SD       = (0x3F << 26),
 103     /* Floating point load/store */
 104     OPC_LWC1     = (0x31 << 26),
 105     OPC_LWC2     = (0x32 << 26),
 106     OPC_LDC1     = (0x35 << 26),
 107     OPC_LDC2     = (0x36 << 26),
 108     OPC_SWC1     = (0x39 << 26),
 109     OPC_SWC2     = (0x3A << 26),
 110     OPC_SDC1     = (0x3D << 26),
 111     OPC_SDC2     = (0x3E << 26),
 112     /* MDMX ASE specific */
 113     OPC_MDMX     = (0x1E << 26),
 114     /* Cache and prefetch */
 115     OPC_CACHE    = (0x2F << 26),
 116     OPC_PREF     = (0x33 << 26),
 117     /* Reserved major opcode */
 118     OPC_MAJOR3B_RESERVED = (0x3B << 26),
 119 };
 120
 121 /* MIPS special opcodes */
 122 #define MASK_SPECIAL(op)   MASK_OP_MAJOR(op) | (op & 0x3F)
 123
 124 enum {
 125     /* Shifts */
 126     OPC_SLL      = 0x00 | OPC_SPECIAL,
 127     /* NOP is SLL r0, r0, 0   */
 128     /* SSNOP is SLL r0, r0, 1 */
 129     /* EHB is SLL r0, r0, 3 */
 130     OPC_SRL      = 0x02 | OPC_SPECIAL, /* also ROTR */
 131     OPC_SRA      = 0x03 | OPC_SPECIAL,
 132     OPC_SLLV     = 0x04 | OPC_SPECIAL,
 133     OPC_SRLV     = 0x06 | OPC_SPECIAL, /* also ROTRV */
 134     OPC_SRAV     = 0x07 | OPC_SPECIAL,
 135     OPC_DSLLV    = 0x14 | OPC_SPECIAL,
 136     OPC_DSRLV    = 0x16 | OPC_SPECIAL, /* also DROTRV */
 137     OPC_DSRAV    = 0x17 | OPC_SPECIAL,
 138     OPC_DSLL     = 0x38 | OPC_SPECIAL,
 139     OPC_DSRL     = 0x3A | OPC_SPECIAL, /* also DROTR */
 140     OPC_DSRA     = 0x3B | OPC_SPECIAL,
 141     OPC_DSLL32   = 0x3C | OPC_SPECIAL,
 142     OPC_DSRL32   = 0x3E | OPC_SPECIAL, /* also DROTR32 */
 143     OPC_DSRA32   = 0x3F | OPC_SPECIAL,
 144     /* Multiplication / division */
 145     OPC_MULT     = 0x18 | OPC_SPECIAL,
 146     OPC_MULTU    = 0x19 | OPC_SPECIAL,
 147     OPC_DIV      = 0x1A | OPC_SPECIAL,
 148     OPC_DIVU     = 0x1B | OPC_SPECIAL,
 149     OPC_DMULT    = 0x1C | OPC_SPECIAL,
 150     OPC_DMULTU   = 0x1D | OPC_SPECIAL,
 151     OPC_DDIV     = 0x1E | OPC_SPECIAL,
 152     OPC_DDIVU    = 0x1F | OPC_SPECIAL,
 153     /* 2 registers arithmetic / logic */
 154     OPC_ADD      = 0x20 | OPC_SPECIAL,
 155     OPC_ADDU     = 0x21 | OPC_SPECIAL,
 156     OPC_SUB      = 0x22 | OPC_SPECIAL,
 157     OPC_SUBU     = 0x23 | OPC_SPECIAL,
 158     OPC_AND      = 0x24 | OPC_SPECIAL,
 159     OPC_OR       = 0x25 | OPC_SPECIAL,
 160     OPC_XOR      = 0x26 | OPC_SPECIAL,
 161     OPC_NOR      = 0x27 | OPC_SPECIAL,
 162     OPC_SLT      = 0x2A | OPC_SPECIAL,
 163     OPC_SLTU     = 0x2B | OPC_SPECIAL,
 164     OPC_DADD     = 0x2C | OPC_SPECIAL,
 165     OPC_DADDU    = 0x2D | OPC_SPECIAL,
 166     OPC_DSUB     = 0x2E | OPC_SPECIAL,
 167     OPC_DSUBU    = 0x2F | OPC_SPECIAL,
 168     /* Jumps */
 169     OPC_JR       = 0x08 | OPC_SPECIAL, /* Also JR.HB */
 170     OPC_JALR     = 0x09 | OPC_SPECIAL, /* Also JALR.HB */
 171     /* Traps */
 172     OPC_TGE      = 0x30 | OPC_SPECIAL,
 173     OPC_TGEU     = 0x31 | OPC_SPECIAL,
 174     OPC_TLT      = 0x32 | OPC_SPECIAL,
 175     OPC_TLTU     = 0x33 | OPC_SPECIAL,
 176     OPC_TEQ      = 0x34 | OPC_SPECIAL,
 177     OPC_TNE      = 0x36 | OPC_SPECIAL,
 178     /* HI / LO registers load & stores */
 179     OPC_MFHI     = 0x10 | OPC_SPECIAL,
 180     OPC_MTHI     = 0x11 | OPC_SPECIAL,
 181     OPC_MFLO     = 0x12 | OPC_SPECIAL,
 182     OPC_MTLO     = 0x13 | OPC_SPECIAL,
 183     /* Conditional moves */
 184     OPC_MOVZ     = 0x0A | OPC_SPECIAL,
 185     OPC_MOVN     = 0x0B | OPC_SPECIAL,
 186
 187     OPC_MOVCI    = 0x01 | OPC_SPECIAL,
 188
 189     /* Special */
 190     OPC_PMON     = 0x05 | OPC_SPECIAL, /* inofficial */
 191     OPC_SYSCALL  = 0x0C | OPC_SPECIAL,
 192     OPC_BREAK    = 0x0D | OPC_SPECIAL,
 193     OPC_SPIM     = 0x0E | OPC_SPECIAL, /* inofficial */
 194     OPC_SYNC     = 0x0F | OPC_SPECIAL,
 195
 196     OPC_SPECIAL15_RESERVED = 0x15 | OPC_SPECIAL,
 197     OPC_SPECIAL28_RESERVED = 0x28 | OPC_SPECIAL,
 198     OPC_SPECIAL29_RESERVED = 0x29 | OPC_SPECIAL,
 199     OPC_SPECIAL35_RESERVED = 0x35 | OPC_SPECIAL,
 200     OPC_SPECIAL37_RESERVED = 0x37 | OPC_SPECIAL,
 201     OPC_SPECIAL39_RESERVED = 0x39 | OPC_SPECIAL,
 202     OPC_SPECIAL3D_RESERVED = 0x3D | OPC_SPECIAL,
 203 };
 204
 205 /* Multiplication variants of the vr54xx. */
 206 #define MASK_MUL_VR54XX(op)   MASK_SPECIAL(op) | (op & (0x1F << 6))
 207
 208 enum {
 209     OPC_VR54XX_MULS    = (0x03 << 6) | OPC_MULT,
 210     OPC_VR54XX_MULSU   = (0x03 << 6) | OPC_MULTU,
 211     OPC_VR54XX_MACC    = (0x05 << 6) | OPC_MULT,
 212     OPC_VR54XX_MACCU   = (0x05 << 6) | OPC_MULTU,
 213     OPC_VR54XX_MSAC    = (0x07 << 6) | OPC_MULT,
 214     OPC_VR54XX_MSACU   = (0x07 << 6) | OPC_MULTU,
 215     OPC_VR54XX_MULHI   = (0x09 << 6) | OPC_MULT,
 216     OPC_VR54XX_MULHIU  = (0x09 << 6) | OPC_MULTU,
 217     OPC_VR54XX_MULSHI  = (0x0B << 6) | OPC_MULT,
 218     OPC_VR54XX_MULSHIU = (0x0B << 6) | OPC_MULTU,
 219     OPC_VR54XX_MACCHI  = (0x0D << 6) | OPC_MULT,
 220     OPC_VR54XX_MACCHIU = (0x0D << 6) | OPC_MULTU,
 221     OPC_VR54XX_MSACHI  = (0x0F << 6) | OPC_MULT,
 222     OPC_VR54XX_MSACHIU = (0x0F << 6) | OPC_MULTU,
 223 };
 224
 225 /* REGIMM (rt field) opcodes */
 226 #define MASK_REGIMM(op)    MASK_OP_MAJOR(op) | (op & (0x1F << 16))
 227
 228 enum {
 229     OPC_BLTZ     = (0x00 << 16) | OPC_REGIMM,
 230     OPC_BLTZL    = (0x02 << 16) | OPC_REGIMM,
 231     OPC_BGEZ     = (0x01 << 16) | OPC_REGIMM,
 232     OPC_BGEZL    = (0x03 << 16) | OPC_REGIMM,
 233     OPC_BLTZAL   = (0x10 << 16) | OPC_REGIMM,
 234     OPC_BLTZALL  = (0x12 << 16) | OPC_REGIMM,
 235     OPC_BGEZAL   = (0x11 << 16) | OPC_REGIMM,
 236     OPC_BGEZALL  = (0x13 << 16) | OPC_REGIMM,
 237     OPC_TGEI     = (0x08 << 16) | OPC_REGIMM,
 238     OPC_TGEIU    = (0x09 << 16) | OPC_REGIMM,
 239     OPC_TLTI     = (0x0A << 16) | OPC_REGIMM,
 240     OPC_TLTIU    = (0x0B << 16) | OPC_REGIMM,
 241     OPC_TEQI     = (0x0C << 16) | OPC_REGIMM,
 242     OPC_TNEI     = (0x0E << 16) | OPC_REGIMM,
 243     OPC_SYNCI    = (0x1F << 16) | OPC_REGIMM,
 244 };
 245
 246 /* Special2 opcodes */
 247 #define MASK_SPECIAL2(op)  MASK_OP_MAJOR(op) | (op & 0x3F)
 248
 249 enum {
 250     /* Multiply & xxx operations */
 251     OPC_MADD     = 0x00 | OPC_SPECIAL2,
 252     OPC_MADDU    = 0x01 | OPC_SPECIAL2,
 253     OPC_MUL      = 0x02 | OPC_SPECIAL2,
 254     OPC_MSUB     = 0x04 | OPC_SPECIAL2,
 255     OPC_MSUBU    = 0x05 | OPC_SPECIAL2,
 256     /* Misc */
 257     OPC_CLZ      = 0x20 | OPC_SPECIAL2,
 258     OPC_CLO      = 0x21 | OPC_SPECIAL2,
 259     OPC_DCLZ     = 0x24 | OPC_SPECIAL2,
 260     OPC_DCLO     = 0x25 | OPC_SPECIAL2,
 261     /* Special */
 262     OPC_SDBBP    = 0x3F | OPC_SPECIAL2,
 263 };
 264
 265 /* Special3 opcodes */
 266 #define MASK_SPECIAL3(op)  MASK_OP_MAJOR(op) | (op & 0x3F)
 267
 268 enum {
 269     OPC_EXT      = 0x00 | OPC_SPECIAL3,
 270     OPC_DEXTM    = 0x01 | OPC_SPECIAL3,
 271     OPC_DEXTU    = 0x02 | OPC_SPECIAL3,
 272     OPC_DEXT     = 0x03 | OPC_SPECIAL3,
 273     OPC_INS      = 0x04 | OPC_SPECIAL3,
 274     OPC_DINSM    = 0x05 | OPC_SPECIAL3,
 275     OPC_DINSU    = 0x06 | OPC_SPECIAL3,
 276     OPC_DINS     = 0x07 | OPC_SPECIAL3,
 277     OPC_FORK     = 0x08 | OPC_SPECIAL3,
 278     OPC_YIELD    = 0x09 | OPC_SPECIAL3,
 279     OPC_BSHFL    = 0x20 | OPC_SPECIAL3,
 280     OPC_DBSHFL   = 0x24 | OPC_SPECIAL3,
 281     OPC_RDHWR    = 0x3B | OPC_SPECIAL3,
 282 };
 283
 284 /* BSHFL opcodes */
 285 #define MASK_BSHFL(op)     MASK_SPECIAL3(op) | (op & (0x1F << 6))
 286
 287 enum {
 288     OPC_WSBH     = (0x02 << 6) | OPC_BSHFL,
 289     OPC_SEB      = (0x10 << 6) | OPC_BSHFL,
 290     OPC_SEH      = (0x18 << 6) | OPC_BSHFL,
 291 };
 292
 293 /* DBSHFL opcodes */
 294 #define MASK_DBSHFL(op)    MASK_SPECIAL3(op) | (op & (0x1F << 6))
 295
 296 enum {
 297     OPC_DSBH     = (0x02 << 6) | OPC_DBSHFL,
 298     OPC_DSHD     = (0x05 << 6) | OPC_DBSHFL,
 299 };
 300
 301 /* Coprocessor 0 (rs field) */
 302 #define MASK_CP0(op)       MASK_OP_MAJOR(op) | (op & (0x1F << 21))
 303
 304 enum {
 305     OPC_MFC0     = (0x00 << 21) | OPC_CP0,
 306     OPC_DMFC0    = (0x01 << 21) | OPC_CP0,
 307     OPC_MTC0     = (0x04 << 21) | OPC_CP0,
 308     OPC_DMTC0    = (0x05 << 21) | OPC_CP0,
 309     OPC_MFTR     = (0x08 << 21) | OPC_CP0,
 310     OPC_RDPGPR   = (0x0A << 21) | OPC_CP0,
 311     OPC_MFMC0    = (0x0B << 21) | OPC_CP0,
 312     OPC_MTTR     = (0x0C << 21) | OPC_CP0,
 313     OPC_WRPGPR   = (0x0E << 21) | OPC_CP0,
 314     OPC_C0       = (0x10 << 21) | OPC_CP0,
 315     OPC_C0_FIRST = (0x10 << 21) | OPC_CP0,
 316     OPC_C0_LAST  = (0x1F << 21) | OPC_CP0,
 317 };
 318
 319 /* MFMC0 opcodes */
 320 #define MASK_MFMC0(op)     MASK_CP0(op) | (op & 0xFFFF)
 321
 322 enum {
 323     OPC_DMT      = 0x01 | (0 << 5) | (0x0F << 6) | (0x01 << 11) | OPC_MFMC0,
 324     OPC_EMT      = 0x01 | (1 << 5) | (0x0F << 6) | (0x01 << 11) | OPC_MFMC0,
 325     OPC_DVPE     = 0x01 | (0 << 5) | OPC_MFMC0,
 326     OPC_EVPE     = 0x01 | (1 << 5) | OPC_MFMC0,
 327     OPC_DI       = (0 << 5) | (0x0C << 11) | OPC_MFMC0,
 328     OPC_EI       = (1 << 5) | (0x0C << 11) | OPC_MFMC0,
 329 };
 330
 331 /* Coprocessor 0 (with rs == C0) */
 332 #define MASK_C0(op)        MASK_CP0(op) | (op & 0x3F)
 333
 334 enum {
 335     OPC_TLBR     = 0x01 | OPC_C0,
 336     OPC_TLBWI    = 0x02 | OPC_C0,
 337     OPC_TLBWR    = 0x06 | OPC_C0,
 338     OPC_TLBP     = 0x08 | OPC_C0,
 339     OPC_RFE      = 0x10 | OPC_C0,
 340     OPC_ERET     = 0x18 | OPC_C0,
 341     OPC_DERET    = 0x1F | OPC_C0,
 342     OPC_WAIT     = 0x20 | OPC_C0,
 343 };
 344
 345 /* Coprocessor 1 (rs field) */
 346 #define MASK_CP1(op)       MASK_OP_MAJOR(op) | (op & (0x1F << 21))
 347
 348 enum {
 349     OPC_MFC1     = (0x00 << 21) | OPC_CP1,
 350     OPC_DMFC1    = (0x01 << 21) | OPC_CP1,
 351     OPC_CFC1     = (0x02 << 21) | OPC_CP1,
 352     OPC_MFHC1    = (0x03 << 21) | OPC_CP1,
 353     OPC_MTC1     = (0x04 << 21) | OPC_CP1,
 354     OPC_DMTC1    = (0x05 << 21) | OPC_CP1,
 355     OPC_CTC1     = (0x06 << 21) | OPC_CP1,
 356     OPC_MTHC1    = (0x07 << 21) | OPC_CP1,
 357     OPC_BC1      = (0x08 << 21) | OPC_CP1, /* bc */
 358     OPC_BC1ANY2  = (0x09 << 21) | OPC_CP1,
 359     OPC_BC1ANY4  = (0x0A << 21) | OPC_CP1,
 360     OPC_S_FMT    = (0x10 << 21) | OPC_CP1, /* 16: fmt=single fp */
 361     OPC_D_FMT    = (0x11 << 21) | OPC_CP1, /* 17: fmt=double fp */
 362     OPC_E_FMT    = (0x12 << 21) | OPC_CP1, /* 18: fmt=extended fp */
 363     OPC_Q_FMT    = (0x13 << 21) | OPC_CP1, /* 19: fmt=quad fp */
 364     OPC_W_FMT    = (0x14 << 21) | OPC_CP1, /* 20: fmt=32bit fixed */
 365     OPC_L_FMT    = (0x15 << 21) | OPC_CP1, /* 21: fmt=64bit fixed */
 366     OPC_PS_FMT   = (0x16 << 21) | OPC_CP1, /* 22: fmt=paired single fp */
 367 };
 368
 369 #define MASK_CP1_FUNC(op)       MASK_CP1(op) | (op & 0x3F)
 370 #define MASK_BC1(op)            MASK_CP1(op) | (op & (0x3 << 16))
 371
 372 enum {
 373     OPC_BC1F     = (0x00 << 16) | OPC_BC1,
 374     OPC_BC1T     = (0x01 << 16) | OPC_BC1,
 375     OPC_BC1FL    = (0x02 << 16) | OPC_BC1,
 376     OPC_BC1TL    = (0x03 << 16) | OPC_BC1,
 377 };
 378
 379 enum {
 380     OPC_BC1FANY2     = (0x00 << 16) | OPC_BC1ANY2,
 381     OPC_BC1TANY2     = (0x01 << 16) | OPC_BC1ANY2,
 382 };
 383
 384 enum {
 385     OPC_BC1FANY4     = (0x00 << 16) | OPC_BC1ANY4,
 386     OPC_BC1TANY4     = (0x01 << 16) | OPC_BC1ANY4,
 387 };
 388
 389 #define MASK_CP2(op)       MASK_OP_MAJOR(op) | (op & (0x1F << 21))
 390
 391 enum {
 392     OPC_MFC2    = (0x00 << 21) | OPC_CP2,
 393     OPC_DMFC2   = (0x01 << 21) | OPC_CP2,
 394     OPC_CFC2    = (0x02 << 21) | OPC_CP2,
 395     OPC_MFHC2   = (0x03 << 21) | OPC_CP2,
 396     OPC_MTC2    = (0x04 << 21) | OPC_CP2,
 397     OPC_DMTC2   = (0x05 << 21) | OPC_CP2,
 398     OPC_CTC2    = (0x06 << 21) | OPC_CP2,
 399     OPC_MTHC2   = (0x07 << 21) | OPC_CP2,
 400     OPC_BC2     = (0x08 << 21) | OPC_CP2,
 401 };
 402
 403 #define MASK_CP3(op)       MASK_OP_MAJOR(op) | (op & 0x3F)
 404
 405 enum {
 406     OPC_LWXC1   = 0x00 | OPC_CP3,
 407     OPC_LDXC1   = 0x01 | OPC_CP3,
 408     OPC_LUXC1   = 0x05 | OPC_CP3,
 409     OPC_SWXC1   = 0x08 | OPC_CP3,
 410     OPC_SDXC1   = 0x09 | OPC_CP3,
 411     OPC_SUXC1   = 0x0D | OPC_CP3,
 412     OPC_PREFX   = 0x0F | OPC_CP3,
 413     OPC_ALNV_PS = 0x1E | OPC_CP3,
 414     OPC_MADD_S  = 0x20 | OPC_CP3,
 415     OPC_MADD_D  = 0x21 | OPC_CP3,
 416     OPC_MADD_PS = 0x26 | OPC_CP3,
 417     OPC_MSUB_S  = 0x28 | OPC_CP3,
 418     OPC_MSUB_D  = 0x29 | OPC_CP3,
 419     OPC_MSUB_PS = 0x2E | OPC_CP3,
 420     OPC_NMADD_S = 0x30 | OPC_CP3,
 421     OPC_NMADD_D = 0x31 | OPC_CP3,
 422     OPC_NMADD_PS= 0x36 | OPC_CP3,
 423     OPC_NMSUB_S = 0x38 | OPC_CP3,
 424     OPC_NMSUB_D = 0x39 | OPC_CP3,
 425     OPC_NMSUB_PS= 0x3E | OPC_CP3,
 426 };
 427
 428 /* global register indices */
 429 static TCGv_ptr cpu_env;
 430 static TCGv cpu_gpr[32], cpu_PC;
 431 static TCGv cpu_HI[MIPS_DSP_ACC], cpu_LO[MIPS_DSP_ACC], cpu_ACX[MIPS_DSP_ACC];
 432 static TCGv cpu_dspctrl, btarget;
 433 static TCGv_i32 bcond;
 434 static TCGv_i32 fpu_fpr32[32], fpu_fpr32h[32];
 435 static TCGv_i64 fpu_fpr64[32];
 436 static TCGv_i32 fpu_fcr0, fpu_fcr31;
 437
 438 #include "gen-icount.h"
 439
 440 #define gen_helper_0i(name, arg) do {                             \
 441     TCGv_i32 helper_tmp = tcg_const_i32(arg);                     \
 442     gen_helper_##name(helper_tmp);                                \
 443     tcg_temp_free_i32(helper_tmp);                                \
 444     } while(0)
 445
 446 #define gen_helper_1i(name, arg1, arg2) do {                      \
 447     TCGv_i32 helper_tmp = tcg_const_i32(arg2);                    \
 448     gen_helper_##name(arg1, helper_tmp);                          \
 449     tcg_temp_free_i32(helper_tmp);                                \
 450     } while(0)
 451
 452 #define gen_helper_2i(name, arg1, arg2, arg3) do {                \
 453     TCGv_i32 helper_tmp = tcg_const_i32(arg3);                    \
 454     gen_helper_##name(arg1, arg2, helper_tmp);                    \
 455     tcg_temp_free_i32(helper_tmp);                                \
 456     } while(0)
 457
 458 #define gen_helper_3i(name, arg1, arg2, arg3, arg4) do {          \
 459     TCGv_i32 helper_tmp = tcg_const_i32(arg4);                    \
 460     gen_helper_##name(arg1, arg2, arg3, helper_tmp);              \
 461     tcg_temp_free_i32(helper_tmp);                                \
 462     } while(0)
 463
 464 typedef struct DisasContext {
 465     struct TranslationBlock *tb;
 466     target_ulong pc, saved_pc;
 467     uint32_t opcode;
 468     /* Routine used to access memory */
 469     int mem_idx;
 470     uint32_t hflags, saved_hflags;
 471     int bstate;
 472     target_ulong btarget;
 473 } DisasContext;
 474
 475 enum {
 476     BS_NONE     = 0, /* We go out of the TB without reaching a branch or an
 477                       * exception condition */
 478     BS_STOP     = 1, /* We want to stop translation for any reason */
 479     BS_BRANCH   = 2, /* We reached a branch condition     */
 480     BS_EXCP     = 3, /* We reached an exception condition */
 481 };
 482
 483 static const char *regnames[] =
 484     { "r0", "at", "v0", "v1", "a0", "a1", "a2", "a3",
 485       "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
 486       "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
 487       "t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra", };
 488
 489 static const char *regnames_HI[] =
 490     { "HI0", "HI1", "HI2", "HI3", };
 491
 492 static const char *regnames_LO[] =
 493     { "LO0", "LO1", "LO2", "LO3", };
 494
 495 static const char *regnames_ACX[] =
 496     { "ACX0", "ACX1", "ACX2", "ACX3", };
 497
 498 static const char *fregnames[] =
 499     { "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
 500       "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
 501       "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 502       "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", };
 503
 504 static const char *fregnames_64[] =
 505     { "F0",  "F1",  "F2",  "F3",  "F4",  "F5",  "F6",  "F7",
 506       "F8",  "F9",  "F10", "F11", "F12", "F13", "F14", "F15",
 507       "F16", "F17", "F18", "F19", "F20", "F21", "F22", "F23",
 508       "F24", "F25", "F26", "F27", "F28", "F29", "F30", "F31", };
 509
 510 static const char *fregnames_h[] =
 511     { "h0",  "h1",  "h2",  "h3",  "h4",  "h5",  "h6",  "h7",
 512       "h8",  "h9",  "h10", "h11", "h12", "h13", "h14", "h15",
 513       "h16", "h17", "h18", "h19", "h20", "h21", "h22", "h23",
 514       "h24", "h25", "h26", "h27", "h28", "h29", "h30", "h31", };
 515
 516 #ifdef MIPS_DEBUG_DISAS
 517 #define MIPS_DEBUG(fmt, args...)                         \
 518         qemu_log_mask(CPU_LOG_TB_IN_ASM,                \
 519                        TARGET_FMT_lx ": %08x " fmt "\n", \
 520                        ctx->pc, ctx->opcode , ##args)
 521 #define LOG_DISAS(...) qemu_log_mask(CPU_LOG_TB_IN_ASM, ## __VA_ARGS__)
 522 #else
 523 #define MIPS_DEBUG(fmt, args...) do { } while(0)
 524 #define LOG_DISAS(...) do { } while (0)
 525 #endif
 526
 527 #define MIPS_INVAL(op)                                                        \
 528 do {                                                                          \
 529     MIPS_DEBUG("Invalid %s %03x %03x %03x", op, ctx->opcode >> 26,            \
 530                ctx->opcode & 0x3F, ((ctx->opcode >> 16) & 0x1F));             \
 531 } while (0)
 532
 533 /* General purpose registers moves. */
 534 static inline void gen_load_gpr (TCGv t, int reg)
 535 {
 536     if (reg == 0)
 537         tcg_gen_movi_tl(t, 0);
 538     else
 539         tcg_gen_mov_tl(t, cpu_gpr[reg]);
 540 }
 541
 542 static inline void gen_store_gpr (TCGv t, int reg)
 543 {
 544     if (reg != 0)
 545         tcg_gen_mov_tl(cpu_gpr[reg], t);
 546 }
 547
 548 /* Moves to/from ACX register.  */
 549 static inline void gen_load_ACX (TCGv t, int reg)
 550 {
 551     tcg_gen_mov_tl(t, cpu_ACX[reg]);
 552 }
 553
 554 static inline void gen_store_ACX (TCGv t, int reg)
 555 {
 556     tcg_gen_mov_tl(cpu_ACX[reg], t);
 557 }
 558
 559 /* Moves to/from shadow registers. */
 560 static inline void gen_load_srsgpr (int from, int to)
 561 {
 562     TCGv r_tmp1 = tcg_temp_new();
 563
 564     if (from == 0)
 565         tcg_gen_movi_tl(r_tmp1, 0);
 566     else {
 567         TCGv_i32 r_tmp2 = tcg_temp_new_i32();
 568         TCGv_ptr addr = tcg_temp_new_ptr();
 569
 570         tcg_gen_ld_i32(r_tmp2, cpu_env, offsetof(CPUState, CP0_SRSCtl));
 571         tcg_gen_shri_i32(r_tmp2, r_tmp2, CP0SRSCtl_PSS);
 572         tcg_gen_andi_i32(r_tmp2, r_tmp2, 0xf);
 573         tcg_gen_muli_i32(r_tmp2, r_tmp2, sizeof(target_ulong) * 32);
 574         tcg_gen_ext_i32_ptr(addr, r_tmp2);
 575         tcg_gen_add_ptr(addr, cpu_env, addr);
 576
 577         tcg_gen_ld_tl(r_tmp1, addr, sizeof(target_ulong) * from);
 578         tcg_temp_free_ptr(addr);
 579         tcg_temp_free_i32(r_tmp2);
 580     }
 581     gen_store_gpr(r_tmp1, to);
 582     tcg_temp_free(r_tmp1);
 583 }
 584
 585 static inline void gen_store_srsgpr (int from, int to)
 586 {
 587     if (to != 0) {
 588         TCGv r_tmp1 = tcg_temp_new();
 589         TCGv_i32 r_tmp2 = tcg_temp_new_i32();
 590         TCGv_ptr addr = tcg_temp_new_ptr();
 591
 592         gen_load_gpr(r_tmp1, from);
 593         tcg_gen_ld_i32(r_tmp2, cpu_env, offsetof(CPUState, CP0_SRSCtl));
 594         tcg_gen_shri_i32(r_tmp2, r_tmp2, CP0SRSCtl_PSS);
 595         tcg_gen_andi_i32(r_tmp2, r_tmp2, 0xf);
 596         tcg_gen_muli_i32(r_tmp2, r_tmp2, sizeof(target_ulong) * 32);
 597         tcg_gen_ext_i32_ptr(addr, r_tmp2);
 598         tcg_gen_add_ptr(addr, cpu_env, addr);
 599
 600         tcg_gen_st_tl(r_tmp1, addr, sizeof(target_ulong) * to);
 601         tcg_temp_free_ptr(addr);
 602         tcg_temp_free_i32(r_tmp2);
 603         tcg_temp_free(r_tmp1);
 604     }
 605 }
 606
 607 /* Floating point register moves. */
 608 static inline void gen_load_fpr32 (TCGv_i32 t, int reg)
 609 {
 610     tcg_gen_mov_i32(t, fpu_fpr32[reg]);
 611 }
 612
 613 static inline void gen_store_fpr32 (TCGv_i32 t, int reg)
 614 {
 615     tcg_gen_mov_i32(fpu_fpr32[reg], t);
 616 }
 617
 618 static inline void gen_load_fpr64 (DisasContext *ctx, TCGv_i64 t, int reg)
 619 {
 620     if (ctx->hflags & MIPS_HFLAG_F64)
 621         tcg_gen_mov_i64(t, fpu_fpr64[reg]);
 622     else {
 623         tcg_gen_concat_i32_i64(t, fpu_fpr32[reg & ~1], fpu_fpr32[reg | 1]);
 624     }
 625 }
 626
 627 static inline void gen_store_fpr64 (DisasContext *ctx, TCGv_i64 t, int reg)
 628 {
 629     if (ctx->hflags & MIPS_HFLAG_F64)
 630         tcg_gen_mov_i64(fpu_fpr64[reg], t);
 631     else {
 632         tcg_gen_trunc_i64_i32(fpu_fpr32[reg & ~1], t);
 633         tcg_gen_shri_i64(t, t, 32);
 634         tcg_gen_trunc_i64_i32(fpu_fpr32[reg | 1], t);
 635     }
 636 }
 637
 638 static inline void gen_load_fpr32h (TCGv_i32 t, int reg)
 639 {
 640     tcg_gen_mov_i32(t, fpu_fpr32h[reg]);
 641 }
 642
 643 static inline void gen_store_fpr32h (TCGv_i32 t, int reg)
 644 {
 645     tcg_gen_mov_i32(fpu_fpr32h[reg], t);
 646 }
 647
 648 static inline void get_fp_cond (TCGv_i32 t)
 649 {
 650     TCGv_i32 r_tmp1 = tcg_temp_new_i32();
 651     TCGv_i32 r_tmp2 = tcg_temp_new_i32();
 652
 653     tcg_gen_shri_i32(r_tmp2, fpu_fcr31, 24);
 654     tcg_gen_andi_i32(r_tmp2, r_tmp2, 0xfe);
 655     tcg_gen_shri_i32(r_tmp1, fpu_fcr31, 23);
 656     tcg_gen_andi_i32(r_tmp1, r_tmp1, 0x1);
 657     tcg_gen_or_i32(t, r_tmp1, r_tmp2);
 658     tcg_temp_free_i32(r_tmp1);
 659     tcg_temp_free_i32(r_tmp2);
 660 }
 661
 662 #define FOP_CONDS(type, fmt, bits)                                            \
 663 static inline void gen_cmp ## type ## _ ## fmt(int n, TCGv_i##bits a,         \
 664                                                TCGv_i##bits b, int cc)        \
 665 {                                                                             \
 666     switch (n) {                                                              \
 667     case  0: gen_helper_2i(cmp ## type ## _ ## fmt ## _f, a, b, cc);    break;\
 668     case  1: gen_helper_2i(cmp ## type ## _ ## fmt ## _un, a, b, cc);   break;\
 669     case  2: gen_helper_2i(cmp ## type ## _ ## fmt ## _eq, a, b, cc);   break;\
 670     case  3: gen_helper_2i(cmp ## type ## _ ## fmt ## _ueq, a, b, cc);  break;\
 671     case  4: gen_helper_2i(cmp ## type ## _ ## fmt ## _olt, a, b, cc);  break;\
 672     case  5: gen_helper_2i(cmp ## type ## _ ## fmt ## _ult, a, b, cc);  break;\
 673     case  6: gen_helper_2i(cmp ## type ## _ ## fmt ## _ole, a, b, cc);  break;\
 674     case  7: gen_helper_2i(cmp ## type ## _ ## fmt ## _ule, a, b, cc);  break;\
 675     case  8: gen_helper_2i(cmp ## type ## _ ## fmt ## _sf, a, b, cc);   break;\
 676     case  9: gen_helper_2i(cmp ## type ## _ ## fmt ## _ngle, a, b, cc); break;\
 677     case 10: gen_helper_2i(cmp ## type ## _ ## fmt ## _seq, a, b, cc);  break;\
 678     case 11: gen_helper_2i(cmp ## type ## _ ## fmt ## _ngl, a, b, cc);  break;\
 679     case 12: gen_helper_2i(cmp ## type ## _ ## fmt ## _lt, a, b, cc);   break;\
 680     case 13: gen_helper_2i(cmp ## type ## _ ## fmt ## _nge, a, b, cc);  break;\
 681     case 14: gen_helper_2i(cmp ## type ## _ ## fmt ## _le, a, b, cc);   break;\
 682     case 15: gen_helper_2i(cmp ## type ## _ ## fmt ## _ngt, a, b, cc);  break;\
 683     default: abort();                                                         \
 684     }                                                                         \
 685 }
 686
 687 FOP_CONDS(, d, 64)
 688 FOP_CONDS(abs, d, 64)
 689 FOP_CONDS(, s, 32)
 690 FOP_CONDS(abs, s, 32)
 691 FOP_CONDS(, ps, 64)
 692 FOP_CONDS(abs, ps, 64)
 693 #undef FOP_CONDS
 694
 695 /* Tests */
 696 #define OP_COND(name, cond)                                   \
 697 static inline void glue(gen_op_, name) (TCGv t0, TCGv t1)     \
 698 {                                                             \
 699     int l1 = gen_new_label();                                 \
 700     int l2 = gen_new_label();                                 \
 701                                                               \
 702     tcg_gen_brcond_tl(cond, t0, t1, l1);                      \
 703     tcg_gen_movi_tl(t0, 0);                                   \
 704     tcg_gen_br(l2);                                           \
 705     gen_set_label(l1);                                        \
 706     tcg_gen_movi_tl(t0, 1);                                   \
 707     gen_set_label(l2);                                        \
 708 }
 709 OP_COND(eq, TCG_COND_EQ);
 710 OP_COND(ne, TCG_COND_NE);
 711 OP_COND(ge, TCG_COND_GE);
 712 OP_COND(geu, TCG_COND_GEU);
 713 OP_COND(lt, TCG_COND_LT);
 714 OP_COND(ltu, TCG_COND_LTU);
 715 #undef OP_COND
 716
 717 #define OP_CONDI(name, cond)                                  \
 718 static inline void glue(gen_op_, name) (TCGv t, target_ulong val) \
 719 {                                                             \
 720     int l1 = gen_new_label();                                 \
 721     int l2 = gen_new_label();                                 \
 722                                                               \
 723     tcg_gen_brcondi_tl(cond, t, val, l1);                     \
 724     tcg_gen_movi_tl(t, 0);                                    \
 725     tcg_gen_br(l2);                                           \
 726     gen_set_label(l1);                                        \
 727     tcg_gen_movi_tl(t, 1);                                    \
 728     gen_set_label(l2);                                        \
 729 }
 730 OP_CONDI(lti, TCG_COND_LT);
 731 OP_CONDI(ltiu, TCG_COND_LTU);
 732 #undef OP_CONDI
 733
 734 #define OP_CONDZ(name, cond)                                  \
 735 static inline void glue(gen_op_, name) (TCGv t)               \
 736 {                                                             \
 737     int l1 = gen_new_label();                                 \
 738     int l2 = gen_new_label();                                 \
 739                                                               \
 740     tcg_gen_brcondi_tl(cond, t, 0, l1);                       \
 741     tcg_gen_movi_tl(t, 0);                                    \
 742     tcg_gen_br(l2);                                           \
 743     gen_set_label(l1);                                        \
 744     tcg_gen_movi_tl(t, 1);                                    \
 745     gen_set_label(l2);                                        \
 746 }
 747 OP_CONDZ(gez, TCG_COND_GE);
 748 OP_CONDZ(gtz, TCG_COND_GT);
 749 OP_CONDZ(lez, TCG_COND_LE);
 750 OP_CONDZ(ltz, TCG_COND_LT);
 751 #undef OP_CONDZ
 752
 753 static inline void gen_save_pc(target_ulong pc)
 754 {
 755     tcg_gen_movi_tl(cpu_PC, pc);
 756 }
 757
 758 static inline void save_cpu_state (DisasContext *ctx, int do_save_pc)
 759 {
 760     LOG_DISAS("hflags %08x saved %08x\n", ctx->hflags, ctx->saved_hflags);
 761     if (do_save_pc && ctx->pc != ctx->saved_pc) {
 762         gen_save_pc(ctx->pc);
 763         ctx->saved_pc = ctx->pc;
 764     }
 765     if (ctx->hflags != ctx->saved_hflags) {
 766         TCGv_i32 r_tmp = tcg_temp_new_i32();
 767
 768         tcg_gen_movi_i32(r_tmp, ctx->hflags);
 769         tcg_gen_st_i32(r_tmp, cpu_env, offsetof(CPUState, hflags));
 770         tcg_temp_free_i32(r_tmp);
 771         ctx->saved_hflags = ctx->hflags;
 772         switch (ctx->hflags & MIPS_HFLAG_BMASK) {
 773         case MIPS_HFLAG_BR:
 774             break;
 775         case MIPS_HFLAG_BC:
 776         case MIPS_HFLAG_BL:
 777         case MIPS_HFLAG_B:
 778             tcg_gen_movi_tl(btarget, ctx->btarget);
 779             break;
 780         }
 781     }
 782 }
 783
 784 static inline void restore_cpu_state (CPUState *env, DisasContext *ctx)
 785 {
 786     ctx->saved_hflags = ctx->hflags;
 787     switch (ctx->hflags & MIPS_HFLAG_BMASK) {
 788     case MIPS_HFLAG_BR:
 789         break;
 790     case MIPS_HFLAG_BC:
 791     case MIPS_HFLAG_BL:
 792     case MIPS_HFLAG_B:
 793         ctx->btarget = env->btarget;
 794         break;
 795     }
 796 }
 797
 798 static inline void
 799 generate_exception_err (DisasContext *ctx, int excp, int err)
 800 {
 801     TCGv_i32 texcp = tcg_const_i32(excp);
 802     TCGv_i32 terr = tcg_const_i32(err);
 803     save_cpu_state(ctx, 1);
 804     gen_helper_raise_exception_err(texcp, terr);
 805     tcg_temp_free_i32(terr);
 806     tcg_temp_free_i32(texcp);
 807     gen_helper_interrupt_restart();
 808     tcg_gen_exit_tb(0);
 809 }
 810
 811 static inline void
 812 generate_exception (DisasContext *ctx, int excp)
 813 {
 814     save_cpu_state(ctx, 1);
 815     gen_helper_0i(raise_exception, excp);
 816     gen_helper_interrupt_restart();
 817     tcg_gen_exit_tb(0);
 818 }
 819
 820 /* Addresses computation */
 821 static inline void gen_op_addr_add (DisasContext *ctx, TCGv t0, TCGv t1)
 822 {
 823     tcg_gen_add_tl(t0, t0, t1);
 824
 825 #if defined(TARGET_MIPS64)
 826     /* For compatibility with 32-bit code, data reference in user mode
 827        with Status_UX = 0 should be casted to 32-bit and sign extended.
 828        See the MIPS64 PRA manual, section 4.10. */
 829     if (((ctx->hflags & MIPS_HFLAG_KSU) == MIPS_HFLAG_UM) &&
 830         !(ctx->hflags & MIPS_HFLAG_UX)) {
 831         tcg_gen_ext32s_i64(t0, t0);
 832     }
 833 #endif
 834 }
 835
 836 static inline void check_cp0_enabled(DisasContext *ctx)
 837 {
 838     if (unlikely(!(ctx->hflags & MIPS_HFLAG_CP0)))
 839         generate_exception_err(ctx, EXCP_CpU, 1);
 840 }
 841
 842 static inline void check_cp1_enabled(DisasContext *ctx)
 843 {
 844     if (unlikely(!(ctx->hflags & MIPS_HFLAG_FPU)))
 845         generate_exception_err(ctx, EXCP_CpU, 1);
 846 }
 847
 848 /* Verify that the processor is running with COP1X instructions enabled.
 849    This is associated with the nabla symbol in the MIPS32 and MIPS64
 850    opcode tables.  */
 851
 852 static inline void check_cop1x(DisasContext *ctx)
 853 {
 854     if (unlikely(!(ctx->hflags & MIPS_HFLAG_COP1X)))
 855         generate_exception(ctx, EXCP_RI);
 856 }
 857
 858 /* Verify that the processor is running with 64-bit floating-point
 859    operations enabled.  */
 860
 861 static inline void check_cp1_64bitmode(DisasContext *ctx)
 862 {
 863     if (unlikely(~ctx->hflags & (MIPS_HFLAG_F64 | MIPS_HFLAG_COP1X)))
 864         generate_exception(ctx, EXCP_RI);
 865 }
 866
 867 /*
 868  * Verify if floating point register is valid; an operation is not defined
 869  * if bit 0 of any register specification is set and the FR bit in the
 870  * Status register equals zero, since the register numbers specify an
 871  * even-odd pair of adjacent coprocessor general registers. When the FR bit
 872  * in the Status register equals one, both even and odd register numbers
 873  * are valid. This limitation exists only for 64 bit wide (d,l,ps) registers.
 874  *
 875  * Multiple 64 bit wide registers can be checked by calling
 876  * gen_op_cp1_registers(freg1 | freg2 | ... | fregN);
 877  */
 878 static inline void check_cp1_registers(DisasContext *ctx, int regs)
 879 {
 880     if (unlikely(!(ctx->hflags & MIPS_HFLAG_F64) && (regs & 1)))
 881         generate_exception(ctx, EXCP_RI);
 882 }
 883
 884 /* This code generates a "reserved instruction" exception if the
 885    CPU does not support the instruction set corresponding to flags. */
 886 static inline void check_insn(CPUState *env, DisasContext *ctx, int flags)
 887 {
 888     if (unlikely(!(env->insn_flags & flags)))
 889         generate_exception(ctx, EXCP_RI);
 890 }
 891
 892 /* This code generates a "reserved instruction" exception if 64-bit
 893    instructions are not enabled. */
 894 static inline void check_mips_64(DisasContext *ctx)
 895 {
 896     if (unlikely(!(ctx->hflags & MIPS_HFLAG_64)))
 897         generate_exception(ctx, EXCP_RI);
 898 }
 899
 900 /* load/store instructions. */
 901 #define OP_LD(insn,fname)                                        \
 902 static inline void op_ldst_##insn(TCGv t0, DisasContext *ctx)    \
 903 {                                                                \
 904     tcg_gen_qemu_##fname(t0, t0, ctx->mem_idx);                  \
 905 }
 906 OP_LD(lb,ld8s);
 907 OP_LD(lbu,ld8u);
 908 OP_LD(lh,ld16s);
 909 OP_LD(lhu,ld16u);
 910 OP_LD(lw,ld32s);
 911 #if defined(TARGET_MIPS64)
 912 OP_LD(lwu,ld32u);
 913 OP_LD(ld,ld64);
 914 #endif
 915 #undef OP_LD
 916
 917 #define OP_ST(insn,fname)                                        \
 918 static inline void op_ldst_##insn(TCGv t0, TCGv t1, DisasContext *ctx) \
 919 {                                                                \
 920     tcg_gen_qemu_##fname(t1, t0, ctx->mem_idx);                  \
 921 }
 922 OP_ST(sb,st8);
 923 OP_ST(sh,st16);
 924 OP_ST(sw,st32);
 925 #if defined(TARGET_MIPS64)
 926 OP_ST(sd,st64);
 927 #endif
 928 #undef OP_ST
 929
 930 #define OP_LD_ATOMIC(insn,fname)                                        \
 931 static inline void op_ldst_##insn(TCGv t0, TCGv t1, DisasContext *ctx)  \
 932 {                                                                       \
 933     tcg_gen_mov_tl(t1, t0);                                             \
 934     tcg_gen_qemu_##fname(t0, t0, ctx->mem_idx);                         \
 935     tcg_gen_st_tl(t1, cpu_env, offsetof(CPUState, CP0_LLAddr));         \
 936 }
 937 OP_LD_ATOMIC(ll,ld32s);
 938 #if defined(TARGET_MIPS64)
 939 OP_LD_ATOMIC(lld,ld64);
 940 #endif
 941 #undef OP_LD_ATOMIC
 942
 943 #define OP_ST_ATOMIC(insn,fname,almask)                                 \
 944 static inline void op_ldst_##insn(TCGv t0, TCGv t1, DisasContext *ctx)  \
 945 {                                                                       \
 946     TCGv r_tmp = tcg_temp_local_new();                       \
 947     int l1 = gen_new_label();                                           \
 948     int l2 = gen_new_label();                                           \
 949     int l3 = gen_new_label();                                           \
 950                                                                         \
 951     tcg_gen_andi_tl(r_tmp, t0, almask);                                 \
 952     tcg_gen_brcondi_tl(TCG_COND_EQ, r_tmp, 0, l1);                      \
 953     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, CP0_BadVAddr));       \
 954     generate_exception(ctx, EXCP_AdES);                                 \
 955     gen_set_label(l1);                                                  \
 956     tcg_gen_ld_tl(r_tmp, cpu_env, offsetof(CPUState, CP0_LLAddr));      \
 957     tcg_gen_brcond_tl(TCG_COND_NE, t0, r_tmp, l2);                      \
 958     tcg_gen_qemu_##fname(t1, t0, ctx->mem_idx);                         \
 959     tcg_gen_movi_tl(t0, 1);                                             \
 960     tcg_gen_br(l3);                                                     \
 961     gen_set_label(l2);                                                  \
 962     tcg_gen_movi_tl(t0, 0);                                             \
 963     gen_set_label(l3);                                                  \
 964     tcg_temp_free(r_tmp);                                               \
 965 }
 966 OP_ST_ATOMIC(sc,st32,0x3);
 967 #if defined(TARGET_MIPS64)
 968 OP_ST_ATOMIC(scd,st64,0x7);
 969 #endif
 970 #undef OP_ST_ATOMIC
 971
 972 /* Load and store */
 973 static void gen_ldst (DisasContext *ctx, uint32_t opc, int rt,
 974                       int base, int16_t offset)
 975 {
 976     const char *opn = "ldst";
 977     TCGv t0 = tcg_temp_local_new();
 978     TCGv t1 = tcg_temp_local_new();
 979
 980     if (base == 0) {
 981         tcg_gen_movi_tl(t0, offset);
 982     } else if (offset == 0) {
 983         gen_load_gpr(t0, base);
 984     } else {
 985         tcg_gen_movi_tl(t0, offset);
 986         gen_op_addr_add(ctx, t0, cpu_gpr[base]);
 987     }
 988     /* Don't do NOP if destination is zero: we must perform the actual
 989        memory access. */
 990     switch (opc) {
 991 #if defined(TARGET_MIPS64)
 992     case OPC_LWU:
 993         op_ldst_lwu(t0, ctx);
 994         gen_store_gpr(t0, rt);
 995         opn = "lwu";
 996         break;
 997     case OPC_LD:
 998         op_ldst_ld(t0, ctx);
 999         gen_store_gpr(t0, rt);
1000         opn = "ld";
1001         break;
1002     case OPC_LLD:
1003         op_ldst_lld(t0, t1, ctx);
1004         gen_store_gpr(t0, rt);
1005         opn = "lld";
1006         break;
1007     case OPC_SD:
1008         gen_load_gpr(t1, rt);
1009         op_ldst_sd(t0, t1, ctx);
1010         opn = "sd";
1011         break;
1012     case OPC_SCD:
1013         save_cpu_state(ctx, 1);
1014         gen_load_gpr(t1, rt);
1015         op_ldst_scd(t0, t1, ctx);
1016         gen_store_gpr(t0, rt);
1017         opn = "scd";
1018         break;
1019     case OPC_LDL:
1020         save_cpu_state(ctx, 1);
1021         gen_load_gpr(t1, rt);
1022         gen_helper_3i(ldl, t1, t0, t1, ctx->mem_idx);
1023         gen_store_gpr(t1, rt);
1024         opn = "ldl";
1025         break;
1026     case OPC_SDL:
1027         save_cpu_state(ctx, 1);
1028         gen_load_gpr(t1, rt);
1029         gen_helper_2i(sdl, t0, t1, ctx->mem_idx);
1030         opn = "sdl";
1031         break;
1032     case OPC_LDR:
1033         save_cpu_state(ctx, 1);
1034         gen_load_gpr(t1, rt);
1035         gen_helper_3i(ldr, t1, t0, t1, ctx->mem_idx);
1036         gen_store_gpr(t1, rt);
1037         opn = "ldr";
1038         break;
1039     case OPC_SDR:
1040         save_cpu_state(ctx, 1);
1041         gen_load_gpr(t1, rt);
1042         gen_helper_2i(sdr, t0, t1, ctx->mem_idx);
1043         opn = "sdr";
1044         break;
1045 #endif
1046     case OPC_LW:
1047         op_ldst_lw(t0, ctx);
1048         gen_store_gpr(t0, rt);
1049         opn = "lw";
1050         break;
1051     case OPC_SW:
1052         gen_load_gpr(t1, rt);
1053         op_ldst_sw(t0, t1, ctx);
1054         opn = "sw";
1055         break;
1056     case OPC_LH:
1057         op_ldst_lh(t0, ctx);
1058         gen_store_gpr(t0, rt);
1059         opn = "lh";
1060         break;
1061     case OPC_SH:
1062         gen_load_gpr(t1, rt);
1063         op_ldst_sh(t0, t1, ctx);
1064         opn = "sh";
1065         break;
1066     case OPC_LHU:
1067         op_ldst_lhu(t0, ctx);
1068         gen_store_gpr(t0, rt);
1069         opn = "lhu";
1070         break;
1071     case OPC_LB:
1072         op_ldst_lb(t0, ctx);
1073         gen_store_gpr(t0, rt);
1074         opn = "lb";
1075         break;
1076     case OPC_SB:
1077         gen_load_gpr(t1, rt);
1078         op_ldst_sb(t0, t1, ctx);
1079         opn = "sb";
1080         break;
1081     case OPC_LBU:
1082         op_ldst_lbu(t0, ctx);
1083         gen_store_gpr(t0, rt);
1084         opn = "lbu";
1085         break;
1086     case OPC_LWL:
1087         save_cpu_state(ctx, 1);
1088         gen_load_gpr(t1, rt);
1089         gen_helper_3i(lwl, t1, t0, t1, ctx->mem_idx);
1090         gen_store_gpr(t1, rt);
1091         opn = "lwl";
1092         break;
1093     case OPC_SWL:
1094         save_cpu_state(ctx, 1);
1095         gen_load_gpr(t1, rt);
1096         gen_helper_2i(swl, t0, t1, ctx->mem_idx);
1097         opn = "swr";
1098         break;
1099     case OPC_LWR:
1100         save_cpu_state(ctx, 1);
1101         gen_load_gpr(t1, rt);
1102         gen_helper_3i(lwr, t1, t0, t1, ctx->mem_idx);
1103         gen_store_gpr(t1, rt);
1104         opn = "lwr";
1105         break;
1106     case OPC_SWR:
1107         save_cpu_state(ctx, 1);
1108         gen_load_gpr(t1, rt);
1109         gen_helper_2i(swr, t0, t1, ctx->mem_idx);
1110         opn = "swr";
1111         break;
1112     case OPC_LL:
1113         op_ldst_ll(t0, t1, ctx);
1114         gen_store_gpr(t0, rt);
1115         opn = "ll";
1116         break;
1117     case OPC_SC:
1118         save_cpu_state(ctx, 1);
1119         gen_load_gpr(t1, rt);
1120         op_ldst_sc(t0, t1, ctx);
1121         gen_store_gpr(t0, rt);
1122         opn = "sc";
1123         break;
1124     default:
1125         MIPS_INVAL(opn);
1126         generate_exception(ctx, EXCP_RI);
1127         goto out;
1128     }
1129     MIPS_DEBUG("%s %s, %d(%s)", opn, regnames[rt], offset, regnames[base]);
1130  out:
1131     tcg_temp_free(t0);
1132     tcg_temp_free(t1);
1133 }
1134
1135 /* Load and store */
1136 static void gen_flt_ldst (DisasContext *ctx, uint32_t opc, int ft,
1137                           int base, int16_t offset)
1138 {
1139     const char *opn = "flt_ldst";
1140     TCGv t0 = tcg_temp_local_new();
1141
1142     if (base == 0) {
1143         tcg_gen_movi_tl(t0, offset);
1144     } else if (offset == 0) {
1145         gen_load_gpr(t0, base);
1146     } else {
1147         tcg_gen_movi_tl(t0, offset);
1148         gen_op_addr_add(ctx, t0, cpu_gpr[base]);
1149     }
1150     /* Don't do NOP if destination is zero: we must perform the actual
1151        memory access. */
1152     switch (opc) {
1153     case OPC_LWC1:
1154         {
1155             TCGv_i32 fp0 = tcg_temp_new_i32();
1156             TCGv t1 = tcg_temp_new();
1157
1158             tcg_gen_qemu_ld32s(t1, t0, ctx->mem_idx);
1159             tcg_gen_trunc_tl_i32(fp0, t1);
1160             gen_store_fpr32(fp0, ft);
1161             tcg_temp_free(t1);
1162             tcg_temp_free_i32(fp0);
1163         }
1164         opn = "lwc1";
1165         break;
1166     case OPC_SWC1:
1167         {
1168             TCGv_i32 fp0 = tcg_temp_new_i32();
1169             TCGv t1 = tcg_temp_new();
1170
1171             gen_load_fpr32(fp0, ft);
1172             tcg_gen_extu_i32_tl(t1, fp0);
1173             tcg_gen_qemu_st32(t1, t0, ctx->mem_idx);
1174             tcg_temp_free(t1);
1175             tcg_temp_free_i32(fp0);
1176         }
1177         opn = "swc1";
1178         break;
1179     case OPC_LDC1:
1180         {
1181             TCGv_i64 fp0 = tcg_temp_new_i64();
1182
1183             tcg_gen_qemu_ld64(fp0, t0, ctx->mem_idx);
1184             gen_store_fpr64(ctx, fp0, ft);
1185             tcg_temp_free_i64(fp0);
1186         }
1187         opn = "ldc1";
1188         break;
1189     case OPC_SDC1:
1190         {
1191             TCGv_i64 fp0 = tcg_temp_new_i64();
1192
1193             gen_load_fpr64(ctx, fp0, ft);
1194             tcg_gen_qemu_st64(fp0, t0, ctx->mem_idx);
1195             tcg_temp_free_i64(fp0);
1196         }
1197         opn = "sdc1";
1198         break;
1199     default:
1200         MIPS_INVAL(opn);
1201         generate_exception(ctx, EXCP_RI);
1202         goto out;
1203     }
1204     MIPS_DEBUG("%s %s, %d(%s)", opn, fregnames[ft], offset, regnames[base]);
1205  out:
1206     tcg_temp_free(t0);
1207 }
1208
1209 /* Arithmetic with immediate operand */
1210 static void gen_arith_imm (CPUState *env, DisasContext *ctx, uint32_t opc,
1211                            int rt, int rs, int16_t imm)
1212 {
1213     target_ulong uimm;
1214     const char *opn = "imm arith";
1215     TCGv t0 = tcg_temp_local_new();
1216
1217     if (rt == 0 && opc != OPC_ADDI && opc != OPC_DADDI) {
1218         /* If no destination, treat it as a NOP.
1219            For addi, we must generate the overflow exception when needed. */
1220         MIPS_DEBUG("NOP");
1221         goto out;
1222     }
1223     uimm = (uint16_t)imm;
1224     switch (opc) {
1225     case OPC_ADDI:
1226     case OPC_ADDIU:
1227 #if defined(TARGET_MIPS64)
1228     case OPC_DADDI:
1229     case OPC_DADDIU:
1230 #endif
1231     case OPC_SLTI:
1232     case OPC_SLTIU:
1233         uimm = (target_long)imm; /* Sign extend to 32/64 bits */
1234         /* Fall through. */
1235     case OPC_ANDI:
1236     case OPC_ORI:
1237     case OPC_XORI:
1238         gen_load_gpr(t0, rs);
1239         break;
1240     case OPC_LUI:
1241         tcg_gen_movi_tl(t0, imm << 16);
1242         break;
1243     case OPC_SLL:
1244     case OPC_SRA:
1245     case OPC_SRL:
1246 #if defined(TARGET_MIPS64)
1247     case OPC_DSLL:
1248     case OPC_DSRA:
1249     case OPC_DSRL:
1250     case OPC_DSLL32:
1251     case OPC_DSRA32:
1252     case OPC_DSRL32:
1253 #endif
1254         uimm &= 0x1f;
1255         gen_load_gpr(t0, rs);
1256         break;
1257     }
1258     switch (opc) {
1259     case OPC_ADDI:
1260         {
1261             TCGv r_tmp1 = tcg_temp_new();
1262             TCGv r_tmp2 = tcg_temp_new();
1263             int l1 = gen_new_label();
1264
1265             save_cpu_state(ctx, 1);
1266             tcg_gen_ext32s_tl(r_tmp1, t0);
1267             tcg_gen_addi_tl(t0, r_tmp1, uimm);
1268
1269             tcg_gen_xori_tl(r_tmp1, r_tmp1, ~uimm);
1270             tcg_gen_xori_tl(r_tmp2, t0, uimm);
1271             tcg_gen_and_tl(r_tmp1, r_tmp1, r_tmp2);
1272             tcg_temp_free(r_tmp2);
1273             tcg_gen_brcondi_tl(TCG_COND_GE, r_tmp1, 0, l1);
1274             /* operands of same sign, result different sign */
1275             generate_exception(ctx, EXCP_OVERFLOW);
1276             gen_set_label(l1);
1277             tcg_temp_free(r_tmp1);
1278
1279             tcg_gen_ext32s_tl(t0, t0);
1280         }
1281         opn = "addi";
1282         break;
1283     case OPC_ADDIU:
1284         tcg_gen_addi_tl(t0, t0, uimm);
1285         tcg_gen_ext32s_tl(t0, t0);
1286         opn = "addiu";
1287         break;
1288 #if defined(TARGET_MIPS64)
1289     case OPC_DADDI:
1290         {
1291             TCGv r_tmp1 = tcg_temp_new();
1292             TCGv r_tmp2 = tcg_temp_new();
1293             int l1 = gen_new_label();
1294
1295             save_cpu_state(ctx, 1);
1296             tcg_gen_mov_tl(r_tmp1, t0);
1297             tcg_gen_addi_tl(t0, t0, uimm);
1298
1299             tcg_gen_xori_tl(r_tmp1, r_tmp1, ~uimm);
1300             tcg_gen_xori_tl(r_tmp2, t0, uimm);
1301             tcg_gen_and_tl(r_tmp1, r_tmp1, r_tmp2);
1302             tcg_temp_free(r_tmp2);
1303             tcg_gen_brcondi_tl(TCG_COND_GE, r_tmp1, 0, l1);
1304             /* operands of same sign, result different sign */
1305             generate_exception(ctx, EXCP_OVERFLOW);
1306             gen_set_label(l1);
1307             tcg_temp_free(r_tmp1);
1308         }
1309         opn = "daddi";
1310         break;
1311     case OPC_DADDIU:
1312         tcg_gen_addi_tl(t0, t0, uimm);
1313         opn = "daddiu";
1314         break;
1315 #endif
1316     case OPC_SLTI:
1317         gen_op_lti(t0, uimm);
1318         opn = "slti";
1319         break;
1320     case OPC_SLTIU:
1321         gen_op_ltiu(t0, uimm);
1322         opn = "sltiu";
1323         break;
1324     case OPC_ANDI:
1325         tcg_gen_andi_tl(t0, t0, uimm);
1326         opn = "andi";
1327         break;
1328     case OPC_ORI:
1329         tcg_gen_ori_tl(t0, t0, uimm);
1330         opn = "ori";
1331         break;
1332     case OPC_XORI:
1333         tcg_gen_xori_tl(t0, t0, uimm);
1334         opn = "xori";
1335         break;
1336     case OPC_LUI:
1337         opn = "lui";
1338         break;
1339     case OPC_SLL:
1340         tcg_gen_shli_tl(t0, t0, uimm);
1341         tcg_gen_ext32s_tl(t0, t0);
1342         opn = "sll";
1343         break;
1344     case OPC_SRA:
1345         tcg_gen_ext32s_tl(t0, t0);
1346         tcg_gen_sari_tl(t0, t0, uimm);
1347         opn = "sra";
1348         break;
1349     case OPC_SRL:
1350         switch ((ctx->opcode >> 21) & 0x1f) {
1351         case 0:
1352             if (uimm != 0) {
1353                 tcg_gen_ext32u_tl(t0, t0);
1354                 tcg_gen_shri_tl(t0, t0, uimm);
1355             } else {
1356                 tcg_gen_ext32s_tl(t0, t0);
1357             }
1358             opn = "srl";
1359             break;
1360         case 1:
1361             /* rotr is decoded as srl on non-R2 CPUs */
1362             if (env->insn_flags & ISA_MIPS32R2) {
1363                 if (uimm != 0) {
1364                     TCGv_i32 r_tmp1 = tcg_temp_new_i32();
1365
1366                     tcg_gen_trunc_tl_i32(r_tmp1, t0);
1367                     tcg_gen_rotri_i32(r_tmp1, r_tmp1, uimm);
1368                     tcg_gen_ext_i32_tl(t0, r_tmp1);
1369                     tcg_temp_free_i32(r_tmp1);
1370                 }
1371                 opn = "rotr";
1372             } else {
1373                 if (uimm != 0) {
1374                     tcg_gen_ext32u_tl(t0, t0);
1375                     tcg_gen_shri_tl(t0, t0, uimm);
1376                 } else {
1377                     tcg_gen_ext32s_tl(t0, t0);
1378                 }
1379                 opn = "srl";
1380             }
1381             break;
1382         default:
1383             MIPS_INVAL("invalid srl flag");
1384             generate_exception(ctx, EXCP_RI);
1385             break;
1386         }
1387         break;
1388 #if defined(TARGET_MIPS64)
1389     case OPC_DSLL:
1390         tcg_gen_shli_tl(t0, t0, uimm);
1391         opn = "dsll";
1392         break;
1393     case OPC_DSRA:
1394         tcg_gen_sari_tl(t0, t0, uimm);
1395         opn = "dsra";
1396         break;
1397     case OPC_DSRL:
1398         switch ((ctx->opcode >> 21) & 0x1f) {
1399         case 0:
1400             tcg_gen_shri_tl(t0, t0, uimm);
1401             opn = "dsrl";
1402             break;
1403         case 1:
1404             /* drotr is decoded as dsrl on non-R2 CPUs */
1405             if (env->insn_flags & ISA_MIPS32R2) {
1406                 if (uimm != 0) {
1407                     tcg_gen_rotri_tl(t0, t0, uimm);
1408                 }
1409                 opn = "drotr";
1410             } else {
1411                 tcg_gen_shri_tl(t0, t0, uimm);
1412                 opn = "dsrl";
1413             }
1414             break;
1415         default:
1416             MIPS_INVAL("invalid dsrl flag");
1417             generate_exception(ctx, EXCP_RI);
1418             break;
1419         }
1420         break;
1421     case OPC_DSLL32:
1422         tcg_gen_shli_tl(t0, t0, uimm + 32);
1423         opn = "dsll32";
1424         break;
1425     case OPC_DSRA32:
1426         tcg_gen_sari_tl(t0, t0, uimm + 32);
1427         opn = "dsra32";
1428         break;
1429     case OPC_DSRL32:
1430         switch ((ctx->opcode >> 21) & 0x1f) {
1431         case 0:
1432             tcg_gen_shri_tl(t0, t0, uimm + 32);
1433             opn = "dsrl32";
1434             break;
1435         case 1:
1436             /* drotr32 is decoded as dsrl32 on non-R2 CPUs */
1437             if (env->insn_flags & ISA_MIPS32R2) {
1438                 tcg_gen_rotri_tl(t0, t0, uimm + 32);
1439                 opn = "drotr32";
1440             } else {
1441                 tcg_gen_shri_tl(t0, t0, uimm + 32);
1442                 opn = "dsrl32";
1443             }
1444             break;
1445         default:
1446             MIPS_INVAL("invalid dsrl32 flag");
1447             generate_exception(ctx, EXCP_RI);
1448             break;
1449         }
1450         break;
1451 #endif
1452     default:
1453         MIPS_INVAL(opn);
1454         generate_exception(ctx, EXCP_RI);
1455         goto out;
1456     }
1457     gen_store_gpr(t0, rt);
1458     MIPS_DEBUG("%s %s, %s, " TARGET_FMT_lx, opn, regnames[rt], regnames[rs], uimm);
1459  out:
1460     tcg_temp_free(t0);
1461 }
1462
1463 /* Arithmetic */
1464 static void gen_arith (CPUState *env, DisasContext *ctx, uint32_t opc,
1465                        int rd, int rs, int rt)
1466 {
1467     const char *opn = "arith";
1468     TCGv t0 = tcg_temp_local_new();
1469     TCGv t1 = tcg_temp_local_new();
1470
1471     if (rd == 0 && opc != OPC_ADD && opc != OPC_SUB
1472        && opc != OPC_DADD && opc != OPC_DSUB) {
1473         /* If no destination, treat it as a NOP.
1474            For add & sub, we must generate the overflow exception when needed. */
1475         MIPS_DEBUG("NOP");
1476         goto out;
1477     }
1478     gen_load_gpr(t0, rs);
1479     /* Specialcase the conventional move operation. */
1480     if (rt == 0 && (opc == OPC_ADDU || opc == OPC_DADDU
1481                     || opc == OPC_SUBU || opc == OPC_DSUBU)) {
1482         gen_store_gpr(t0, rd);
1483         goto out;
1484     }
1485     gen_load_gpr(t1, rt);
1486     switch (opc) {
1487     case OPC_ADD:
1488         {
1489             TCGv r_tmp1 = tcg_temp_new();
1490             TCGv r_tmp2 = tcg_temp_new();
1491             int l1 = gen_new_label();
1492
1493             save_cpu_state(ctx, 1);
1494             tcg_gen_ext32s_tl(r_tmp1, t0);
1495             tcg_gen_ext32s_tl(r_tmp2, t1);
1496             tcg_gen_add_tl(t0, r_tmp1, r_tmp2);
1497
1498             tcg_gen_xor_tl(r_tmp1, r_tmp1, t1);
1499             tcg_gen_xori_tl(r_tmp1, r_tmp1, -1);
1500             tcg_gen_xor_tl(r_tmp2, t0, t1);
1501             tcg_gen_and_tl(r_tmp1, r_tmp1, r_tmp2);
1502             tcg_temp_free(r_tmp2);
1503             tcg_gen_brcondi_tl(TCG_COND_GE, r_tmp1, 0, l1);
1504             /* operands of same sign, result different sign */
1505             generate_exception(ctx, EXCP_OVERFLOW);
1506             gen_set_label(l1);
1507             tcg_temp_free(r_tmp1);
1508
1509             tcg_gen_ext32s_tl(t0, t0);
1510         }
1511         opn = "add";
1512         break;
1513     case OPC_ADDU:
1514         tcg_gen_add_tl(t0, t0, t1);
1515         tcg_gen_ext32s_tl(t0, t0);
1516         opn = "addu";
1517         break;
1518     case OPC_SUB:
1519         {
1520             TCGv r_tmp1 = tcg_temp_new();
1521             TCGv r_tmp2 = tcg_temp_new();
1522             int l1 = gen_new_label();
1523
1524             save_cpu_state(ctx, 1);
1525             tcg_gen_ext32s_tl(r_tmp1, t0);
1526             tcg_gen_ext32s_tl(r_tmp2, t1);
1527             tcg_gen_sub_tl(t0, r_tmp1, r_tmp2);
1528
1529             tcg_gen_xor_tl(r_tmp2, r_tmp1, t1);
1530             tcg_gen_xor_tl(r_tmp1, r_tmp1, t0);
1531             tcg_gen_and_tl(r_tmp1, r_tmp1, r_tmp2);
1532             tcg_temp_free(r_tmp2);
1533             tcg_gen_brcondi_tl(TCG_COND_GE, r_tmp1, 0, l1);
1534             /* operands of different sign, first operand and result different sign */
1535             generate_exception(ctx, EXCP_OVERFLOW);
1536             gen_set_label(l1);
1537             tcg_temp_free(r_tmp1);
1538
1539             tcg_gen_ext32s_tl(t0, t0);
1540         }
1541         opn = "sub";
1542         break;
1543     case OPC_SUBU:
1544         tcg_gen_sub_tl(t0, t0, t1);
1545         tcg_gen_ext32s_tl(t0, t0);
1546         opn = "subu";
1547         break;
1548 #if defined(TARGET_MIPS64)
1549     case OPC_DADD:
1550         {
1551             TCGv r_tmp1 = tcg_temp_new();
1552             TCGv r_tmp2 = tcg_temp_new();
1553             int l1 = gen_new_label();
1554
1555             save_cpu_state(ctx, 1);
1556             tcg_gen_mov_tl(r_tmp1, t0);
1557             tcg_gen_add_tl(t0, t0, t1);
1558
1559             tcg_gen_xor_tl(r_tmp1, r_tmp1, t1);
1560             tcg_gen_xori_tl(r_tmp1, r_tmp1, -1);
1561             tcg_gen_xor_tl(r_tmp2, t0, t1);
1562             tcg_gen_and_tl(r_tmp1, r_tmp1, r_tmp2);
1563             tcg_temp_free(r_tmp2);
1564             tcg_gen_brcondi_tl(TCG_COND_GE, r_tmp1, 0, l1);
1565             /* operands of same sign, result different sign */
1566             generate_exception(ctx, EXCP_OVERFLOW);
1567             gen_set_label(l1);
1568             tcg_temp_free(r_tmp1);
1569         }
1570         opn = "dadd";
1571         break;
1572     case OPC_DADDU:
1573         tcg_gen_add_tl(t0, t0, t1);
1574         opn = "daddu";
1575         break;
1576     case OPC_DSUB:
1577         {
1578             TCGv r_tmp1 = tcg_temp_new();
1579             TCGv r_tmp2 = tcg_temp_new();
1580             int l1 = gen_new_label();
1581
1582             save_cpu_state(ctx, 1);
1583             tcg_gen_mov_tl(r_tmp1, t0);
1584             tcg_gen_sub_tl(t0, t0, t1);
1585
1586             tcg_gen_xor_tl(r_tmp2, r_tmp1, t1);
1587             tcg_gen_xor_tl(r_tmp1, r_tmp1, t0);
1588             tcg_gen_and_tl(r_tmp1, r_tmp1, r_tmp2);
1589             tcg_temp_free(r_tmp2);
1590             tcg_gen_brcondi_tl(TCG_COND_GE, r_tmp1, 0, l1);
1591             /* operands of different sign, first operand and result different sign */
1592             generate_exception(ctx, EXCP_OVERFLOW);
1593             gen_set_label(l1);
1594             tcg_temp_free(r_tmp1);
1595         }
1596         opn = "dsub";
1597         break;
1598     case OPC_DSUBU:
1599         tcg_gen_sub_tl(t0, t0, t1);
1600         opn = "dsubu";
1601         break;
1602 #endif
1603     case OPC_SLT:
1604         gen_op_lt(t0, t1);
1605         opn = "slt";
1606         break;
1607     case OPC_SLTU:
1608         gen_op_ltu(t0, t1);
1609         opn = "sltu";
1610         break;
1611     case OPC_AND:
1612         tcg_gen_and_tl(t0, t0, t1);
1613         opn = "and";
1614         break;
1615     case OPC_NOR:
1616         tcg_gen_nor_tl(t0, t0, t1);
1617         opn = "nor";
1618         break;
1619     case OPC_OR:
1620         tcg_gen_or_tl(t0, t0, t1);
1621         opn = "or";
1622         break;
1623     case OPC_XOR:
1624         tcg_gen_xor_tl(t0, t0, t1);
1625         opn = "xor";
1626         break;
1627     case OPC_MUL:
1628         tcg_gen_mul_tl(t0, t0, t1);
1629         tcg_gen_ext32s_tl(t0, t0);
1630         opn = "mul";
1631         break;
1632     case OPC_MOVN:
1633         {
1634             int l1 = gen_new_label();
1635
1636             tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
1637             gen_store_gpr(t0, rd);
1638             gen_set_label(l1);
1639         }
1640         opn = "movn";
1641         goto print;
1642     case OPC_MOVZ:
1643         {
1644             int l1 = gen_new_label();
1645
1646             tcg_gen_brcondi_tl(TCG_COND_NE, t1, 0, l1);
1647             gen_store_gpr(t0, rd);
1648             gen_set_label(l1);
1649         }
1650         opn = "movz";
1651         goto print;
1652     case OPC_SLLV:
1653         tcg_gen_andi_tl(t0, t0, 0x1f);
1654         tcg_gen_shl_tl(t0, t1, t0);
1655         tcg_gen_ext32s_tl(t0, t0);
1656         opn = "sllv";
1657         break;
1658     case OPC_SRAV:
1659         tcg_gen_ext32s_tl(t1, t1);
1660         tcg_gen_andi_tl(t0, t0, 0x1f);
1661         tcg_gen_sar_tl(t0, t1, t0);
1662         opn = "srav";
1663         break;
1664     case OPC_SRLV:
1665         switch ((ctx->opcode >> 6) & 0x1f) {
1666         case 0:
1667             tcg_gen_ext32u_tl(t1, t1);
1668             tcg_gen_andi_tl(t0, t0, 0x1f);
1669             tcg_gen_shr_tl(t0, t1, t0);
1670             tcg_gen_ext32s_tl(t0, t0);
1671             opn = "srlv";
1672             break;
1673         case 1:
1674             /* rotrv is decoded as srlv on non-R2 CPUs */
1675             if (env->insn_flags & ISA_MIPS32R2) {
1676                 int l1 = gen_new_label();
1677                 int l2 = gen_new_label();
1678
1679                 tcg_gen_andi_tl(t0, t0, 0x1f);
1680                 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
1681                 {
1682                     TCGv_i32 r_tmp1 = tcg_temp_new_i32();
1683                     TCGv_i32 r_tmp2 = tcg_temp_new_i32();
1684
1685                     tcg_gen_trunc_tl_i32(r_tmp1, t0);
1686                     tcg_gen_trunc_tl_i32(r_tmp2, t1);
1687                     tcg_gen_rotr_i32(r_tmp1, r_tmp1, r_tmp2);
1688                     tcg_temp_free_i32(r_tmp1);
1689                     tcg_temp_free_i32(r_tmp2);
1690                     tcg_gen_br(l2);
1691                 }
1692                 gen_set_label(l1);
1693                 tcg_gen_mov_tl(t0, t1);
1694                 gen_set_label(l2);
1695                 opn = "rotrv";
1696             } else {
1697                 tcg_gen_ext32u_tl(t1, t1);
1698                 tcg_gen_andi_tl(t0, t0, 0x1f);
1699                 tcg_gen_shr_tl(t0, t1, t0);
1700                 tcg_gen_ext32s_tl(t0, t0);
1701                 opn = "srlv";
1702             }
1703             break;
1704         default:
1705             MIPS_INVAL("invalid srlv flag");
1706             generate_exception(ctx, EXCP_RI);
1707             break;
1708         }
1709         break;
1710 #if defined(TARGET_MIPS64)
1711     case OPC_DSLLV:
1712         tcg_gen_andi_tl(t0, t0, 0x3f);
1713         tcg_gen_shl_tl(t0, t1, t0);
1714         opn = "dsllv";
1715         break;
1716     case OPC_DSRAV:
1717         tcg_gen_andi_tl(t0, t0, 0x3f);
1718         tcg_gen_sar_tl(t0, t1, t0);
1719         opn = "dsrav";
1720         break;
1721     case OPC_DSRLV:
1722         switch ((ctx->opcode >> 6) & 0x1f) {
1723         case 0:
1724             tcg_gen_andi_tl(t0, t0, 0x3f);
1725             tcg_gen_shr_tl(t0, t1, t0);
1726             opn = "dsrlv";
1727             break;
1728         case 1:
1729             /* drotrv is decoded as dsrlv on non-R2 CPUs */
1730             if (env->insn_flags & ISA_MIPS32R2) {
1731                 int l1 = gen_new_label();
1732                 int l2 = gen_new_label();
1733
1734                 tcg_gen_andi_tl(t0, t0, 0x3f);
1735                 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
1736                 {
1737                     tcg_gen_rotr_tl(t0, t1, t0);
1738                     tcg_gen_br(l2);
1739                 }
1740                 gen_set_label(l1);
1741                 tcg_gen_mov_tl(t0, t1);
1742                 gen_set_label(l2);
1743                 opn = "drotrv";
1744             } else {
1745                 tcg_gen_andi_tl(t0, t0, 0x3f);
1746                 tcg_gen_shr_tl(t0, t1, t0);
1747                 opn = "dsrlv";
1748             }
1749             break;
1750         default:
1751             MIPS_INVAL("invalid dsrlv flag");
1752             generate_exception(ctx, EXCP_RI);
1753             break;
1754         }
1755         break;
1756 #endif
1757     default:
1758         MIPS_INVAL(opn);
1759         generate_exception(ctx, EXCP_RI);
1760         goto out;
1761     }
1762     gen_store_gpr(t0, rd);
1763  print:
1764     MIPS_DEBUG("%s %s, %s, %s", opn, regnames[rd], regnames[rs], regnames[rt]);
1765  out:
1766     tcg_temp_free(t0);
1767     tcg_temp_free(t1);
1768 }
1769
1770 /* Arithmetic on HI/LO registers */
1771 static void gen_HILO (DisasContext *ctx, uint32_t opc, int reg)
1772 {
1773     const char *opn = "hilo";
1774
1775     if (reg == 0 && (opc == OPC_MFHI || opc == OPC_MFLO)) {
1776         /* Treat as NOP. */
1777         MIPS_DEBUG("NOP");
1778         return;
1779     }
1780     switch (opc) {
1781     case OPC_MFHI:
1782         tcg_gen_mov_tl(cpu_gpr[reg], cpu_HI[0]);
1783         opn = "mfhi";
1784         break;
1785     case OPC_MFLO:
1786         tcg_gen_mov_tl(cpu_gpr[reg], cpu_LO[0]);
1787         opn = "mflo";
1788         break;
1789     case OPC_MTHI:
1790         if (reg != 0)
1791             tcg_gen_mov_tl(cpu_HI[0], cpu_gpr[reg]);
1792         else
1793             tcg_gen_movi_tl(cpu_HI[0], 0);
1794         opn = "mthi";
1795         break;
1796     case OPC_MTLO:
1797         if (reg != 0)
1798             tcg_gen_mov_tl(cpu_LO[0], cpu_gpr[reg]);
1799         else
1800             tcg_gen_movi_tl(cpu_LO[0], 0);
1801         opn = "mtlo";
1802         break;
1803     default:
1804         MIPS_INVAL(opn);
1805         generate_exception(ctx, EXCP_RI);
1806         return;
1807     }
1808     MIPS_DEBUG("%s %s", opn, regnames[reg]);
1809 }
1810
1811 static void gen_muldiv (DisasContext *ctx, uint32_t opc,
1812                         int rs, int rt)
1813 {
1814     const char *opn = "mul/div";
1815     TCGv t0 = tcg_temp_local_new();
1816     TCGv t1 = tcg_temp_local_new();
1817
1818     gen_load_gpr(t0, rs);
1819     gen_load_gpr(t1, rt);
1820     switch (opc) {
1821     case OPC_DIV:
1822         {
1823             int l1 = gen_new_label();
1824
1825             tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
1826             {
1827                 int l2 = gen_new_label();
1828                 TCGv_i32 r_tmp1 = tcg_temp_local_new_i32();
1829                 TCGv_i32 r_tmp2 = tcg_temp_local_new_i32();
1830                 TCGv_i32 r_tmp3 = tcg_temp_local_new_i32();
1831
1832                 tcg_gen_trunc_tl_i32(r_tmp1, t0);
1833                 tcg_gen_trunc_tl_i32(r_tmp2, t1);
1834                 tcg_gen_brcondi_i32(TCG_COND_NE, r_tmp1, -1 << 31, l2);
1835                 tcg_gen_brcondi_i32(TCG_COND_NE, r_tmp2, -1, l2);
1836                 tcg_gen_ext32s_tl(cpu_LO[0], t0);
1837                 tcg_gen_movi_tl(cpu_HI[0], 0);
1838                 tcg_gen_br(l1);
1839                 gen_set_label(l2);
1840                 tcg_gen_div_i32(r_tmp3, r_tmp1, r_tmp2);
1841                 tcg_gen_rem_i32(r_tmp2, r_tmp1, r_tmp2);
1842                 tcg_gen_ext_i32_tl(cpu_LO[0], r_tmp3);
1843                 tcg_gen_ext_i32_tl(cpu_HI[0], r_tmp2);
1844                 tcg_temp_free_i32(r_tmp1);
1845                 tcg_temp_free_i32(r_tmp2);
1846                 tcg_temp_free_i32(r_tmp3);
1847             }
1848             gen_set_label(l1);
1849         }
1850         opn = "div";
1851         break;
1852     case OPC_DIVU:
1853         {
1854             int l1 = gen_new_label();
1855
1856             tcg_gen_ext32s_tl(t1, t1);
1857             tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
1858             {
1859                 TCGv_i32 r_tmp1 = tcg_temp_new_i32();
1860                 TCGv_i32 r_tmp2 = tcg_temp_new_i32();
1861                 TCGv_i32 r_tmp3 = tcg_temp_new_i32();
1862
1863                 tcg_gen_trunc_tl_i32(r_tmp1, t0);
1864                 tcg_gen_trunc_tl_i32(r_tmp2, t1);
1865                 tcg_gen_divu_i32(r_tmp3, r_tmp1, r_tmp2);
1866                 tcg_gen_remu_i32(r_tmp1, r_tmp1, r_tmp2);
1867                 tcg_gen_ext_i32_tl(cpu_LO[0], r_tmp3);
1868                 tcg_gen_ext_i32_tl(cpu_HI[0], r_tmp1);
1869                 tcg_temp_free_i32(r_tmp1);
1870                 tcg_temp_free_i32(r_tmp2);
1871                 tcg_temp_free_i32(r_tmp3);
1872             }
1873             gen_set_label(l1);
1874         }
1875         opn = "divu";
1876         break;
1877     case OPC_MULT:
1878         {
1879             TCGv_i64 r_tmp1 = tcg_temp_new_i64();
1880             TCGv_i64 r_tmp2 = tcg_temp_new_i64();
1881
1882             tcg_gen_ext_tl_i64(r_tmp1, t0);
1883             tcg_gen_ext_tl_i64(r_tmp2, t1);
1884             tcg_gen_mul_i64(r_tmp1, r_tmp1, r_tmp2);
1885             tcg_temp_free_i64(r_tmp2);
1886             tcg_gen_trunc_i64_tl(t0, r_tmp1);
1887             tcg_gen_shri_i64(r_tmp1, r_tmp1, 32);
1888             tcg_gen_trunc_i64_tl(t1, r_tmp1);
1889             tcg_temp_free_i64(r_tmp1);
1890             tcg_gen_ext32s_tl(cpu_LO[0], t0);
1891             tcg_gen_ext32s_tl(cpu_HI[0], t1);
1892         }
1893         opn = "mult";
1894         break;
1895     case OPC_MULTU:
1896         {
1897             TCGv_i64 r_tmp1 = tcg_temp_new_i64();
1898             TCGv_i64 r_tmp2 = tcg_temp_new_i64();
1899
1900             tcg_gen_ext32u_tl(t0, t0);
1901             tcg_gen_ext32u_tl(t1, t1);
1902             tcg_gen_extu_tl_i64(r_tmp1, t0);
1903             tcg_gen_extu_tl_i64(r_tmp2, t1);
1904             tcg_gen_mul_i64(r_tmp1, r_tmp1, r_tmp2);
1905             tcg_temp_free_i64(r_tmp2);
1906             tcg_gen_trunc_i64_tl(t0, r_tmp1);
1907             tcg_gen_shri_i64(r_tmp1, r_tmp1, 32);
1908             tcg_gen_trunc_i64_tl(t1, r_tmp1);
1909             tcg_temp_free_i64(r_tmp1);
1910             tcg_gen_ext32s_tl(cpu_LO[0], t0);
1911             tcg_gen_ext32s_tl(cpu_HI[0], t1);
1912         }
1913         opn = "multu";
1914         break;
1915 #if defined(TARGET_MIPS64)
1916     case OPC_DDIV:
1917         {
1918             int l1 = gen_new_label();
1919
1920             tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
1921             {
1922                 int l2 = gen_new_label();
1923
1924                 tcg_gen_brcondi_tl(TCG_COND_NE, t0, -1LL << 63, l2);
1925                 tcg_gen_brcondi_tl(TCG_COND_NE, t1, -1LL, l2);
1926                 tcg_gen_mov_tl(cpu_LO[0], t0);
1927                 tcg_gen_movi_tl(cpu_HI[0], 0);
1928                 tcg_gen_br(l1);
1929                 gen_set_label(l2);
1930                 tcg_gen_div_i64(cpu_LO[0], t0, t1);
1931                 tcg_gen_rem_i64(cpu_HI[0], t0, t1);
1932             }
1933             gen_set_label(l1);
1934         }
1935         opn = "ddiv";
1936         break;
1937     case OPC_DDIVU:
1938         {
1939             int l1 = gen_new_label();
1940
1941             tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
1942             tcg_gen_divu_i64(cpu_LO[0], t0, t1);
1943             tcg_gen_remu_i64(cpu_HI[0], t0, t1);
1944             gen_set_label(l1);
1945         }
1946         opn = "ddivu";
1947         break;
1948     case OPC_DMULT:
1949         gen_helper_dmult(t0, t1);
1950         opn = "dmult";
1951         break;
1952     case OPC_DMULTU:
1953         gen_helper_dmultu(t0, t1);
1954         opn = "dmultu";
1955         break;
1956 #endif
1957     case OPC_MADD:
1958         {
1959             TCGv_i64 r_tmp1 = tcg_temp_new_i64();
1960             TCGv_i64 r_tmp2 = tcg_temp_new_i64();
1961
1962             tcg_gen_ext_tl_i64(r_tmp1, t0);
1963             tcg_gen_ext_tl_i64(r_tmp2, t1);
1964             tcg_gen_mul_i64(r_tmp1, r_tmp1, r_tmp2);
1965             tcg_gen_concat_tl_i64(r_tmp2, cpu_LO[0], cpu_HI[0]);
1966             tcg_gen_add_i64(r_tmp1, r_tmp1, r_tmp2);
1967             tcg_temp_free_i64(r_tmp2);
1968             tcg_gen_trunc_i64_tl(t0, r_tmp1);
1969             tcg_gen_shri_i64(r_tmp1, r_tmp1, 32);
1970             tcg_gen_trunc_i64_tl(t1, r_tmp1);
1971             tcg_temp_free_i64(r_tmp1);
1972             tcg_gen_ext32s_tl(cpu_LO[0], t0);
1973             tcg_gen_ext32s_tl(cpu_LO[1], t1);
1974         }
1975         opn = "madd";
1976         break;
1977     case OPC_MADDU:
1978        {
1979             TCGv_i64 r_tmp1 = tcg_temp_new_i64();
1980             TCGv_i64 r_tmp2 = tcg_temp_new_i64();
1981
1982             tcg_gen_ext32u_tl(t0, t0);
1983             tcg_gen_ext32u_tl(t1, t1);
1984             tcg_gen_extu_tl_i64(r_tmp1, t0);
1985             tcg_gen_extu_tl_i64(r_tmp2, t1);
1986             tcg_gen_mul_i64(r_tmp1, r_tmp1, r_tmp2);
1987             tcg_gen_concat_tl_i64(r_tmp2, cpu_LO[0], cpu_HI[0]);
1988             tcg_gen_add_i64(r_tmp1, r_tmp1, r_tmp2);
1989             tcg_temp_free_i64(r_tmp2);
1990             tcg_gen_trunc_i64_tl(t0, r_tmp1);
1991             tcg_gen_shri_i64(r_tmp1, r_tmp1, 32);
1992             tcg_gen_trunc_i64_tl(t1, r_tmp1);
1993             tcg_temp_free_i64(r_tmp1);
1994             tcg_gen_ext32s_tl(cpu_LO[0], t0);
1995             tcg_gen_ext32s_tl(cpu_HI[0], t1);
1996         }
1997         opn = "maddu";
1998         break;
1999     case OPC_MSUB:
2000         {
2001             TCGv_i64 r_tmp1 = tcg_temp_new_i64();
2002             TCGv_i64 r_tmp2 = tcg_temp_new_i64();
2003
2004             tcg_gen_ext_tl_i64(r_tmp1, t0);
2005             tcg_gen_ext_tl_i64(r_tmp2, t1);
2006             tcg_gen_mul_i64(r_tmp1, r_tmp1, r_tmp2);
2007             tcg_gen_concat_tl_i64(r_tmp2, cpu_LO[0], cpu_HI[0]);
2008             tcg_gen_sub_i64(r_tmp1, r_tmp1, r_tmp2);
2009             tcg_temp_free_i64(r_tmp2);
2010             tcg_gen_trunc_i64_tl(t0, r_tmp1);
2011             tcg_gen_shri_i64(r_tmp1, r_tmp1, 32);
2012             tcg_gen_trunc_i64_tl(t1, r_tmp1);
2013             tcg_temp_free_i64(r_tmp1);
2014             tcg_gen_ext32s_tl(cpu_LO[0], t0);
2015             tcg_gen_ext32s_tl(cpu_HI[0], t1);
2016         }
2017         opn = "msub";
2018         break;
2019     case OPC_MSUBU:
2020         {
2021             TCGv_i64 r_tmp1 = tcg_temp_new_i64();
2022             TCGv_i64 r_tmp2 = tcg_temp_new_i64();
2023
2024             tcg_gen_ext32u_tl(t0, t0);
2025             tcg_gen_ext32u_tl(t1, t1);
2026             tcg_gen_extu_tl_i64(r_tmp1, t0);
2027             tcg_gen_extu_tl_i64(r_tmp2, t1);
2028             tcg_gen_mul_i64(r_tmp1, r_tmp1, r_tmp2);
2029             tcg_gen_concat_tl_i64(r_tmp2, cpu_LO[0], cpu_HI[0]);
2030             tcg_gen_sub_i64(r_tmp1, r_tmp1, r_tmp2);
2031             tcg_temp_free_i64(r_tmp2);
2032             tcg_gen_trunc_i64_tl(t0, r_tmp1);
2033             tcg_gen_shri_i64(r_tmp1, r_tmp1, 32);
2034             tcg_gen_trunc_i64_tl(t1, r_tmp1);
2035             tcg_temp_free_i64(r_tmp1);
2036             tcg_gen_ext32s_tl(cpu_LO[0], t0);
2037             tcg_gen_ext32s_tl(cpu_HI[0], t1);
2038         }
2039         opn = "msubu";
2040         break;
2041     default:
2042         MIPS_INVAL(opn);
2043         generate_exception(ctx, EXCP_RI);
2044         goto out;
2045     }
2046     MIPS_DEBUG("%s %s %s", opn, regnames[rs], regnames[rt]);
2047  out:
2048     tcg_temp_free(t0);
2049     tcg_temp_free(t1);
2050 }
2051
2052 static void gen_mul_vr54xx (DisasContext *ctx, uint32_t opc,
2053                             int rd, int rs, int rt)
2054 {
2055     const char *opn = "mul vr54xx";
2056     TCGv t0 = tcg_temp_local_new();
2057     TCGv t1 = tcg_temp_local_new();
2058
2059     gen_load_gpr(t0, rs);
2060     gen_load_gpr(t1, rt);
2061
2062     switch (opc) {
2063     case OPC_VR54XX_MULS:
2064         gen_helper_muls(t0, t0, t1);
2065         opn = "muls";
2066         break;
2067     case OPC_VR54XX_MULSU:
2068         gen_helper_mulsu(t0, t0, t1);
2069         opn = "mulsu";
2070         break;
2071     case OPC_VR54XX_MACC:
2072         gen_helper_macc(t0, t0, t1);
2073         opn = "macc";
2074         break;
2075     case OPC_VR54XX_MACCU:
2076         gen_helper_maccu(t0, t0, t1);
2077         opn = "maccu";
2078         break;
2079     case OPC_VR54XX_MSAC:
2080         gen_helper_msac(t0, t0, t1);
2081         opn = "msac";
2082         break;
2083     case OPC_VR54XX_MSACU:
2084         gen_helper_msacu(t0, t0, t1);
2085         opn = "msacu";
2086         break;
2087     case OPC_VR54XX_MULHI:
2088         gen_helper_mulhi(t0, t0, t1);
2089         opn = "mulhi";
2090         break;
2091     case OPC_VR54XX_MULHIU:
2092         gen_helper_mulhiu(t0, t0, t1);
2093         opn = "mulhiu";
2094         break;
2095     case OPC_VR54XX_MULSHI:
2096         gen_helper_mulshi(t0, t0, t1);
2097         opn = "mulshi";
2098         break;
2099     case OPC_VR54XX_MULSHIU:
2100         gen_helper_mulshiu(t0, t0, t1);
2101         opn = "mulshiu";
2102         break;
2103     case OPC_VR54XX_MACCHI:
2104         gen_helper_macchi(t0, t0, t1);
2105         opn = "macchi";
2106         break;
2107     case OPC_VR54XX_MACCHIU:
2108         gen_helper_macchiu(t0, t0, t1);
2109         opn = "macchiu";
2110         break;
2111     case OPC_VR54XX_MSACHI:
2112         gen_helper_msachi(t0, t0, t1);
2113         opn = "msachi";
2114         break;
2115     case OPC_VR54XX_MSACHIU:
2116         gen_helper_msachiu(t0, t0, t1);
2117         opn = "msachiu";
2118         break;
2119     default:
2120         MIPS_INVAL("mul vr54xx");
2121         generate_exception(ctx, EXCP_RI);
2122         goto out;
2123     }
2124     gen_store_gpr(t0, rd);
2125     MIPS_DEBUG("%s %s, %s, %s", opn, regnames[rd], regnames[rs], regnames[rt]);
2126
2127  out:
2128     tcg_temp_free(t0);
2129     tcg_temp_free(t1);
2130 }
2131
2132 static void gen_cl (DisasContext *ctx, uint32_t opc,
2133                     int rd, int rs)
2134 {
2135     const char *opn = "CLx";
2136     TCGv t0 = tcg_temp_local_new();
2137
2138     if (rd == 0) {
2139         /* Treat as NOP. */
2140         MIPS_DEBUG("NOP");
2141         goto out;
2142     }
2143     gen_load_gpr(t0, rs);
2144     switch (opc) {
2145     case OPC_CLO:
2146         gen_helper_clo(t0, t0);
2147         opn = "clo";
2148         break;
2149     case OPC_CLZ:
2150         gen_helper_clz(t0, t0);
2151         opn = "clz";
2152         break;
2153 #if defined(TARGET_MIPS64)
2154     case OPC_DCLO:
2155         gen_helper_dclo(t0, t0);
2156         opn = "dclo";
2157         break;
2158     case OPC_DCLZ:
2159         gen_helper_dclz(t0, t0);
2160         opn = "dclz";
2161         break;
2162 #endif
2163     default:
2164         MIPS_INVAL(opn);
2165         generate_exception(ctx, EXCP_RI);
2166         goto out;
2167     }
2168     gen_store_gpr(t0, rd);
2169     MIPS_DEBUG("%s %s, %s", opn, regnames[rd], regnames[rs]);
2170
2171  out:
2172     tcg_temp_free(t0);
2173 }
2174
2175 /* Traps */
2176 static void gen_trap (DisasContext *ctx, uint32_t opc,
2177                       int rs, int rt, int16_t imm)
2178 {
2179     int cond;
2180     TCGv t0 = tcg_temp_local_new();
2181     TCGv t1 = tcg_temp_local_new();
2182
2183     cond = 0;
2184     /* Load needed operands */
2185     switch (opc) {
2186     case OPC_TEQ:
2187     case OPC_TGE:
2188     case OPC_TGEU:
2189     case OPC_TLT:
2190     case OPC_TLTU:
2191     case OPC_TNE:
2192         /* Compare two registers */
2193         if (rs != rt) {
2194             gen_load_gpr(t0, rs);
2195             gen_load_gpr(t1, rt);
2196             cond = 1;
2197         }
2198         break;
2199     case OPC_TEQI:
2200     case OPC_TGEI:
2201     case OPC_TGEIU:
2202     case OPC_TLTI:
2203     case OPC_TLTIU:
2204     case OPC_TNEI:
2205         /* Compare register to immediate */
2206         if (rs != 0 || imm != 0) {
2207             gen_load_gpr(t0, rs);
2208             tcg_gen_movi_tl(t1, (int32_t)imm);
2209             cond = 1;
2210         }
2211         break;
2212     }
2213     if (cond == 0) {
2214         switch (opc) {
2215         case OPC_TEQ:   /* rs == rs */
2216         case OPC_TEQI:  /* r0 == 0  */
2217         case OPC_TGE:   /* rs >= rs */
2218         case OPC_TGEI:  /* r0 >= 0  */
2219         case OPC_TGEU:  /* rs >= rs unsigned */
2220         case OPC_TGEIU: /* r0 >= 0  unsigned */
2221             /* Always trap */
2222             tcg_gen_movi_tl(t0, 1);
2223             break;
2224         case OPC_TLT:   /* rs < rs           */
2225         case OPC_TLTI:  /* r0 < 0            */
2226         case OPC_TLTU:  /* rs < rs unsigned  */
2227         case OPC_TLTIU: /* r0 < 0  unsigned  */
2228         case OPC_TNE:   /* rs != rs          */
2229         case OPC_TNEI:  /* r0 != 0           */
2230             /* Never trap: treat as NOP. */
2231             goto out;
2232         default:
2233             MIPS_INVAL("trap");
2234             generate_exception(ctx, EXCP_RI);
2235             goto out;
2236         }
2237     } else {
2238         switch (opc) {
2239         case OPC_TEQ:
2240         case OPC_TEQI:
2241             gen_op_eq(t0, t1);
2242             break;
2243         case OPC_TGE:
2244         case OPC_TGEI:
2245             gen_op_ge(t0, t1);
2246             break;
2247         case OPC_TGEU:
2248         case OPC_TGEIU:
2249             gen_op_geu(t0, t1);
2250             break;
2251         case OPC_TLT:
2252         case OPC_TLTI:
2253             gen_op_lt(t0, t1);
2254             break;
2255         case OPC_TLTU:
2256         case OPC_TLTIU:
2257             gen_op_ltu(t0, t1);
2258             break;
2259         case OPC_TNE:
2260         case OPC_TNEI:
2261             gen_op_ne(t0, t1);
2262             break;
2263         default:
2264             MIPS_INVAL("trap");
2265             generate_exception(ctx, EXCP_RI);
2266             goto out;
2267         }
2268     }
2269     save_cpu_state(ctx, 1);
2270     {
2271         int l1 = gen_new_label();
2272
2273         tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
2274         gen_helper_0i(raise_exception, EXCP_TRAP);
2275         gen_set_label(l1);
2276     }
2277     ctx->bstate = BS_STOP;
2278  out:
2279     tcg_temp_free(t0);
2280     tcg_temp_free(t1);
2281 }
2282
2283 static inline void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
2284 {
2285     TranslationBlock *tb;
2286     tb = ctx->tb;
2287     if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
2288         tcg_gen_goto_tb(n);
2289         gen_save_pc(dest);
2290         tcg_gen_exit_tb((long)tb + n);
2291     } else {
2292         gen_save_pc(dest);
2293         tcg_gen_exit_tb(0);
2294     }
2295 }
2296
2297 /* Branches (before delay slot) */
2298 static void gen_compute_branch (DisasContext *ctx, uint32_t opc,
2299                                 int rs, int rt, int32_t offset)
2300 {
2301     target_ulong btgt = -1;
2302     int blink = 0;
2303     int bcond_compute = 0;
2304     TCGv t0 = tcg_temp_local_new();
2305     TCGv t1 = tcg_temp_local_new();
2306
2307     if (ctx->hflags & MIPS_HFLAG_BMASK) {
2308 #ifdef MIPS_DEBUG_DISAS
2309         LOG_DISAS("Branch in delay slot at PC 0x" TARGET_FMT_lx "\n", ctx->pc);
2310 #endif
2311         generate_exception(ctx, EXCP_RI);
2312         goto out;
2313     }
2314
2315     /* Load needed operands */
2316     switch (opc) {
2317     case OPC_BEQ:
2318     case OPC_BEQL:
2319     case OPC_BNE:
2320     case OPC_BNEL:
2321         /* Compare two registers */
2322         if (rs != rt) {
2323             gen_load_gpr(t0, rs);
2324             gen_load_gpr(t1, rt);
2325             bcond_compute = 1;
2326         }
2327         btgt = ctx->pc + 4 + offset;
2328         break;
2329     case OPC_BGEZ:
2330     case OPC_BGEZAL:
2331     case OPC_BGEZALL:
2332     case OPC_BGEZL:
2333     case OPC_BGTZ:
2334     case OPC_BGTZL:
2335     case OPC_BLEZ:
2336     case OPC_BLEZL:
2337     case OPC_BLTZ:
2338     case OPC_BLTZAL:
2339     case OPC_BLTZALL:
2340     case OPC_BLTZL:
2341         /* Compare to zero */
2342         if (rs != 0) {
2343             gen_load_gpr(t0, rs);
2344             bcond_compute = 1;
2345         }
2346         btgt = ctx->pc + 4 + offset;
2347         break;
2348     case OPC_J:
2349     case OPC_JAL:
2350         /* Jump to immediate */
2351         btgt = ((ctx->pc + 4) & (int32_t)0xF0000000) | (uint32_t)offset;
2352         break;
2353     case OPC_JR:
2354     case OPC_JALR:
2355         /* Jump to register */
2356         if (offset != 0 && offset != 16) {
2357             /* Hint = 0 is JR/JALR, hint 16 is JR.HB/JALR.HB, the
2358                others are reserved. */
2359             MIPS_INVAL("jump hint");
2360             generate_exception(ctx, EXCP_RI);
2361             goto out;
2362         }
2363         gen_load_gpr(btarget, rs);
2364         break;
2365     default:
2366         MIPS_INVAL("branch/jump");
2367         generate_exception(ctx, EXCP_RI);
2368         goto out;
2369     }
2370     if (bcond_compute == 0) {
2371         /* No condition to be computed */
2372         switch (opc) {
2373         case OPC_BEQ:     /* rx == rx        */
2374         case OPC_BEQL:    /* rx == rx likely */
2375         case OPC_BGEZ:    /* 0 >= 0          */
2376         case OPC_BGEZL:   /* 0 >= 0 likely   */
2377         case OPC_BLEZ:    /* 0 <= 0          */
2378         case OPC_BLEZL:   /* 0 <= 0 likely   */
2379             /* Always take */
2380             ctx->hflags |= MIPS_HFLAG_B;
2381             MIPS_DEBUG("balways");
2382             break;
2383         case OPC_BGEZAL:  /* 0 >= 0          */
2384         case OPC_BGEZALL: /* 0 >= 0 likely   */
2385             /* Always take and link */
2386             blink = 31;
2387             ctx->hflags |= MIPS_HFLAG_B;
2388             MIPS_DEBUG("balways and link");
2389             break;
2390         case OPC_BNE:     /* rx != rx        */
2391         case OPC_BGTZ:    /* 0 > 0           */
2392         case OPC_BLTZ:    /* 0 < 0           */
2393             /* Treat as NOP. */
2394             MIPS_DEBUG("bnever (NOP)");
2395             goto out;
2396         case OPC_BLTZAL:  /* 0 < 0           */
2397             tcg_gen_movi_tl(t0, ctx->pc + 8);
2398             gen_store_gpr(t0, 31);
2399             MIPS_DEBUG("bnever and link");
2400             goto out;
2401         case OPC_BLTZALL: /* 0 < 0 likely */
2402             tcg_gen_movi_tl(t0, ctx->pc + 8);
2403             gen_store_gpr(t0, 31);
2404             /* Skip the instruction in the delay slot */
2405             MIPS_DEBUG("bnever, link and skip");
2406             ctx->pc += 4;
2407             goto out;
2408         case OPC_BNEL:    /* rx != rx likely */
2409         case OPC_BGTZL:   /* 0 > 0 likely */
2410         case OPC_BLTZL:   /* 0 < 0 likely */
2411             /* Skip the instruction in the delay slot */
2412             MIPS_DEBUG("bnever and skip");
2413             ctx->pc += 4;
2414             goto out;
2415         case OPC_J:
2416             ctx->hflags |= MIPS_HFLAG_B;
2417             MIPS_DEBUG("j " TARGET_FMT_lx, btgt);
2418             break;
2419         case OPC_JAL:
2420             blink = 31;
2421             ctx->hflags |= MIPS_HFLAG_B;
2422             MIPS_DEBUG("jal " TARGET_FMT_lx, btgt);
2423             break;
2424         case OPC_JR:
2425             ctx->hflags |= MIPS_HFLAG_BR;
2426             MIPS_DEBUG("jr %s", regnames[rs]);
2427             break;
2428         case OPC_JALR:
2429             blink = rt;
2430             ctx->hflags |= MIPS_HFLAG_BR;
2431             MIPS_DEBUG("jalr %s, %s", regnames[rt], regnames[rs]);
2432             break;
2433         default:
2434             MIPS_INVAL("branch/jump");
2435             generate_exception(ctx, EXCP_RI);
2436             goto out;
2437         }
2438     } else {
2439         switch (opc) {
2440         case OPC_BEQ:
2441             gen_op_eq(t0, t1);
2442             MIPS_DEBUG("beq %s, %s, " TARGET_FMT_lx,
2443                        regnames[rs], regnames[rt], btgt);
2444             goto not_likely;
2445         case OPC_BEQL:
2446             gen_op_eq(t0, t1);
2447             MIPS_DEBUG("beql %s, %s, " TARGET_FMT_lx,
2448                        regnames[rs], regnames[rt], btgt);
2449             goto likely;
2450         case OPC_BNE:
2451             gen_op_ne(t0, t1);
2452             MIPS_DEBUG("bne %s, %s, " TARGET_FMT_lx,
2453                        regnames[rs], regnames[rt], btgt);
2454             goto not_likely;
2455         case OPC_BNEL:
2456             gen_op_ne(t0, t1);
2457             MIPS_DEBUG("bnel %s, %s, " TARGET_FMT_lx,
2458                        regnames[rs], regnames[rt], btgt);
2459             goto likely;
2460         case OPC_BGEZ:
2461             gen_op_gez(t0);
2462             MIPS_DEBUG("bgez %s, " TARGET_FMT_lx, regnames[rs], btgt);
2463             goto not_likely;
2464         case OPC_BGEZL:
2465             gen_op_gez(t0);
2466             MIPS_DEBUG("bgezl %s, " TARGET_FMT_lx, regnames[rs], btgt);
2467             goto likely;
2468         case OPC_BGEZAL:
2469             gen_op_gez(t0);
2470             MIPS_DEBUG("bgezal %s, " TARGET_FMT_lx, regnames[rs], btgt);
2471             blink = 31;
2472             goto not_likely;
2473         case OPC_BGEZALL:
2474             gen_op_gez(t0);
2475             blink = 31;
2476             MIPS_DEBUG("bgezall %s, " TARGET_FMT_lx, regnames[rs], btgt);
2477             goto likely;
2478         case OPC_BGTZ:
2479             gen_op_gtz(t0);
2480             MIPS_DEBUG("bgtz %s, " TARGET_FMT_lx, regnames[rs], btgt);
2481             goto not_likely;
2482         case OPC_BGTZL:
2483             gen_op_gtz(t0);
2484             MIPS_DEBUG("bgtzl %s, " TARGET_FMT_lx, regnames[rs], btgt);
2485             goto likely;
2486         case OPC_BLEZ:
2487             gen_op_lez(t0);
2488             MIPS_DEBUG("blez %s, " TARGET_FMT_lx, regnames[rs], btgt);
2489             goto not_likely;
2490         case OPC_BLEZL:
2491             gen_op_lez(t0);
2492             MIPS_DEBUG("blezl %s, " TARGET_FMT_lx, regnames[rs], btgt);
2493             goto likely;
2494         case OPC_BLTZ:
2495             gen_op_ltz(t0);
2496             MIPS_DEBUG("bltz %s, " TARGET_FMT_lx, regnames[rs], btgt);
2497             goto not_likely;
2498         case OPC_BLTZL:
2499             gen_op_ltz(t0);
2500             MIPS_DEBUG("bltzl %s, " TARGET_FMT_lx, regnames[rs], btgt);
2501             goto likely;
2502         case OPC_BLTZAL:
2503             gen_op_ltz(t0);
2504             blink = 31;
2505             MIPS_DEBUG("bltzal %s, " TARGET_FMT_lx, regnames[rs], btgt);
2506         not_likely:
2507             ctx->hflags |= MIPS_HFLAG_BC;
2508             tcg_gen_trunc_tl_i32(bcond, t0);
2509             break;
2510         case OPC_BLTZALL:
2511             gen_op_ltz(t0);
2512             blink = 31;
2513             MIPS_DEBUG("bltzall %s, " TARGET_FMT_lx, regnames[rs], btgt);
2514         likely:
2515             ctx->hflags |= MIPS_HFLAG_BL;
2516             tcg_gen_trunc_tl_i32(bcond, t0);
2517             break;
2518         default:
2519             MIPS_INVAL("conditional branch/jump");
2520             generate_exception(ctx, EXCP_RI);
2521             goto out;
2522         }
2523     }
2524     MIPS_DEBUG("enter ds: link %d cond %02x target " TARGET_FMT_lx,
2525                blink, ctx->hflags, btgt);
2526
2527     ctx->btarget = btgt;
2528     if (blink > 0) {
2529         tcg_gen_movi_tl(t0, ctx->pc + 8);
2530         gen_store_gpr(t0, blink);
2531     }
2532
2533  out:
2534     tcg_temp_free(t0);
2535     tcg_temp_free(t1);
2536 }
2537
2538 /* special3 bitfield operations */
2539 static void gen_bitops (DisasContext *ctx, uint32_t opc, int rt,
2540                         int rs, int lsb, int msb)
2541 {
2542     TCGv t0 = tcg_temp_new();
2543     TCGv t1 = tcg_temp_new();
2544     target_ulong mask;
2545
2546     gen_load_gpr(t1, rs);
2547     switch (opc) {
2548     case OPC_EXT:
2549         if (lsb + msb > 31)
2550             goto fail;
2551         tcg_gen_shri_tl(t0, t1, lsb);
2552         if (msb != 31) {
2553             tcg_gen_andi_tl(t0, t0, (1 << (msb + 1)) - 1);
2554         } else {
2555             tcg_gen_ext32s_tl(t0, t0);
2556         }
2557         break;
2558 #if defined(TARGET_MIPS64)
2559     case OPC_DEXTM:
2560         tcg_gen_shri_tl(t0, t1, lsb);
2561         if (msb != 31) {
2562             tcg_gen_andi_tl(t0, t0, (1ULL << (msb + 1 + 32)) - 1);
2563         }
2564         break;
2565     case OPC_DEXTU:
2566         tcg_gen_shri_tl(t0, t1, lsb + 32);
2567         tcg_gen_andi_tl(t0, t0, (1ULL << (msb + 1)) - 1);
2568         break;
2569     case OPC_DEXT:
2570         tcg_gen_shri_tl(t0, t1, lsb);
2571         tcg_gen_andi_tl(t0, t0, (1ULL << (msb + 1)) - 1);
2572         break;
2573 #endif
2574     case OPC_INS:
2575         if (lsb > msb)
2576             goto fail;
2577         mask = ((msb - lsb + 1 < 32) ? ((1 << (msb - lsb + 1)) - 1) : ~0) << lsb;
2578         gen_load_gpr(t0, rt);
2579         tcg_gen_andi_tl(t0, t0, ~mask);
2580         tcg_gen_shli_tl(t1, t1, lsb);
2581         tcg_gen_andi_tl(t1, t1, mask);
2582         tcg_gen_or_tl(t0, t0, t1);
2583         tcg_gen_ext32s_tl(t0, t0);
2584         break;
2585 #if defined(TARGET_MIPS64)
2586     case OPC_DINSM:
2587         if (lsb > msb)
2588             goto fail;
2589         mask = ((msb - lsb + 1 + 32 < 64) ? ((1ULL << (msb - lsb + 1 + 32)) - 1) : ~0ULL) << lsb;
2590         gen_load_gpr(t0, rt);
2591         tcg_gen_andi_tl(t0, t0, ~mask);
2592         tcg_gen_shli_tl(t1, t1, lsb);
2593         tcg_gen_andi_tl(t1, t1, mask);
2594         tcg_gen_or_tl(t0, t0, t1);
2595         break;
2596     case OPC_DINSU:
2597         if (lsb > msb)
2598             goto fail;
2599         mask = ((1ULL << (msb - lsb + 1)) - 1) << lsb;
2600         gen_load_gpr(t0, rt);
2601         tcg_gen_andi_tl(t0, t0, ~mask);
2602         tcg_gen_shli_tl(t1, t1, lsb + 32);
2603         tcg_gen_andi_tl(t1, t1, mask);
2604         tcg_gen_or_tl(t0, t0, t1);
2605         break;
2606     case OPC_DINS:
2607         if (lsb > msb)
2608             goto fail;
2609         gen_load_gpr(t0, rt);
2610         mask = ((1ULL << (msb - lsb + 1)) - 1) << lsb;
2611         gen_load_gpr(t0, rt);
2612         tcg_gen_andi_tl(t0, t0, ~mask);
2613         tcg_gen_shli_tl(t1, t1, lsb);
2614         tcg_gen_andi_tl(t1, t1, mask);
2615         tcg_gen_or_tl(t0, t0, t1);
2616         break;
2617 #endif
2618     default:
2619 fail:
2620         MIPS_INVAL("bitops");
2621         generate_exception(ctx, EXCP_RI);
2622         tcg_temp_free(t0);
2623         tcg_temp_free(t1);
2624         return;
2625     }
2626     gen_store_gpr(t0, rt);
2627     tcg_temp_free(t0);
2628     tcg_temp_free(t1);
2629 }
2630
2631 static void gen_bshfl (DisasContext *ctx, uint32_t op2, int rt, int rd)
2632 {
2633     TCGv t0 = tcg_temp_new();
2634     TCGv t1 = tcg_temp_new();
2635
2636     gen_load_gpr(t1, rt);
2637     switch (op2) {
2638     case OPC_WSBH:
2639         tcg_gen_shri_tl(t0, t1, 8);
2640         tcg_gen_andi_tl(t0, t0, 0x00FF00FF);
2641         tcg_gen_shli_tl(t1, t1, 8);
2642         tcg_gen_andi_tl(t1, t1, ~0x00FF00FF);
2643         tcg_gen_or_tl(t0, t0, t1);
2644         tcg_gen_ext32s_tl(t0, t0);
2645         break;
2646     case OPC_SEB:
2647         tcg_gen_ext8s_tl(t0, t1);
2648         break;
2649     case OPC_SEH:
2650         tcg_gen_ext16s_tl(t0, t1);
2651         break;
2652 #if defined(TARGET_MIPS64)
2653     case OPC_DSBH:
2654         gen_load_gpr(t1, rt);
2655         tcg_gen_shri_tl(t0, t1, 8);
2656         tcg_gen_andi_tl(t0, t0, 0x00FF00FF00FF00FFULL);
2657         tcg_gen_shli_tl(t1, t1, 8);
2658         tcg_gen_andi_tl(t1, t1, ~0x00FF00FF00FF00FFULL);
2659         tcg_gen_or_tl(t0, t0, t1);
2660         break;
2661     case OPC_DSHD:
2662         gen_load_gpr(t1, rt);
2663         tcg_gen_shri_tl(t0, t1, 16);
2664         tcg_gen_andi_tl(t0, t0, 0x0000FFFF0000FFFFULL);
2665         tcg_gen_shli_tl(t1, t1, 16);
2666         tcg_gen_andi_tl(t1, t1, ~0x0000FFFF0000FFFFULL);
2667         tcg_gen_or_tl(t1, t0, t1);
2668         tcg_gen_shri_tl(t0, t1, 32);
2669         tcg_gen_shli_tl(t1, t1, 32);
2670         tcg_gen_or_tl(t0, t0, t1);
2671         break;
2672 #endif
2673     default:
2674         MIPS_INVAL("bsfhl");
2675         generate_exception(ctx, EXCP_RI);
2676         tcg_temp_free(t0);
2677         tcg_temp_free(t1);
2678         return;
2679     }
2680     gen_store_gpr(t0, rd);
2681     tcg_temp_free(t0);
2682     tcg_temp_free(t1);
2683 }
2684
2685 #ifndef CONFIG_USER_ONLY
2686 /* CP0 (MMU and control) */
2687 static inline void gen_mfc0_load32 (TCGv t, target_ulong off)
2688 {
2689     TCGv_i32 r_tmp = tcg_temp_new_i32();
2690
2691     tcg_gen_ld_i32(r_tmp, cpu_env, off);
2692     tcg_gen_ext_i32_tl(t, r_tmp);
2693     tcg_temp_free_i32(r_tmp);
2694 }
2695
2696 static inline void gen_mfc0_load64 (TCGv t, target_ulong off)
2697 {
2698     tcg_gen_ld_tl(t, cpu_env, off);
2699     tcg_gen_ext32s_tl(t, t);
2700 }
2701
2702 static inline void gen_mtc0_store32 (TCGv t, target_ulong off)
2703 {
2704     TCGv_i32 r_tmp = tcg_temp_new_i32();
2705
2706     tcg_gen_trunc_tl_i32(r_tmp, t);
2707     tcg_gen_st_i32(r_tmp, cpu_env, off);
2708     tcg_temp_free_i32(r_tmp);
2709 }
2710
2711 static inline void gen_mtc0_store64 (TCGv t, target_ulong off)
2712 {
2713     tcg_gen_ext32s_tl(t, t);
2714     tcg_gen_st_tl(t, cpu_env, off);
2715 }
2716
2717 static void gen_mfc0 (CPUState *env, DisasContext *ctx, TCGv t0, int reg, int sel)
2718 {
2719     const char *rn = "invalid";
2720
2721     if (sel != 0)
2722         check_insn(env, ctx, ISA_MIPS32);
2723
2724     switch (reg) {
2725     case 0:
2726         switch (sel) {
2727         case 0:
2728             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Index));
2729             rn = "Index";
2730             break;
2731         case 1:
2732             check_insn(env, ctx, ASE_MT);
2733             gen_helper_mfc0_mvpcontrol(t0);
2734             rn = "MVPControl";
2735             break;
2736         case 2:
2737             check_insn(env, ctx, ASE_MT);
2738             gen_helper_mfc0_mvpconf0(t0);
2739             rn = "MVPConf0";
2740             break;
2741         case 3:
2742             check_insn(env, ctx, ASE_MT);
2743             gen_helper_mfc0_mvpconf1(t0);
2744             rn = "MVPConf1";
2745             break;
2746         default:
2747             goto die;
2748         }
2749         break;
2750     case 1:
2751         switch (sel) {
2752         case 0:
2753             gen_helper_mfc0_random(t0);
2754             rn = "Random";
2755             break;
2756         case 1:
2757             check_insn(env, ctx, ASE_MT);
2758             gen_mfc0_load32(t0, offsetof(CPUState, CP0_VPEControl));
2759             rn = "VPEControl";
2760             break;
2761         case 2:
2762             check_insn(env, ctx, ASE_MT);
2763             gen_mfc0_load32(t0, offsetof(CPUState, CP0_VPEConf0));
2764             rn = "VPEConf0";
2765             break;
2766         case 3:
2767             check_insn(env, ctx, ASE_MT);
2768             gen_mfc0_load32(t0, offsetof(CPUState, CP0_VPEConf1));
2769             rn = "VPEConf1";
2770             break;
2771         case 4:
2772             check_insn(env, ctx, ASE_MT);
2773             gen_mfc0_load64(t0, offsetof(CPUState, CP0_YQMask));
2774             rn = "YQMask";
2775             break;
2776         case 5:
2777             check_insn(env, ctx, ASE_MT);
2778             gen_mfc0_load64(t0, offsetof(CPUState, CP0_VPESchedule));
2779             rn = "VPESchedule";
2780             break;
2781         case 6:
2782             check_insn(env, ctx, ASE_MT);
2783             gen_mfc0_load64(t0, offsetof(CPUState, CP0_VPEScheFBack));
2784             rn = "VPEScheFBack";
2785             break;
2786         case 7:
2787             check_insn(env, ctx, ASE_MT);
2788             gen_mfc0_load32(t0, offsetof(CPUState, CP0_VPEOpt));
2789             rn = "VPEOpt";
2790             break;
2791         default:
2792             goto die;
2793         }
2794         break;
2795     case 2:
2796         switch (sel) {
2797         case 0:
2798             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_EntryLo0));
2799             tcg_gen_ext32s_tl(t0, t0);
2800             rn = "EntryLo0";
2801             break;
2802         case 1:
2803             check_insn(env, ctx, ASE_MT);
2804             gen_helper_mfc0_tcstatus(t0);
2805             rn = "TCStatus";
2806             break;
2807         case 2:
2808             check_insn(env, ctx, ASE_MT);
2809             gen_helper_mfc0_tcbind(t0);
2810             rn = "TCBind";
2811             break;
2812         case 3:
2813             check_insn(env, ctx, ASE_MT);
2814             gen_helper_mfc0_tcrestart(t0);
2815             rn = "TCRestart";
2816             break;
2817         case 4:
2818             check_insn(env, ctx, ASE_MT);
2819             gen_helper_mfc0_tchalt(t0);
2820             rn = "TCHalt";
2821             break;
2822         case 5:
2823             check_insn(env, ctx, ASE_MT);
2824             gen_helper_mfc0_tccontext(t0);
2825             rn = "TCContext";
2826             break;
2827         case 6:
2828             check_insn(env, ctx, ASE_MT);
2829             gen_helper_mfc0_tcschedule(t0);
2830             rn = "TCSchedule";
2831             break;
2832         case 7:
2833             check_insn(env, ctx, ASE_MT);
2834             gen_helper_mfc0_tcschefback(t0);
2835             rn = "TCScheFBack";
2836             break;
2837         default:
2838             goto die;
2839         }
2840         break;
2841     case 3:
2842         switch (sel) {
2843         case 0:
2844             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_EntryLo1));
2845             tcg_gen_ext32s_tl(t0, t0);
2846             rn = "EntryLo1";
2847             break;
2848         default:
2849             goto die;
2850         }
2851         break;
2852     case 4:
2853         switch (sel) {
2854         case 0:
2855             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_Context));
2856             tcg_gen_ext32s_tl(t0, t0);
2857             rn = "Context";
2858             break;
2859         case 1:
2860 //            gen_helper_mfc0_contextconfig(t0); /* SmartMIPS ASE */
2861             rn = "ContextConfig";
2862 //            break;
2863         default:
2864             goto die;
2865         }
2866         break;
2867     case 5:
2868         switch (sel) {
2869         case 0:
2870             gen_mfc0_load32(t0, offsetof(CPUState, CP0_PageMask));
2871             rn = "PageMask";
2872             break;
2873         case 1:
2874             check_insn(env, ctx, ISA_MIPS32R2);
2875             gen_mfc0_load32(t0, offsetof(CPUState, CP0_PageGrain));
2876             rn = "PageGrain";
2877             break;
2878         default:
2879             goto die;
2880         }
2881         break;
2882     case 6:
2883         switch (sel) {
2884         case 0:
2885             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Wired));
2886             rn = "Wired";
2887             break;
2888         case 1:
2889             check_insn(env, ctx, ISA_MIPS32R2);
2890             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSConf0));
2891             rn = "SRSConf0";
2892             break;
2893         case 2:
2894             check_insn(env, ctx, ISA_MIPS32R2);
2895             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSConf1));
2896             rn = "SRSConf1";
2897             break;
2898         case 3:
2899             check_insn(env, ctx, ISA_MIPS32R2);
2900             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSConf2));
2901             rn = "SRSConf2";
2902             break;
2903         case 4:
2904             check_insn(env, ctx, ISA_MIPS32R2);
2905             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSConf3));
2906             rn = "SRSConf3";
2907             break;
2908         case 5:
2909             check_insn(env, ctx, ISA_MIPS32R2);
2910             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSConf4));
2911             rn = "SRSConf4";
2912             break;
2913         default:
2914             goto die;
2915         }
2916         break;
2917     case 7:
2918         switch (sel) {
2919         case 0:
2920             check_insn(env, ctx, ISA_MIPS32R2);
2921             gen_mfc0_load32(t0, offsetof(CPUState, CP0_HWREna));
2922             rn = "HWREna";
2923             break;
2924         default:
2925             goto die;
2926         }
2927         break;
2928     case 8:
2929         switch (sel) {
2930         case 0:
2931             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_BadVAddr));
2932             tcg_gen_ext32s_tl(t0, t0);
2933             rn = "BadVAddr";
2934             break;
2935         default:
2936             goto die;
2937        }
2938         break;
2939     case 9:
2940         switch (sel) {
2941         case 0:
2942             /* Mark as an IO operation because we read the time.  */
2943             if (use_icount)
2944                 gen_io_start();
2945             gen_helper_mfc0_count(t0);
2946             if (use_icount) {
2947                 gen_io_end();
2948                 ctx->bstate = BS_STOP;
2949             }
2950             rn = "Count";
2951             break;
2952         /* 6,7 are implementation dependent */
2953         default:
2954             goto die;
2955         }
2956         break;
2957     case 10:
2958         switch (sel) {
2959         case 0:
2960             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_EntryHi));
2961             tcg_gen_ext32s_tl(t0, t0);
2962             rn = "EntryHi";
2963             break;
2964         default:
2965             goto die;
2966         }
2967         break;
2968     case 11:
2969         switch (sel) {
2970         case 0:
2971             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Compare));
2972             rn = "Compare";
2973             break;
2974         /* 6,7 are implementation dependent */
2975         default:
2976             goto die;
2977         }
2978         break;
2979     case 12:
2980         switch (sel) {
2981         case 0:
2982             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Status));
2983             rn = "Status";
2984             break;
2985         case 1:
2986             check_insn(env, ctx, ISA_MIPS32R2);
2987             gen_mfc0_load32(t0, offsetof(CPUState, CP0_IntCtl));
2988             rn = "IntCtl";
2989             break;
2990         case 2:
2991             check_insn(env, ctx, ISA_MIPS32R2);
2992             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSCtl));
2993             rn = "SRSCtl";
2994             break;
2995         case 3:
2996             check_insn(env, ctx, ISA_MIPS32R2);
2997             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSMap));
2998             rn = "SRSMap";
2999             break;
3000         default:
3001             goto die;
3002        }
3003         break;
3004     case 13:
3005         switch (sel) {
3006         case 0:
3007             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Cause));
3008             rn = "Cause";
3009             break;
3010         default:
3011             goto die;
3012        }
3013         break;
3014     case 14:
3015         switch (sel) {
3016         case 0:
3017             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_EPC));
3018             tcg_gen_ext32s_tl(t0, t0);
3019             rn = "EPC";
3020             break;
3021         default:
3022             goto die;
3023         }
3024         break;
3025     case 15:
3026         switch (sel) {
3027         case 0:
3028             gen_mfc0_load32(t0, offsetof(CPUState, CP0_PRid));
3029             rn = "PRid";
3030             break;
3031         case 1:
3032             check_insn(env, ctx, ISA_MIPS32R2);
3033             gen_mfc0_load32(t0, offsetof(CPUState, CP0_EBase));
3034             rn = "EBase";
3035             break;
3036         default:
3037             goto die;
3038        }
3039         break;
3040     case 16:
3041         switch (sel) {
3042         case 0:
3043             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config0));
3044             rn = "Config";
3045             break;
3046         case 1:
3047             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config1));
3048             rn = "Config1";
3049             break;
3050         case 2:
3051             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config2));
3052             rn = "Config2";
3053             break;
3054         case 3:
3055             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config3));
3056             rn = "Config3";
3057             break;
3058         /* 4,5 are reserved */
3059         /* 6,7 are implementation dependent */
3060         case 6:
3061             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config6));
3062             rn = "Config6";
3063             break;
3064         case 7:
3065             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config7));
3066             rn = "Config7";
3067             break;
3068         default:
3069             goto die;
3070         }
3071         break;
3072     case 17:
3073         switch (sel) {
3074         case 0:
3075             gen_helper_mfc0_lladdr(t0);
3076             rn = "LLAddr";
3077             break;
3078         default:
3079             goto die;
3080         }
3081         break;
3082     case 18:
3083         switch (sel) {
3084         case 0 ... 7:
3085             gen_helper_1i(mfc0_watchlo, t0, sel);
3086             rn = "WatchLo";
3087             break;
3088         default:
3089             goto die;
3090         }
3091         break;
3092     case 19:
3093         switch (sel) {
3094         case 0 ...7:
3095             gen_helper_1i(mfc0_watchhi, t0, sel);
3096             rn = "WatchHi";
3097             break;
3098         default:
3099             goto die;
3100         }
3101         break;
3102     case 20:
3103         switch (sel) {
3104         case 0:
3105 #if defined(TARGET_MIPS64)
3106             check_insn(env, ctx, ISA_MIPS3);
3107             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_XContext));
3108             tcg_gen_ext32s_tl(t0, t0);
3109             rn = "XContext";
3110             break;
3111 #endif
3112         default:
3113             goto die;
3114         }
3115         break;
3116     case 21:
3117        /* Officially reserved, but sel 0 is used for R1x000 framemask */
3118         switch (sel) {
3119         case 0:
3120             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Framemask));
3121             rn = "Framemask";
3122             break;
3123         default:
3124             goto die;
3125         }
3126         break;
3127     case 22:
3128         tcg_gen_movi_tl(t0, 0); /* unimplemented */
3129         rn = "'Diagnostic"; /* implementation dependent */
3130         break;
3131     case 23:
3132         switch (sel) {
3133         case 0:
3134             gen_helper_mfc0_debug(t0); /* EJTAG support */
3135             rn = "Debug";
3136             break;
3137         case 1:
3138 //            gen_helper_mfc0_tracecontrol(t0); /* PDtrace support */
3139             rn = "TraceControl";
3140 //            break;
3141         case 2:
3142 //            gen_helper_mfc0_tracecontrol2(t0); /* PDtrace support */
3143             rn = "TraceControl2";
3144 //            break;
3145         case 3:
3146 //            gen_helper_mfc0_usertracedata(t0); /* PDtrace support */
3147             rn = "UserTraceData";
3148 //            break;
3149         case 4:
3150 //            gen_helper_mfc0_tracebpc(t0); /* PDtrace support */
3151             rn = "TraceBPC";
3152 //            break;
3153         default:
3154             goto die;
3155         }
3156         break;
3157     case 24:
3158         switch (sel) {
3159         case 0:
3160             /* EJTAG support */
3161             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_DEPC));
3162             tcg_gen_ext32s_tl(t0, t0);
3163             rn = "DEPC";
3164             break;
3165         default:
3166             goto die;
3167         }
3168         break;
3169     case 25:
3170         switch (sel) {
3171         case 0:
3172             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Performance0));
3173             rn = "Performance0";
3174             break;
3175         case 1:
3176 //            gen_helper_mfc0_performance1(t0);
3177             rn = "Performance1";
3178 //            break;
3179         case 2:
3180 //            gen_helper_mfc0_performance2(t0);
3181             rn = "Performance2";
3182 //            break;
3183         case 3:
3184 //            gen_helper_mfc0_performance3(t0);
3185             rn = "Performance3";
3186 //            break;
3187         case 4:
3188 //            gen_helper_mfc0_performance4(t0);
3189             rn = "Performance4";
3190 //            break;
3191         case 5:
3192 //            gen_helper_mfc0_performance5(t0);
3193             rn = "Performance5";
3194 //            break;
3195         case 6:
3196 //            gen_helper_mfc0_performance6(t0);
3197             rn = "Performance6";
3198 //            break;
3199         case 7:
3200 //            gen_helper_mfc0_performance7(t0);
3201             rn = "Performance7";
3202 //            break;
3203         default:
3204             goto die;
3205         }
3206         break;
3207     case 26:
3208         tcg_gen_movi_tl(t0, 0); /* unimplemented */
3209         rn = "ECC";
3210         break;
3211     case 27:
3212         switch (sel) {
3213         case 0 ... 3:
3214             tcg_gen_movi_tl(t0, 0); /* unimplemented */
3215             rn = "CacheErr";
3216             break;
3217         default:
3218             goto die;
3219         }
3220         break;
3221     case 28:
3222         switch (sel) {
3223         case 0:
3224         case 2:
3225         case 4:
3226         case 6:
3227             gen_mfc0_load32(t0, offsetof(CPUState, CP0_TagLo));
3228             rn = "TagLo";
3229             break;
3230         case 1:
3231         case 3:
3232         case 5:
3233         case 7:
3234             gen_mfc0_load32(t0, offsetof(CPUState, CP0_DataLo));
3235             rn = "DataLo";
3236             break;
3237         default:
3238             goto die;
3239         }
3240         break;
3241     case 29:
3242         switch (sel) {
3243         case 0:
3244         case 2:
3245         case 4:
3246         case 6:
3247             gen_mfc0_load32(t0, offsetof(CPUState, CP0_TagHi));
3248             rn = "TagHi";
3249             break;
3250         case 1:
3251         case 3:
3252         case 5:
3253         case 7:
3254             gen_mfc0_load32(t0, offsetof(CPUState, CP0_DataHi));
3255             rn = "DataHi";
3256             break;
3257         default:
3258             goto die;
3259         }
3260         break;
3261     case 30:
3262         switch (sel) {
3263         case 0:
3264             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_ErrorEPC));
3265             tcg_gen_ext32s_tl(t0, t0);
3266             rn = "ErrorEPC";
3267             break;
3268         default:
3269             goto die;
3270         }
3271         break;
3272     case 31:
3273         switch (sel) {
3274         case 0:
3275             /* EJTAG support */
3276             gen_mfc0_load32(t0, offsetof(CPUState, CP0_DESAVE));
3277             rn = "DESAVE";
3278             break;
3279         default:
3280             goto die;
3281         }
3282         break;
3283     default:
3284        goto die;
3285     }
3286     LOG_DISAS("mfc0 %s (reg %d sel %d)\n", rn, reg, sel);
3287     return;
3288
3289 die:
3290     LOG_DISAS("mfc0 %s (reg %d sel %d)\n", rn, reg, sel);
3291     generate_exception(ctx, EXCP_RI);
3292 }
3293
3294 static void gen_mtc0 (CPUState *env, DisasContext *ctx, TCGv t0, int reg, int sel)
3295 {
3296     const char *rn = "invalid";
3297
3298     if (sel != 0)
3299         check_insn(env, ctx, ISA_MIPS32);
3300
3301     if (use_icount)
3302         gen_io_start();
3303
3304     switch (reg) {
3305     case 0:
3306         switch (sel) {
3307         case 0:
3308             gen_helper_mtc0_index(t0);
3309             rn = "Index";
3310             break;
3311         case 1:
3312             check_insn(env, ctx, ASE_MT);
3313             gen_helper_mtc0_mvpcontrol(t0);
3314             rn = "MVPControl";
3315             break;
3316         case 2:
3317             check_insn(env, ctx, ASE_MT);
3318             /* ignored */
3319             rn = "MVPConf0";
3320             break;
3321         case 3:
3322             check_insn(env, ctx, ASE_MT);
3323             /* ignored */
3324             rn = "MVPConf1";
3325             break;
3326         default:
3327             goto die;
3328         }
3329         break;
3330     case 1:
3331         switch (sel) {
3332         case 0:
3333             /* ignored */
3334             rn = "Random";
3335             break;
3336         case 1:
3337             check_insn(env, ctx, ASE_MT);
3338             gen_helper_mtc0_vpecontrol(t0);
3339             rn = "VPEControl";
3340             break;
3341         case 2:
3342             check_insn(env, ctx, ASE_MT);
3343             gen_helper_mtc0_vpeconf0(t0);
3344             rn = "VPEConf0";
3345             break;
3346         case 3:
3347             check_insn(env, ctx, ASE_MT);
3348             gen_helper_mtc0_vpeconf1(t0);
3349             rn = "VPEConf1";
3350             break;
3351         case 4:
3352             check_insn(env, ctx, ASE_MT);
3353             gen_helper_mtc0_yqmask(t0);
3354             rn = "YQMask";
3355             break;
3356         case 5:
3357             check_insn(env, ctx, ASE_MT);
3358             gen_mtc0_store64(t0, offsetof(CPUState, CP0_VPESchedule));
3359             rn = "VPESchedule";
3360             break;
3361         case 6:
3362             check_insn(env, ctx, ASE_MT);
3363             gen_mtc0_store64(t0, offsetof(CPUState, CP0_VPEScheFBack));
3364             rn = "VPEScheFBack";
3365             break;
3366         case 7:
3367             check_insn(env, ctx, ASE_MT);
3368             gen_helper_mtc0_vpeopt(t0);
3369             rn = "VPEOpt";
3370             break;
3371         default:
3372             goto die;
3373         }
3374         break;
3375     case 2:
3376         switch (sel) {
3377         case 0:
3378             gen_helper_mtc0_entrylo0(t0);
3379             rn = "EntryLo0";
3380             break;
3381         case 1:
3382             check_insn(env, ctx, ASE_MT);
3383             gen_helper_mtc0_tcstatus(t0);
3384             rn = "TCStatus";
3385             break;
3386         case 2:
3387             check_insn(env, ctx, ASE_MT);
3388             gen_helper_mtc0_tcbind(t0);
3389             rn = "TCBind";
3390             break;
3391         case 3:
3392             check_insn(env, ctx, ASE_MT);
3393             gen_helper_mtc0_tcrestart(t0);
3394             rn = "TCRestart";
3395             break;
3396         case 4:
3397             check_insn(env, ctx, ASE_MT);
3398             gen_helper_mtc0_tchalt(t0);
3399             rn = "TCHalt";
3400             break;
3401         case 5:
3402             check_insn(env, ctx, ASE_MT);
3403             gen_helper_mtc0_tccontext(t0);
3404             rn = "TCContext";
3405             break;
3406         case 6:
3407             check_insn(env, ctx, ASE_MT);
3408             gen_helper_mtc0_tcschedule(t0);
3409             rn = "TCSchedule";
3410             break;
3411         case 7:
3412             check_insn(env, ctx, ASE_MT);
3413             gen_helper_mtc0_tcschefback(t0);
3414             rn = "TCScheFBack";
3415             break;
3416         default:
3417             goto die;
3418         }
3419         break;
3420     case 3:
3421         switch (sel) {
3422         case 0:
3423             gen_helper_mtc0_entrylo1(t0);
3424             rn = "EntryLo1";
3425             break;
3426         default:
3427             goto die;
3428         }
3429         break;
3430     case 4:
3431         switch (sel) {
3432         case 0:
3433             gen_helper_mtc0_context(t0);
3434             rn = "Context";
3435             break;
3436         case 1:
3437 //            gen_helper_mtc0_contextconfig(t0); /* SmartMIPS ASE */
3438             rn = "ContextConfig";
3439 //            break;
3440         default:
3441             goto die;
3442         }
3443         break;
3444     case 5:
3445         switch (sel) {
3446         case 0:
3447             gen_helper_mtc0_pagemask(t0);
3448             rn = "PageMask";
3449             break;
3450         case 1:
3451             check_insn(env, ctx, ISA_MIPS32R2);
3452             gen_helper_mtc0_pagegrain(t0);
3453             rn = "PageGrain";
3454             break;
3455         default:
3456             goto die;
3457         }
3458         break;
3459     case 6:
3460         switch (sel) {
3461         case 0:
3462             gen_helper_mtc0_wired(t0);
3463             rn = "Wired";
3464             break;
3465         case 1:
3466             check_insn(env, ctx, ISA_MIPS32R2);
3467             gen_helper_mtc0_srsconf0(t0);
3468             rn = "SRSConf0";
3469             break;
3470         case 2:
3471             check_insn(env, ctx, ISA_MIPS32R2);
3472             gen_helper_mtc0_srsconf1(t0);
3473             rn = "SRSConf1";
3474             break;
3475         case 3:
3476             check_insn(env, ctx, ISA_MIPS32R2);
3477             gen_helper_mtc0_srsconf2(t0);
3478             rn = "SRSConf2";
3479             break;
3480         case 4:
3481             check_insn(env, ctx, ISA_MIPS32R2);
3482             gen_helper_mtc0_srsconf3(t0);
3483             rn = "SRSConf3";
3484             break;
3485         case 5:
3486             check_insn(env, ctx, ISA_MIPS32R2);
3487             gen_helper_mtc0_srsconf4(t0);
3488             rn = "SRSConf4";
3489             break;
3490         default:
3491             goto die;
3492         }
3493         break;
3494     case 7:
3495         switch (sel) {
3496         case 0:
3497             check_insn(env, ctx, ISA_MIPS32R2);
3498             gen_helper_mtc0_hwrena(t0);
3499             rn = "HWREna";
3500             break;
3501         default:
3502             goto die;
3503         }
3504         break;
3505     case 8:
3506         /* ignored */
3507         rn = "BadVAddr";
3508         break;
3509     case 9:
3510         switch (sel) {
3511         case 0:
3512             gen_helper_mtc0_count(t0);
3513             rn = "Count";
3514             break;
3515         /* 6,7 are implementation dependent */
3516         default:
3517             goto die;
3518         }
3519         /* Stop translation as we may have switched the execution mode */
3520         ctx->bstate = BS_STOP;
3521         break;
3522     case 10:
3523         switch (sel) {
3524         case 0:
3525             gen_helper_mtc0_entryhi(t0);
3526             rn = "EntryHi";
3527             break;
3528         default:
3529             goto die;
3530         }
3531         break;
3532     case 11:
3533         switch (sel) {
3534         case 0:
3535             gen_helper_mtc0_compare(t0);
3536             rn = "Compare";
3537             break;
3538         /* 6,7 are implementation dependent */
3539         default:
3540             goto die;
3541         }
3542         /* Stop translation as we may have switched the execution mode */
3543         ctx->bstate = BS_STOP;
3544         break;
3545     case 12:
3546         switch (sel) {
3547         case 0:
3548             gen_helper_mtc0_status(t0);
3549             /* BS_STOP isn't good enough here, hflags may have changed. */
3550             gen_save_pc(ctx->pc + 4);
3551             ctx->bstate = BS_EXCP;
3552             rn = "Status";
3553             break;
3554         case 1:
3555             check_insn(env, ctx, ISA_MIPS32R2);
3556             gen_helper_mtc0_intctl(t0);
3557             /* Stop translation as we may have switched the execution mode */
3558             ctx->bstate = BS_STOP;
3559             rn = "IntCtl";
3560             break;
3561         case 2:
3562             check_insn(env, ctx, ISA_MIPS32R2);
3563             gen_helper_mtc0_srsctl(t0);
3564             /* Stop translation as we may have switched the execution mode */
3565             ctx->bstate = BS_STOP;
3566             rn = "SRSCtl";
3567             break;
3568         case 3:
3569             check_insn(env, ctx, ISA_MIPS32R2);
3570             gen_mtc0_store32(t0, offsetof(CPUState, CP0_SRSMap));
3571             /* Stop translation as we may have switched the execution mode */
3572             ctx->bstate = BS_STOP;
3573             rn = "SRSMap";
3574             break;
3575         default:
3576             goto die;
3577         }
3578         break;
3579     case 13:
3580         switch (sel) {
3581         case 0:
3582             gen_helper_mtc0_cause(t0);
3583             rn = "Cause";
3584             break;
3585         default:
3586             goto die;
3587         }
3588         /* Stop translation as we may have switched the execution mode */
3589         ctx->bstate = BS_STOP;
3590         break;
3591     case 14:
3592         switch (sel) {
3593         case 0:
3594             gen_mtc0_store64(t0, offsetof(CPUState, CP0_EPC));
3595             rn = "EPC";
3596             break;
3597         default:
3598             goto die;
3599         }
3600         break;
3601     case 15:
3602         switch (sel) {
3603         case 0:
3604             /* ignored */
3605             rn = "PRid";
3606             break;
3607         case 1:
3608             check_insn(env, ctx, ISA_MIPS32R2);
3609             gen_helper_mtc0_ebase(t0);
3610             rn = "EBase";
3611             break;
3612         default:
3613             goto die;
3614         }
3615         break;
3616     case 16:
3617         switch (sel) {
3618         case 0:
3619             gen_helper_mtc0_config0(t0);
3620             rn = "Config";
3621             /* Stop translation as we may have switched the execution mode */
3622             ctx->bstate = BS_STOP;
3623             break;
3624         case 1:
3625             /* ignored, read only */
3626             rn = "Config1";
3627             break;
3628         case 2:
3629             gen_helper_mtc0_config2(t0);
3630             rn = "Config2";
3631             /* Stop translation as we may have switched the execution mode */
3632             ctx->bstate = BS_STOP;
3633             break;
3634         case 3:
3635             /* ignored, read only */
3636             rn = "Config3";
3637             break;
3638         /* 4,5 are reserved */
3639         /* 6,7 are implementation dependent */
3640         case 6:
3641             /* ignored */
3642             rn = "Config6";
3643             break;
3644         case 7:
3645             /* ignored */
3646             rn = "Config7";
3647             break;
3648         default:
3649             rn = "Invalid config selector";
3650             goto die;
3651         }
3652         break;
3653     case 17:
3654         switch (sel) {
3655         case 0:
3656             /* ignored */
3657             rn = "LLAddr";
3658             break;
3659         default:
3660             goto die;
3661         }
3662         break;
3663     case 18:
3664         switch (sel) {
3665         case 0 ... 7:
3666             gen_helper_1i(mtc0_watchlo, t0, sel);
3667             rn = "WatchLo";
3668             break;
3669         default:
3670             goto die;
3671         }
3672         break;
3673     case 19:
3674         switch (sel) {
3675         case 0 ... 7:
3676             gen_helper_1i(mtc0_watchhi, t0, sel);
3677             rn = "WatchHi";
3678             break;
3679         default:
3680             goto die;
3681         }
3682         break;
3683     case 20:
3684         switch (sel) {
3685         case 0:
3686 #if defined(TARGET_MIPS64)
3687             check_insn(env, ctx, ISA_MIPS3);
3688             gen_helper_mtc0_xcontext(t0);
3689             rn = "XContext";
3690             break;
3691 #endif
3692         default:
3693             goto die;
3694         }
3695         break;
3696     case 21:
3697        /* Officially reserved, but sel 0 is used for R1x000 framemask */
3698         switch (sel) {
3699         case 0:
3700             gen_helper_mtc0_framemask(t0);
3701             rn = "Framemask";
3702             break;
3703         default:
3704             goto die;
3705         }
3706         break;
3707     case 22:
3708         /* ignored */
3709         rn = "Diagnostic"; /* implementation dependent */
3710         break;
3711     case 23:
3712         switch (sel) {
3713         case 0:
3714             gen_helper_mtc0_debug(t0); /* EJTAG support */
3715             /* BS_STOP isn't good enough here, hflags may have changed. */
3716             gen_save_pc(ctx->pc + 4);
3717             ctx->bstate = BS_EXCP;
3718             rn = "Debug";
3719             break;
3720         case 1:
3721 //            gen_helper_mtc0_tracecontrol(t0); /* PDtrace support */
3722             rn = "TraceControl";
3723             /* Stop translation as we may have switched the execution mode */
3724             ctx->bstate = BS_STOP;
3725 //            break;
3726         case 2:
3727 //            gen_helper_mtc0_tracecontrol2(t0); /* PDtrace support */
3728             rn = "TraceControl2";
3729             /* Stop translation as we may have switched the execution mode */
3730             ctx->bstate = BS_STOP;
3731 //            break;
3732         case 3:
3733             /* Stop translation as we may have switched the execution mode */
3734             ctx->bstate = BS_STOP;
3735 //            gen_helper_mtc0_usertracedata(t0); /* PDtrace support */
3736             rn = "UserTraceData";
3737             /* Stop translation as we may have switched the execution mode */
3738             ctx->bstate = BS_STOP;
3739 //            break;
3740         case 4:
3741 //            gen_helper_mtc0_tracebpc(t0); /* PDtrace support */
3742             /* Stop translation as we may have switched the execution mode */
3743             ctx->bstate = BS_STOP;
3744             rn = "TraceBPC";
3745 //            break;
3746         default:
3747             goto die;
3748         }
3749         break;
3750     case 24:
3751         switch (sel) {
3752         case 0:
3753             /* EJTAG support */
3754             gen_mtc0_store64(t0, offsetof(CPUState, CP0_DEPC));
3755             rn = "DEPC";
3756             break;
3757         default:
3758             goto die;
3759         }
3760         break;
3761     case 25:
3762         switch (sel) {
3763         case 0:
3764             gen_helper_mtc0_performance0(t0);
3765             rn = "Performance0";
3766             break;
3767         case 1:
3768 //            gen_helper_mtc0_performance1(t0);
3769             rn = "Performance1";
3770 //            break;
3771         case 2:
3772 //            gen_helper_mtc0_performance2(t0);
3773             rn = "Performance2";
3774 //            break;
3775         case 3:
3776 //            gen_helper_mtc0_performance3(t0);
3777             rn = "Performance3";
3778 //            break;
3779         case 4:
3780 //            gen_helper_mtc0_performance4(t0);
3781             rn = "Performance4";
3782 //            break;
3783         case 5:
3784 //            gen_helper_mtc0_performance5(t0);
3785             rn = "Performance5";
3786 //            break;
3787         case 6:
3788 //            gen_helper_mtc0_performance6(t0);
3789             rn = "Performance6";
3790 //            break;
3791         case 7:
3792 //            gen_helper_mtc0_performance7(t0);
3793             rn = "Performance7";
3794 //            break;
3795         default:
3796             goto die;
3797         }
3798        break;
3799     case 26:
3800         /* ignored */
3801         rn = "ECC";
3802         break;
3803     case 27:
3804         switch (sel) {
3805         case 0 ... 3:
3806             /* ignored */
3807             rn = "CacheErr";
3808             break;
3809         default:
3810             goto die;
3811         }
3812        break;
3813     case 28:
3814         switch (sel) {
3815         case 0:
3816         case 2:
3817         case 4:
3818         case 6:
3819             gen_helper_mtc0_taglo(t0);
3820             rn = "TagLo";
3821             break;
3822         case 1:
3823         case 3:
3824         case 5:
3825         case 7:
3826             gen_helper_mtc0_datalo(t0);
3827             rn = "DataLo";
3828             break;
3829         default:
3830             goto die;
3831         }
3832         break;
3833     case 29:
3834         switch (sel) {
3835         case 0:
3836         case 2:
3837         case 4:
3838         case 6:
3839             gen_helper_mtc0_taghi(t0);
3840             rn = "TagHi";
3841             break;
3842         case 1:
3843         case 3:
3844         case 5:
3845         case 7:
3846             gen_helper_mtc0_datahi(t0);
3847             rn = "DataHi";
3848             break;
3849         default:
3850             rn = "invalid sel";
3851             goto die;
3852         }
3853        break;
3854     case 30:
3855         switch (sel) {
3856         case 0:
3857             gen_mtc0_store64(t0, offsetof(CPUState, CP0_ErrorEPC));
3858             rn = "ErrorEPC";
3859             break;
3860         default:
3861             goto die;
3862         }
3863         break;
3864     case 31:
3865         switch (sel) {
3866         case 0:
3867             /* EJTAG support */
3868             gen_mtc0_store32(t0, offsetof(CPUState, CP0_DESAVE));
3869             rn = "DESAVE";
3870             break;
3871         default:
3872             goto die;
3873         }
3874         /* Stop translation as we may have switched the execution mode */
3875         ctx->bstate = BS_STOP;
3876         break;
3877     default:
3878        goto die;
3879     }
3880     LOG_DISAS("mtc0 %s (reg %d sel %d)\n", rn, reg, sel);
3881     /* For simplicity assume that all writes can cause interrupts.  */
3882     if (use_icount) {
3883         gen_io_end();
3884         ctx->bstate = BS_STOP;
3885     }
3886     return;
3887
3888 die:
3889     LOG_DISAS("mtc0 %s (reg %d sel %d)\n", rn, reg, sel);
3890     generate_exception(ctx, EXCP_RI);
3891 }
3892
3893 #if defined(TARGET_MIPS64)
3894 static void gen_dmfc0 (CPUState *env, DisasContext *ctx, TCGv t0, int reg, int sel)
3895 {
3896     const char *rn = "invalid";
3897
3898     if (sel != 0)
3899         check_insn(env, ctx, ISA_MIPS64);
3900
3901     switch (reg) {
3902     case 0:
3903         switch (sel) {
3904         case 0:
3905             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Index));
3906             rn = "Index";
3907             break;
3908         case 1:
3909             check_insn(env, ctx, ASE_MT);
3910             gen_helper_mfc0_mvpcontrol(t0);
3911             rn = "MVPControl";
3912             break;
3913         case 2:
3914             check_insn(env, ctx, ASE_MT);
3915             gen_helper_mfc0_mvpconf0(t0);
3916             rn = "MVPConf0";
3917             break;
3918         case 3:
3919             check_insn(env, ctx, ASE_MT);
3920             gen_helper_mfc0_mvpconf1(t0);
3921             rn = "MVPConf1";
3922             break;
3923         default:
3924             goto die;
3925         }
3926         break;
3927     case 1:
3928         switch (sel) {
3929         case 0:
3930             gen_helper_mfc0_random(t0);
3931             rn = "Random";
3932             break;
3933         case 1:
3934             check_insn(env, ctx, ASE_MT);
3935             gen_mfc0_load32(t0, offsetof(CPUState, CP0_VPEControl));
3936             rn = "VPEControl";
3937             break;
3938         case 2:
3939             check_insn(env, ctx, ASE_MT);
3940             gen_mfc0_load32(t0, offsetof(CPUState, CP0_VPEConf0));
3941             rn = "VPEConf0";
3942             break;
3943         case 3:
3944             check_insn(env, ctx, ASE_MT);
3945             gen_mfc0_load32(t0, offsetof(CPUState, CP0_VPEConf1));
3946             rn = "VPEConf1";
3947             break;
3948         case 4:
3949             check_insn(env, ctx, ASE_MT);
3950             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_YQMask));
3951             rn = "YQMask";
3952             break;
3953         case 5:
3954             check_insn(env, ctx, ASE_MT);
3955             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_VPESchedule));
3956             rn = "VPESchedule";
3957             break;
3958         case 6:
3959             check_insn(env, ctx, ASE_MT);
3960             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_VPEScheFBack));
3961             rn = "VPEScheFBack";
3962             break;
3963         case 7:
3964             check_insn(env, ctx, ASE_MT);
3965             gen_mfc0_load32(t0, offsetof(CPUState, CP0_VPEOpt));
3966             rn = "VPEOpt";
3967             break;
3968         default:
3969             goto die;
3970         }
3971         break;
3972     case 2:
3973         switch (sel) {
3974         case 0:
3975             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_EntryLo0));
3976             rn = "EntryLo0";
3977             break;
3978         case 1:
3979             check_insn(env, ctx, ASE_MT);
3980             gen_helper_mfc0_tcstatus(t0);
3981             rn = "TCStatus";
3982             break;
3983         case 2:
3984             check_insn(env, ctx, ASE_MT);
3985             gen_helper_mfc0_tcbind(t0);
3986             rn = "TCBind";
3987             break;
3988         case 3:
3989             check_insn(env, ctx, ASE_MT);
3990             gen_helper_dmfc0_tcrestart(t0);
3991             rn = "TCRestart";
3992             break;
3993         case 4:
3994             check_insn(env, ctx, ASE_MT);
3995             gen_helper_dmfc0_tchalt(t0);
3996             rn = "TCHalt";
3997             break;
3998         case 5:
3999             check_insn(env, ctx, ASE_MT);
4000             gen_helper_dmfc0_tccontext(t0);
4001             rn = "TCContext";
4002             break;
4003         case 6:
4004             check_insn(env, ctx, ASE_MT);
4005             gen_helper_dmfc0_tcschedule(t0);
4006             rn = "TCSchedule";
4007             break;
4008         case 7:
4009             check_insn(env, ctx, ASE_MT);
4010             gen_helper_dmfc0_tcschefback(t0);
4011             rn = "TCScheFBack";
4012             break;
4013         default:
4014             goto die;
4015         }
4016         break;
4017     case 3:
4018         switch (sel) {
4019         case 0:
4020             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_EntryLo1));
4021             rn = "EntryLo1";
4022             break;
4023         default:
4024             goto die;
4025         }
4026         break;
4027     case 4:
4028         switch (sel) {
4029         case 0:
4030             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_Context));
4031             rn = "Context";
4032             break;
4033         case 1:
4034 //            gen_helper_dmfc0_contextconfig(t0); /* SmartMIPS ASE */
4035             rn = "ContextConfig";
4036 //            break;
4037         default:
4038             goto die;
4039         }
4040         break;
4041     case 5:
4042         switch (sel) {
4043         case 0:
4044             gen_mfc0_load32(t0, offsetof(CPUState, CP0_PageMask));
4045             rn = "PageMask";
4046             break;
4047         case 1:
4048             check_insn(env, ctx, ISA_MIPS32R2);
4049             gen_mfc0_load32(t0, offsetof(CPUState, CP0_PageGrain));
4050             rn = "PageGrain";
4051             break;
4052         default:
4053             goto die;
4054         }
4055         break;
4056     case 6:
4057         switch (sel) {
4058         case 0:
4059             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Wired));
4060             rn = "Wired";
4061             break;
4062         case 1:
4063             check_insn(env, ctx, ISA_MIPS32R2);
4064             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSConf0));
4065             rn = "SRSConf0";
4066             break;
4067         case 2:
4068             check_insn(env, ctx, ISA_MIPS32R2);
4069             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSConf1));
4070             rn = "SRSConf1";
4071             break;
4072         case 3:
4073             check_insn(env, ctx, ISA_MIPS32R2);
4074             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSConf2));
4075             rn = "SRSConf2";
4076             break;
4077         case 4:
4078             check_insn(env, ctx, ISA_MIPS32R2);
4079             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSConf3));
4080             rn = "SRSConf3";
4081             break;
4082         case 5:
4083             check_insn(env, ctx, ISA_MIPS32R2);
4084             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSConf4));
4085             rn = "SRSConf4";
4086             break;
4087         default:
4088             goto die;
4089         }
4090         break;
4091     case 7:
4092         switch (sel) {
4093         case 0:
4094             check_insn(env, ctx, ISA_MIPS32R2);
4095             gen_mfc0_load32(t0, offsetof(CPUState, CP0_HWREna));
4096             rn = "HWREna";
4097             break;
4098         default:
4099             goto die;
4100         }
4101         break;
4102     case 8:
4103         switch (sel) {
4104         case 0:
4105             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_BadVAddr));
4106             rn = "BadVAddr";
4107             break;
4108         default:
4109             goto die;
4110         }
4111         break;
4112     case 9:
4113         switch (sel) {
4114         case 0:
4115             /* Mark as an IO operation because we read the time.  */
4116             if (use_icount)
4117                 gen_io_start();
4118             gen_helper_mfc0_count(t0);
4119             if (use_icount) {
4120                 gen_io_end();
4121                 ctx->bstate = BS_STOP;
4122             }
4123             rn = "Count";
4124             break;
4125         /* 6,7 are implementation dependent */
4126         default:
4127             goto die;
4128         }
4129         break;
4130     case 10:
4131         switch (sel) {
4132         case 0:
4133             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_EntryHi));
4134             rn = "EntryHi";
4135             break;
4136         default:
4137             goto die;
4138         }
4139         break;
4140     case 11:
4141         switch (sel) {
4142         case 0:
4143             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Compare));
4144             rn = "Compare";
4145             break;
4146         /* 6,7 are implementation dependent */
4147         default:
4148             goto die;
4149         }
4150         break;
4151     case 12:
4152         switch (sel) {
4153         case 0:
4154             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Status));
4155             rn = "Status";
4156             break;
4157         case 1:
4158             check_insn(env, ctx, ISA_MIPS32R2);
4159             gen_mfc0_load32(t0, offsetof(CPUState, CP0_IntCtl));
4160             rn = "IntCtl";
4161             break;
4162         case 2:
4163             check_insn(env, ctx, ISA_MIPS32R2);
4164             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSCtl));
4165             rn = "SRSCtl";
4166             break;
4167         case 3:
4168             check_insn(env, ctx, ISA_MIPS32R2);
4169             gen_mfc0_load32(t0, offsetof(CPUState, CP0_SRSMap));
4170             rn = "SRSMap";
4171             break;
4172         default:
4173             goto die;
4174         }
4175         break;
4176     case 13:
4177         switch (sel) {
4178         case 0:
4179             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Cause));
4180             rn = "Cause";
4181             break;
4182         default:
4183             goto die;
4184         }
4185         break;
4186     case 14:
4187         switch (sel) {
4188         case 0:
4189             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_EPC));
4190             rn = "EPC";
4191             break;
4192         default:
4193             goto die;
4194         }
4195         break;
4196     case 15:
4197         switch (sel) {
4198         case 0:
4199             gen_mfc0_load32(t0, offsetof(CPUState, CP0_PRid));
4200             rn = "PRid";
4201             break;
4202         case 1:
4203             check_insn(env, ctx, ISA_MIPS32R2);
4204             gen_mfc0_load32(t0, offsetof(CPUState, CP0_EBase));
4205             rn = "EBase";
4206             break;
4207         default:
4208             goto die;
4209         }
4210         break;
4211     case 16:
4212         switch (sel) {
4213         case 0:
4214             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config0));
4215             rn = "Config";
4216             break;
4217         case 1:
4218             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config1));
4219             rn = "Config1";
4220             break;
4221         case 2:
4222             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config2));
4223             rn = "Config2";
4224             break;
4225         case 3:
4226             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config3));
4227             rn = "Config3";
4228             break;
4229        /* 6,7 are implementation dependent */
4230         case 6:
4231             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config6));
4232             rn = "Config6";
4233             break;
4234         case 7:
4235             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Config7));
4236             rn = "Config7";
4237             break;
4238         default:
4239             goto die;
4240         }
4241         break;
4242     case 17:
4243         switch (sel) {
4244         case 0:
4245             gen_helper_dmfc0_lladdr(t0);
4246             rn = "LLAddr";
4247             break;
4248         default:
4249             goto die;
4250         }
4251         break;
4252     case 18:
4253         switch (sel) {
4254         case 0 ... 7:
4255             gen_helper_1i(dmfc0_watchlo, t0, sel);
4256             rn = "WatchLo";
4257             break;
4258         default:
4259             goto die;
4260         }
4261         break;
4262     case 19:
4263         switch (sel) {
4264         case 0 ... 7:
4265             gen_helper_1i(mfc0_watchhi, t0, sel);
4266             rn = "WatchHi";
4267             break;
4268         default:
4269             goto die;
4270         }
4271         break;
4272     case 20:
4273         switch (sel) {
4274         case 0:
4275             check_insn(env, ctx, ISA_MIPS3);
4276             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_XContext));
4277             rn = "XContext";
4278             break;
4279         default:
4280             goto die;
4281         }
4282         break;
4283     case 21:
4284        /* Officially reserved, but sel 0 is used for R1x000 framemask */
4285         switch (sel) {
4286         case 0:
4287             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Framemask));
4288             rn = "Framemask";
4289             break;
4290         default:
4291             goto die;
4292         }
4293         break;
4294     case 22:
4295         tcg_gen_movi_tl(t0, 0); /* unimplemented */
4296         rn = "'Diagnostic"; /* implementation dependent */
4297         break;
4298     case 23:
4299         switch (sel) {
4300         case 0:
4301             gen_helper_mfc0_debug(t0); /* EJTAG support */
4302             rn = "Debug";
4303             break;
4304         case 1:
4305 //            gen_helper_dmfc0_tracecontrol(t0); /* PDtrace support */
4306             rn = "TraceControl";
4307 //            break;
4308         case 2:
4309 //            gen_helper_dmfc0_tracecontrol2(t0); /* PDtrace support */
4310             rn = "TraceControl2";
4311 //            break;
4312         case 3:
4313 //            gen_helper_dmfc0_usertracedata(t0); /* PDtrace support */
4314             rn = "UserTraceData";
4315 //            break;
4316         case 4:
4317 //            gen_helper_dmfc0_tracebpc(t0); /* PDtrace support */
4318             rn = "TraceBPC";
4319 //            break;
4320         default:
4321             goto die;
4322         }
4323         break;
4324     case 24:
4325         switch (sel) {
4326         case 0:
4327             /* EJTAG support */
4328             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_DEPC));
4329             rn = "DEPC";
4330             break;
4331         default:
4332             goto die;
4333         }
4334         break;
4335     case 25:
4336         switch (sel) {
4337         case 0:
4338             gen_mfc0_load32(t0, offsetof(CPUState, CP0_Performance0));
4339             rn = "Performance0";
4340             break;
4341         case 1:
4342 //            gen_helper_dmfc0_performance1(t0);
4343             rn = "Performance1";
4344 //            break;
4345         case 2:
4346 //            gen_helper_dmfc0_performance2(t0);
4347             rn = "Performance2";
4348 //            break;
4349         case 3:
4350 //            gen_helper_dmfc0_performance3(t0);
4351             rn = "Performance3";
4352 //            break;
4353         case 4:
4354 //            gen_helper_dmfc0_performance4(t0);
4355             rn = "Performance4";
4356 //            break;
4357         case 5:
4358 //            gen_helper_dmfc0_performance5(t0);
4359             rn = "Performance5";
4360 //            break;
4361         case 6:
4362 //            gen_helper_dmfc0_performance6(t0);
4363             rn = "Performance6";
4364 //            break;
4365         case 7:
4366 //            gen_helper_dmfc0_performance7(t0);
4367             rn = "Performance7";
4368 //            break;
4369         default:
4370             goto die;
4371         }
4372         break;
4373     case 26:
4374         tcg_gen_movi_tl(t0, 0); /* unimplemented */
4375         rn = "ECC";
4376         break;
4377     case 27:
4378         switch (sel) {
4379         /* ignored */
4380         case 0 ... 3:
4381             tcg_gen_movi_tl(t0, 0); /* unimplemented */
4382             rn = "CacheErr";
4383             break;
4384         default:
4385             goto die;
4386         }
4387         break;
4388     case 28:
4389         switch (sel) {
4390         case 0:
4391         case 2:
4392         case 4:
4393         case 6:
4394             gen_mfc0_load32(t0, offsetof(CPUState, CP0_TagLo));
4395             rn = "TagLo";
4396             break;
4397         case 1:
4398         case 3:
4399         case 5:
4400         case 7:
4401             gen_mfc0_load32(t0, offsetof(CPUState, CP0_DataLo));
4402             rn = "DataLo";
4403             break;
4404         default:
4405             goto die;
4406         }
4407         break;
4408     case 29:
4409         switch (sel) {
4410         case 0:
4411         case 2:
4412         case 4:
4413         case 6:
4414             gen_mfc0_load32(t0, offsetof(CPUState, CP0_TagHi));
4415             rn = "TagHi";
4416             break;
4417         case 1:
4418         case 3:
4419         case 5:
4420         case 7:
4421             gen_mfc0_load32(t0, offsetof(CPUState, CP0_DataHi));
4422             rn = "DataHi";
4423             break;
4424         default:
4425             goto die;
4426         }
4427         break;
4428     case 30:
4429         switch (sel) {
4430         case 0:
4431             tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, CP0_ErrorEPC));
4432             rn = "ErrorEPC";
4433             break;
4434         default:
4435             goto die;
4436         }
4437         break;
4438     case 31:
4439         switch (sel) {
4440         case 0:
4441             /* EJTAG support */
4442             gen_mfc0_load32(t0, offsetof(CPUState, CP0_DESAVE));
4443             rn = "DESAVE";
4444             break;
4445         default:
4446             goto die;
4447         }
4448         break;
4449     default:
4450         goto die;
4451     }
4452     LOG_DISAS("dmfc0 %s (reg %d sel %d)\n", rn, reg, sel);
4453     return;
4454
4455 die:
4456     LOG_DISAS("dmfc0 %s (reg %d sel %d)\n", rn, reg, sel);
4457     generate_exception(ctx, EXCP_RI);
4458 }
4459
4460 static void gen_dmtc0 (CPUState *env, DisasContext *ctx, TCGv t0, int reg, int sel)
4461 {
4462     const char *rn = "invalid";
4463
4464     if (sel != 0)
4465         check_insn(env, ctx, ISA_MIPS64);
4466
4467     if (use_icount)
4468         gen_io_start();
4469
4470     switch (reg) {
4471     case 0:
4472         switch (sel) {
4473         case 0:
4474             gen_helper_mtc0_index(t0);
4475             rn = "Index";
4476             break;
4477         case 1:
4478             check_insn(env, ctx, ASE_MT);
4479             gen_helper_mtc0_mvpcontrol(t0);
4480             rn = "MVPControl";
4481             break;
4482         case 2:
4483             check_insn(env, ctx, ASE_MT);
4484             /* ignored */
4485             rn = "MVPConf0";
4486             break;
4487         case 3:
4488             check_insn(env, ctx, ASE_MT);
4489             /* ignored */
4490             rn = "MVPConf1";
4491             break;
4492         default:
4493             goto die;
4494         }
4495         break;
4496     case 1:
4497         switch (sel) {
4498         case 0:
4499             /* ignored */
4500             rn = "Random";
4501             break;
4502         case 1:
4503             check_insn(env, ctx, ASE_MT);
4504             gen_helper_mtc0_vpecontrol(t0);
4505             rn = "VPEControl";
4506             break;
4507         case 2:
4508             check_insn(env, ctx, ASE_MT);
4509             gen_helper_mtc0_vpeconf0(t0);
4510             rn = "VPEConf0";
4511             break;
4512         case 3:
4513             check_insn(env, ctx, ASE_MT);
4514             gen_helper_mtc0_vpeconf1(t0);
4515             rn = "VPEConf1";
4516             break;
4517         case 4:
4518             check_insn(env, ctx, ASE_MT);
4519             gen_helper_mtc0_yqmask(t0);
4520             rn = "YQMask";
4521             break;
4522         case 5:
4523             check_insn(env, ctx, ASE_MT);
4524             tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, CP0_VPESchedule));
4525             rn = "VPESchedule";
4526             break;
4527         case 6:
4528             check_insn(env, ctx, ASE_MT);
4529             tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, CP0_VPEScheFBack));
4530             rn = "VPEScheFBack";
4531             break;
4532         case 7:
4533             check_insn(env, ctx, ASE_MT);
4534             gen_helper_mtc0_vpeopt(t0);
4535             rn = "VPEOpt";
4536             break;
4537         default:
4538             goto die;
4539         }
4540         break;
4541     case 2:
4542         switch (sel) {
4543         case 0:
4544             gen_helper_mtc0_entrylo0(t0);
4545             rn = "EntryLo0";
4546             break;
4547         case 1:
4548             check_insn(env, ctx, ASE_MT);
4549             gen_helper_mtc0_tcstatus(t0);
4550             rn = "TCStatus";
4551             break;
4552         case 2:
4553             check_insn(env, ctx, ASE_MT);
4554             gen_helper_mtc0_tcbind(t0);
4555             rn = "TCBind";
4556             break;
4557         case 3:
4558             check_insn(env, ctx, ASE_MT);
4559             gen_helper_mtc0_tcrestart(t0);
4560             rn = "TCRestart";
4561             break;
4562         case 4:
4563             check_insn(env, ctx, ASE_MT);
4564             gen_helper_mtc0_tchalt(t0);
4565             rn = "TCHalt";
4566             break;
4567         case 5:
4568             check_insn(env, ctx, ASE_MT);
4569             gen_helper_mtc0_tccontext(t0);
4570             rn = "TCContext";
4571             break;
4572         case 6:
4573             check_insn(env, ctx, ASE_MT);
4574             gen_helper_mtc0_tcschedule(t0);
4575             rn = "TCSchedule";
4576             break;
4577         case 7:
4578             check_insn(env, ctx, ASE_MT);
4579             gen_helper_mtc0_tcschefback(t0);
4580             rn = "TCScheFBack";
4581             break;
4582         default:
4583             goto die;
4584         }
4585         break;
4586     case 3:
4587         switch (sel) {
4588         case 0:
4589             gen_helper_mtc0_entrylo1(t0);
4590             rn = "EntryLo1";
4591             break;
4592         default:
4593             goto die;
4594         }
4595         break;
4596     case 4:
4597         switch (sel) {
4598         case 0:
4599             gen_helper_mtc0_context(t0);
4600             rn = "Context";
4601             break;
4602         case 1:
4603 //           gen_helper_mtc0_contextconfig(t0); /* SmartMIPS ASE */
4604             rn = "ContextConfig";
4605 //           break;
4606         default:
4607             goto die;
4608         }
4609         break;
4610     case 5:
4611         switch (sel) {
4612         case 0:
4613             gen_helper_mtc0_pagemask(t0);
4614             rn = "PageMask";
4615             break;
4616         case 1:
4617             check_insn(env, ctx, ISA_MIPS32R2);
4618             gen_helper_mtc0_pagegrain(t0);
4619             rn = "PageGrain";
4620             break;
4621         default:
4622             goto die;
4623         }
4624         break;
4625     case 6:
4626         switch (sel) {
4627         case 0:
4628             gen_helper_mtc0_wired(t0);
4629             rn = "Wired";
4630             break;
4631         case 1:
4632             check_insn(env, ctx, ISA_MIPS32R2);
4633             gen_helper_mtc0_srsconf0(t0);
4634             rn = "SRSConf0";
4635             break;
4636         case 2:
4637             check_insn(env, ctx, ISA_MIPS32R2);
4638             gen_helper_mtc0_srsconf1(t0);
4639             rn = "SRSConf1";
4640             break;
4641         case 3:
4642             check_insn(env, ctx, ISA_MIPS32R2);
4643             gen_helper_mtc0_srsconf2(t0);
4644             rn = "SRSConf2";
4645             break;
4646         case 4:
4647             check_insn(env, ctx, ISA_MIPS32R2);
4648             gen_helper_mtc0_srsconf3(t0);
4649             rn = "SRSConf3";
4650             break;
4651         case 5:
4652             check_insn(env, ctx, ISA_MIPS32R2);
4653             gen_helper_mtc0_srsconf4(t0);
4654             rn = "SRSConf4";
4655             break;
4656         default:
4657             goto die;
4658         }
4659         break;
4660     case 7:
4661         switch (sel) {
4662         case 0:
4663             check_insn(env, ctx, ISA_MIPS32R2);
4664             gen_helper_mtc0_hwrena(t0);
4665             rn = "HWREna";
4666             break;
4667         default:
4668             goto die;
4669         }
4670         break;
4671     case 8:
4672         /* ignored */
4673         rn = "BadVAddr";
4674         break;
4675     case 9:
4676         switch (sel) {
4677         case 0:
4678             gen_helper_mtc0_count(t0);
4679             rn = "Count";
4680             break;
4681         /* 6,7 are implementation dependent */
4682         default:
4683             goto die;
4684         }
4685         /* Stop translation as we may have switched the execution mode */
4686         ctx->bstate = BS_STOP;
4687         break;
4688     case 10:
4689         switch (sel) {
4690         case 0:
4691             gen_helper_mtc0_entryhi(t0);
4692             rn = "EntryHi";
4693             break;
4694         default:
4695             goto die;
4696         }
4697         break;
4698     case 11:
4699         switch (sel) {
4700         case 0:
4701             gen_helper_mtc0_compare(t0);
4702             rn = "Compare";
4703             break;
4704         /* 6,7 are implementation dependent */
4705         default:
4706             goto die;
4707         }
4708         /* Stop translation as we may have switched the execution mode */
4709         ctx->bstate = BS_STOP;
4710         break;
4711     case 12:
4712         switch (sel) {
4713         case 0:
4714             gen_helper_mtc0_status(t0);
4715             /* BS_STOP isn't good enough here, hflags may have changed. */
4716             gen_save_pc(ctx->pc + 4);
4717             ctx->bstate = BS_EXCP;
4718             rn = "Status";
4719             break;
4720         case 1:
4721             check_insn(env, ctx, ISA_MIPS32R2);
4722             gen_helper_mtc0_intctl(t0);
4723             /* Stop translation as we may have switched the execution mode */
4724             ctx->bstate = BS_STOP;
4725             rn = "IntCtl";
4726             break;
4727         case 2:
4728             check_insn(env, ctx, ISA_MIPS32R2);
4729             gen_helper_mtc0_srsctl(t0);
4730             /* Stop translation as we may have switched the execution mode */
4731             ctx->bstate = BS_STOP;
4732             rn = "SRSCtl";
4733             break;
4734         case 3:
4735             check_insn(env, ctx, ISA_MIPS32R2);
4736             gen_mtc0_store32(t0, offsetof(CPUState, CP0_SRSMap));
4737             /* Stop translation as we may have switched the execution mode */
4738             ctx->bstate = BS_STOP;
4739             rn = "SRSMap";
4740             break;
4741         default:
4742             goto die;
4743         }
4744         break;
4745     case 13:
4746         switch (sel) {
4747         case 0:
4748             gen_helper_mtc0_cause(t0);
4749             rn = "Cause";
4750             break;
4751         default:
4752             goto die;
4753         }
4754         /* Stop translation as we may have switched the execution mode */
4755         ctx->bstate = BS_STOP;
4756         break;
4757     case 14:
4758         switch (sel) {
4759         case 0:
4760             tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, CP0_EPC));
4761             rn = "EPC";
4762             break;
4763         default:
4764             goto die;
4765         }
4766         break;
4767     case 15:
4768         switch (sel) {
4769         case 0:
4770             /* ignored */
4771             rn = "PRid";
4772             break;
4773         case 1:
4774             check_insn(env, ctx, ISA_MIPS32R2);
4775             gen_helper_mtc0_ebase(t0);
4776             rn = "EBase";
4777             break;
4778         default:
4779             goto die;
4780         }
4781         break;
4782     case 16:
4783         switch (sel) {
4784         case 0:
4785             gen_helper_mtc0_config0(t0);
4786             rn = "Config";
4787             /* Stop translation as we may have switched the execution mode */
4788             ctx->bstate = BS_STOP;
4789             break;
4790         case 1:
4791             /* ignored */
4792             rn = "Config1";
4793             break;
4794         case 2:
4795             gen_helper_mtc0_config2(t0);
4796             rn = "Config2";
4797             /* Stop translation as we may have switched the execution mode */
4798             ctx->bstate = BS_STOP;
4799             break;
4800         case 3:
4801             /* ignored */
4802             rn = "Config3";
4803             break;
4804         /* 6,7 are implementation dependent */
4805         default:
4806             rn = "Invalid config selector";
4807             goto die;
4808         }
4809         break;
4810     case 17:
4811         switch (sel) {
4812         case 0:
4813             /* ignored */
4814             rn = "LLAddr";
4815             break;
4816         default:
4817             goto die;
4818         }
4819         break;
4820     case 18:
4821         switch (sel) {
4822         case 0 ... 7:
4823             gen_helper_1i(mtc0_watchlo, t0, sel);
4824             rn = "WatchLo";
4825             break;
4826         default:
4827             goto die;
4828         }
4829         break;
4830     case 19:
4831         switch (sel) {
4832         case 0 ... 7:
4833             gen_helper_1i(mtc0_watchhi, t0, sel);
4834             rn = "WatchHi";
4835             break;
4836         default:
4837             goto die;
4838         }
4839         break;
4840     case 20:
4841         switch (sel) {
4842         case 0:
4843             check_insn(env, ctx, ISA_MIPS3);
4844             gen_helper_mtc0_xcontext(t0);
4845             rn = "XContext";
4846             break;
4847         default:
4848             goto die;
4849         }
4850         break;
4851     case 21:
4852        /* Officially reserved, but sel 0 is used for R1x000 framemask */
4853         switch (sel) {
4854         case 0:
4855             gen_helper_mtc0_framemask(t0);
4856             rn = "Framemask";
4857             break;
4858         default:
4859             goto die;
4860         }
4861         break;
4862     case 22:
4863         /* ignored */
4864         rn = "Diagnostic"; /* implementation dependent */
4865         break;
4866     case 23:
4867         switch (sel) {
4868         case 0:
4869             gen_helper_mtc0_debug(t0); /* EJTAG support */
4870             /* BS_STOP isn't good enough here, hflags may have changed. */
4871             gen_save_pc(ctx->pc + 4);
4872             ctx->bstate = BS_EXCP;
4873             rn = "Debug";
4874             break;
4875         case 1:
4876 //            gen_helper_mtc0_tracecontrol(t0); /* PDtrace support */
4877             /* Stop translation as we may have switched the execution mode */
4878             ctx->bstate = BS_STOP;
4879             rn = "TraceControl";
4880 //            break;
4881         case 2:
4882 //            gen_helper_mtc0_tracecontrol2(t0); /* PDtrace support */
4883             /* Stop translation as we may have switched the execution mode */
4884             ctx->bstate = BS_STOP;
4885             rn = "TraceControl2";
4886 //            break;
4887         case 3:
4888 //            gen_helper_mtc0_usertracedata(t0); /* PDtrace support */
4889             /* Stop translation as we may have switched the execution mode */
4890             ctx->bstate = BS_STOP;
4891             rn = "UserTraceData";
4892 //            break;
4893         case 4:
4894 //            gen_helper_mtc0_tracebpc(t0); /* PDtrace support */
4895             /* Stop translation as we may have switched the execution mode */
4896             ctx->bstate = BS_STOP;
4897             rn = "TraceBPC";
4898 //            break;
4899         default:
4900             goto die;
4901         }
4902         break;
4903     case 24:
4904         switch (sel) {
4905         case 0:
4906             /* EJTAG support */
4907             tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, CP0_DEPC));
4908             rn = "DEPC";
4909             break;
4910         default:
4911             goto die;
4912         }
4913         break;
4914     case 25:
4915         switch (sel) {
4916         case 0:
4917             gen_helper_mtc0_performance0(t0);
4918             rn = "Performance0";
4919             break;
4920         case 1:
4921 //            gen_helper_mtc0_performance1(t0);
4922             rn = "Performance1";
4923 //            break;
4924         case 2:
4925 //            gen_helper_mtc0_performance2(t0);
4926             rn = "Performance2";
4927 //            break;
4928         case 3:
4929 //            gen_helper_mtc0_performance3(t0);
4930             rn = "Performance3";
4931 //            break;
4932         case 4:
4933 //            gen_helper_mtc0_performance4(t0);
4934             rn = "Performance4";
4935 //            break;
4936         case 5:
4937 //            gen_helper_mtc0_performance5(t0);
4938             rn = "Performance5";
4939 //            break;
4940         case 6:
4941 //            gen_helper_mtc0_performance6(t0);
4942             rn = "Performance6";
4943 //            break;
4944         case 7:
4945 //            gen_helper_mtc0_performance7(t0);
4946             rn = "Performance7";
4947 //            break;
4948         default:
4949             goto die;
4950         }
4951         break;
4952     case 26:
4953         /* ignored */
4954         rn = "ECC";
4955         break;
4956     case 27:
4957         switch (sel) {
4958         case 0 ... 3:
4959             /* ignored */
4960             rn = "CacheErr";
4961             break;
4962         default:
4963             goto die;
4964         }
4965         break;
4966     case 28:
4967         switch (sel) {
4968         case 0:
4969         case 2:
4970         case 4:
4971         case 6:
4972             gen_helper_mtc0_taglo(t0);
4973             rn = "TagLo";
4974             break;
4975         case 1:
4976         case 3:
4977         case 5:
4978         case 7:
4979             gen_helper_mtc0_datalo(t0);
4980             rn = "DataLo";
4981             break;
4982         default:
4983             goto die;
4984         }
4985         break;
4986     case 29:
4987         switch (sel) {
4988         case 0:
4989         case 2:
4990         case 4:
4991         case 6:
4992             gen_helper_mtc0_taghi(t0);
4993             rn = "TagHi";
4994             break;
4995         case 1:
4996         case 3:
4997         case 5:
4998         case 7:
4999             gen_helper_mtc0_datahi(t0);
5000             rn = "DataHi";
5001             break;
5002         default:
5003             rn = "invalid sel";
5004             goto die;
5005         }
5006         break;
5007     case 30:
5008         switch (sel) {
5009         case 0:
5010             tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, CP0_ErrorEPC));
5011             rn = "ErrorEPC";
5012             break;
5013         default:
5014             goto die;
5015         }
5016         break;
5017     case 31:
5018         switch (sel) {
5019         case 0:
5020             /* EJTAG support */
5021             gen_mtc0_store32(t0, offsetof(CPUState, CP0_DESAVE));
5022             rn = "DESAVE";
5023             break;
5024         default:
5025             goto die;
5026         }
5027         /* Stop translation as we may have switched the execution mode */
5028         ctx->bstate = BS_STOP;
5029         break;
5030     default:
5031         goto die;
5032     }
5033     LOG_DISAS("dmtc0 %s (reg %d sel %d)\n", rn, reg, sel);
5034     /* For simplicity assume that all writes can cause interrupts.  */
5035     if (use_icount) {
5036         gen_io_end();
5037         ctx->bstate = BS_STOP;
5038     }
5039     return;
5040
5041 die:
5042     LOG_DISAS("dmtc0 %s (reg %d sel %d)\n", rn, reg, sel);
5043     generate_exception(ctx, EXCP_RI);
5044 }
5045 #endif /* TARGET_MIPS64 */
5046
5047 static void gen_mftr(CPUState *env, DisasContext *ctx, int rt, int rd,
5048                      int u, int sel, int h)
5049 {
5050     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
5051     TCGv t0 = tcg_temp_local_new();
5052
5053     if ((env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP)) == 0 &&
5054         ((env->tcs[other_tc].CP0_TCBind & (0xf << CP0TCBd_CurVPE)) !=
5055          (env->active_tc.CP0_TCBind & (0xf << CP0TCBd_CurVPE))))
5056         tcg_gen_movi_tl(t0, -1);
5057     else if ((env->CP0_VPEControl & (0xff << CP0VPECo_TargTC)) >
5058              (env->mvp->CP0_MVPConf0 & (0xff << CP0MVPC0_PTC)))
5059         tcg_gen_movi_tl(t0, -1);
5060     else if (u == 0) {
5061         switch (rt) {
5062         case 2:
5063             switch (sel) {
5064             case 1:
5065                 gen_helper_mftc0_tcstatus(t0);
5066                 break;
5067             case 2:
5068                 gen_helper_mftc0_tcbind(t0);
5069                 break;
5070             case 3:
5071                 gen_helper_mftc0_tcrestart(t0);
5072                 break;
5073             case 4:
5074                 gen_helper_mftc0_tchalt(t0);
5075                 break;
5076             case 5:
5077                 gen_helper_mftc0_tccontext(t0);
5078                 break;
5079             case 6:
5080                 gen_helper_mftc0_tcschedule(t0);
5081                 break;
5082             case 7:
5083                 gen_helper_mftc0_tcschefback(t0);
5084                 break;
5085             default:
5086                 gen_mfc0(env, ctx, t0, rt, sel);
5087                 break;
5088             }
5089             break;
5090         case 10:
5091             switch (sel) {
5092             case 0:
5093                 gen_helper_mftc0_entryhi(t0);
5094                 break;
5095             default:
5096                 gen_mfc0(env, ctx, t0, rt, sel);
5097                 break;
5098             }
5099         case 12:
5100             switch (sel) {
5101             case 0:
5102                 gen_helper_mftc0_status(t0);
5103                 break;
5104             default:
5105                 gen_mfc0(env, ctx, t0, rt, sel);
5106                 break;
5107             }
5108         case 23:
5109             switch (sel) {
5110             case 0:
5111                 gen_helper_mftc0_debug(t0);
5112                 break;
5113             default:
5114                 gen_mfc0(env, ctx, t0, rt, sel);
5115                 break;
5116             }
5117             break;
5118         default:
5119             gen_mfc0(env, ctx, t0, rt, sel);
5120         }
5121     } else switch (sel) {
5122     /* GPR registers. */
5123     case 0:
5124         gen_helper_1i(mftgpr, t0, rt);
5125         break;
5126     /* Auxiliary CPU registers */
5127     case 1:
5128         switch (rt) {
5129         case 0:
5130             gen_helper_1i(mftlo, t0, 0);
5131             break;
5132         case 1:
5133             gen_helper_1i(mfthi, t0, 0);
5134             break;
5135         case 2:
5136             gen_helper_1i(mftacx, t0, 0);
5137             break;
5138         case 4:
5139             gen_helper_1i(mftlo, t0, 1);
5140             break;
5141         case 5:
5142             gen_helper_1i(mfthi, t0, 1);
5143             break;
5144         case 6:
5145             gen_helper_1i(mftacx, t0, 1);
5146             break;
5147         case 8:
5148             gen_helper_1i(mftlo, t0, 2);
5149             break;
5150         case 9:
5151             gen_helper_1i(mfthi, t0, 2);
5152             break;
5153         case 10:
5154             gen_helper_1i(mftacx, t0, 2);
5155             break;
5156         case 12:
5157             gen_helper_1i(mftlo, t0, 3);
5158             break;
5159         case 13:
5160             gen_helper_1i(mfthi, t0, 3);
5161             break;
5162         case 14:
5163             gen_helper_1i(mftacx, t0, 3);
5164             break;
5165         case 16:
5166             gen_helper_mftdsp(t0);
5167             break;
5168         default:
5169             goto die;
5170         }
5171         break;
5172     /* Floating point (COP1). */
5173     case 2:
5174         /* XXX: For now we support only a single FPU context. */
5175         if (h == 0) {
5176             TCGv_i32 fp0 = tcg_temp_new_i32();
5177
5178             gen_load_fpr32(fp0, rt);
5179             tcg_gen_ext_i32_tl(t0, fp0);
5180             tcg_temp_free_i32(fp0);
5181         } else {
5182             TCGv_i32 fp0 = tcg_temp_new_i32();
5183
5184             gen_load_fpr32h(fp0, rt);
5185             tcg_gen_ext_i32_tl(t0, fp0);
5186             tcg_temp_free_i32(fp0);
5187         }
5188         break;
5189     case 3:
5190         /* XXX: For now we support only a single FPU context. */
5191         gen_helper_1i(cfc1, t0, rt);
5192         break;
5193     /* COP2: Not implemented. */
5194     case 4:
5195     case 5:
5196         /* fall through */
5197     default:
5198         goto die;
5199     }
5200     LOG_DISAS("mftr (reg %d u %d sel %d h %d)\n", rt, u, sel, h);
5201     gen_store_gpr(t0, rd);
5202     tcg_temp_free(t0);
5203     return;
5204
5205 die:
5206     tcg_temp_free(t0);
5207     LOG_DISAS("mftr (reg %d u %d sel %d h %d)\n", rt, u, sel, h);
5208     generate_exception(ctx, EXCP_RI);
5209 }
5210
5211 static void gen_mttr(CPUState *env, DisasContext *ctx, int rd, int rt,
5212                      int u, int sel, int h)
5213 {
5214     int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
5215     TCGv t0 = tcg_temp_local_new();
5216
5217     gen_load_gpr(t0, rt);
5218     if ((env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP)) == 0 &&
5219         ((env->tcs[other_tc].CP0_TCBind & (0xf << CP0TCBd_CurVPE)) !=
5220          (env->active_tc.CP0_TCBind & (0xf << CP0TCBd_CurVPE))))
5221         /* NOP */ ;
5222     else if ((env->CP0_VPEControl & (0xff << CP0VPECo_TargTC)) >
5223              (env->mvp->CP0_MVPConf0 & (0xff << CP0MVPC0_PTC)))
5224         /* NOP */ ;
5225     else if (u == 0) {
5226         switch (rd) {
5227         case 2:
5228             switch (sel) {
5229             case 1:
5230                 gen_helper_mttc0_tcstatus(t0);
5231                 break;
5232             case 2:
5233                 gen_helper_mttc0_tcbind(t0);
5234                 break;
5235             case 3:
5236                 gen_helper_mttc0_tcrestart(t0);
5237                 break;
5238             case 4:
5239                 gen_helper_mttc0_tchalt(t0);
5240                 break;
5241             case 5:
5242                 gen_helper_mttc0_tccontext(t0);
5243                 break;
5244             case 6:
5245                 gen_helper_mttc0_tcschedule(t0);
5246                 break;
5247             case 7:
5248                 gen_helper_mttc0_tcschefback(t0);
5249                 break;
5250             default:
5251                 gen_mtc0(env, ctx, t0, rd, sel);
5252                 break;
5253             }
5254             break;
5255         case 10:
5256             switch (sel) {
5257             case 0:
5258                 gen_helper_mttc0_entryhi(t0);
5259                 break;
5260             default:
5261                 gen_mtc0(env, ctx, t0, rd, sel);
5262                 break;
5263             }
5264         case 12:
5265             switch (sel) {
5266             case 0:
5267                 gen_helper_mttc0_status(t0);
5268                 break;
5269             default:
5270                 gen_mtc0(env, ctx, t0, rd, sel);
5271                 break;
5272             }
5273         case 23:
5274             switch (sel) {
5275             case 0:
5276                 gen_helper_mttc0_debug(t0);
5277                 break;
5278             default:
5279                 gen_mtc0(env, ctx, t0, rd, sel);
5280                 break;
5281             }
5282             break;
5283         default:
5284             gen_mtc0(env, ctx, t0, rd, sel);
5285         }
5286     } else switch (sel) {
5287     /* GPR registers. */
5288     case 0:
5289         gen_helper_1i(mttgpr, t0, rd);
5290         break;
5291     /* Auxiliary CPU registers */
5292     case 1:
5293         switch (rd) {
5294         case 0:
5295             gen_helper_1i(mttlo, t0, 0);
5296             break;
5297         case 1:
5298             gen_helper_1i(mtthi, t0, 0);
5299             break;
5300         case 2:
5301             gen_helper_1i(mttacx, t0, 0);
5302             break;
5303         case 4:
5304             gen_helper_1i(mttlo, t0, 1);
5305             break;
5306         case 5:
5307             gen_helper_1i(mtthi, t0, 1);
5308             break;
5309         case 6:
5310             gen_helper_1i(mttacx, t0, 1);
5311             break;
5312         case 8:
5313             gen_helper_1i(mttlo, t0, 2);
5314             break;
5315         case 9:
5316             gen_helper_1i(mtthi, t0, 2);
5317             break;
5318         case 10:
5319             gen_helper_1i(mttacx, t0, 2);
5320             break;
5321         case 12:
5322             gen_helper_1i(mttlo, t0, 3);
5323             break;
5324         case 13:
5325             gen_helper_1i(mtthi, t0, 3);
5326             break;
5327         case 14:
5328             gen_helper_1i(mttacx, t0, 3);
5329             break;
5330         case 16:
5331             gen_helper_mttdsp(t0);
5332             break;
5333         default:
5334             goto die;
5335         }
5336         break;
5337     /* Floating point (COP1). */
5338     case 2:
5339         /* XXX: For now we support only a single FPU context. */
5340         if (h == 0) {
5341             TCGv_i32 fp0 = tcg_temp_new_i32();
5342
5343             tcg_gen_trunc_tl_i32(fp0, t0);
5344             gen_store_fpr32(fp0, rd);
5345             tcg_temp_free_i32(fp0);
5346         } else {
5347             TCGv_i32 fp0 = tcg_temp_new_i32();
5348
5349             tcg_gen_trunc_tl_i32(fp0, t0);
5350             gen_store_fpr32h(fp0, rd);
5351             tcg_temp_free_i32(fp0);
5352         }
5353         break;
5354     case 3:
5355         /* XXX: For now we support only a single FPU context. */
5356         gen_helper_1i(ctc1, t0, rd);
5357         break;
5358     /* COP2: Not implemented. */
5359     case 4:
5360     case 5:
5361         /* fall through */
5362     default:
5363         goto die;
5364     }
5365     LOG_DISAS("mttr (reg %d u %d sel %d h %d)\n", rd, u, sel, h);
5366     tcg_temp_free(t0);
5367     return;
5368
5369 die:
5370     tcg_temp_free(t0);
5371     LOG_DISAS("mttr (reg %d u %d sel %d h %d)\n", rd, u, sel, h);
5372     generate_exception(ctx, EXCP_RI);
5373 }
5374
5375 static void gen_cp0 (CPUState *env, DisasContext *ctx, uint32_t opc, int rt, int rd)
5376 {
5377     const char *opn = "ldst";
5378
5379     switch (opc) {
5380     case OPC_MFC0:
5381         if (rt == 0) {
5382             /* Treat as NOP. */
5383             return;
5384         }
5385         {
5386             TCGv t0 = tcg_temp_local_new();
5387
5388             gen_mfc0(env, ctx, t0, rd, ctx->opcode & 0x7);
5389             gen_store_gpr(t0, rt);
5390             tcg_temp_free(t0);
5391         }
5392         opn = "mfc0";
5393         break;
5394     case OPC_MTC0:
5395         {
5396             TCGv t0 = tcg_temp_local_new();
5397
5398             gen_load_gpr(t0, rt);
5399             save_cpu_state(ctx, 1);
5400             gen_mtc0(env, ctx, t0, rd, ctx->opcode & 0x7);
5401             tcg_temp_free(t0);
5402         }
5403         opn = "mtc0";
5404         break;
5405 #if defined(TARGET_MIPS64)
5406     case OPC_DMFC0:
5407         check_insn(env, ctx, ISA_MIPS3);
5408         if (rt == 0) {
5409             /* Treat as NOP. */
5410             return;
5411         }
5412         {
5413             TCGv t0 = tcg_temp_local_new();
5414
5415             gen_dmfc0(env, ctx, t0, rd, ctx->opcode & 0x7);
5416             gen_store_gpr(t0, rt);
5417             tcg_temp_free(t0);
5418         }
5419         opn = "dmfc0";
5420         break;
5421     case OPC_DMTC0:
5422         check_insn(env, ctx, ISA_MIPS3);
5423         {
5424             TCGv t0 = tcg_temp_local_new();
5425
5426             gen_load_gpr(t0, rt);
5427             save_cpu_state(ctx, 1);
5428             gen_dmtc0(env, ctx, t0, rd, ctx->opcode & 0x7);
5429             tcg_temp_free(t0);
5430         }
5431         opn = "dmtc0";
5432         break;
5433 #endif
5434     case OPC_MFTR:
5435         check_insn(env, ctx, ASE_MT);
5436         if (rd == 0) {
5437             /* Treat as NOP. */
5438             return;
5439         }
5440         gen_mftr(env, ctx, rt, rd, (ctx->opcode >> 5) & 1,
5441                  ctx->opcode & 0x7, (ctx->opcode >> 4) & 1);
5442         opn = "mftr";
5443         break;
5444     case OPC_MTTR:
5445         check_insn(env, ctx, ASE_MT);
5446         gen_mttr(env, ctx, rd, rt, (ctx->opcode >> 5) & 1,
5447                  ctx->opcode & 0x7, (ctx->opcode >> 4) & 1);
5448         opn = "mttr";
5449         break;
5450     case OPC_TLBWI:
5451         opn = "tlbwi";
5452         if (!env->tlb->helper_tlbwi)
5453             goto die;
5454         gen_helper_tlbwi();
5455         break;
5456     case OPC_TLBWR:
5457         opn = "tlbwr";
5458         if (!env->tlb->helper_tlbwr)
5459             goto die;
5460         gen_helper_tlbwr();
5461         break;
5462     case OPC_TLBP:
5463         opn = "tlbp";
5464         if (!env->tlb->helper_tlbp)
5465             goto die;
5466         gen_helper_tlbp();
5467         break;
5468     case OPC_TLBR:
5469         opn = "tlbr";
5470         if (!env->tlb->helper_tlbr)
5471             goto die;
5472         gen_helper_tlbr();
5473         break;
5474     case OPC_ERET:
5475         opn = "eret";
5476         check_insn(env, ctx, ISA_MIPS2);
5477         save_cpu_state(ctx, 1);
5478         gen_helper_eret();
5479         ctx->bstate = BS_EXCP;
5480         break;
5481     case OPC_DERET:
5482         opn = "deret";
5483         check_insn(env, ctx, ISA_MIPS32);
5484         if (!(ctx->hflags & MIPS_HFLAG_DM)) {
5485             MIPS_INVAL(opn);
5486             generate_exception(ctx, EXCP_RI);
5487         } else {
5488             save_cpu_state(ctx, 1);
5489             gen_helper_deret();
5490             ctx->bstate = BS_EXCP;
5491         }
5492         break;
5493     case OPC_WAIT:
5494         opn = "wait";
5495         check_insn(env, ctx, ISA_MIPS3 | ISA_MIPS32);
5496         /* If we get an exception, we want to restart at next instruction */
5497         ctx->pc += 4;
5498         save_cpu_state(ctx, 1);
5499         ctx->pc -= 4;
5500         gen_helper_wait();
5501         ctx->bstate = BS_EXCP;
5502         break;
5503     default:
5504  die:
5505         MIPS_INVAL(opn);
5506         generate_exception(ctx, EXCP_RI);
5507         return;
5508     }
5509     MIPS_DEBUG("%s %s %d", opn, regnames[rt], rd);
5510 }
5511 #endif /* !CONFIG_USER_ONLY */
5512
5513 /* CP1 Branches (before delay slot) */
5514 static void gen_compute_branch1 (CPUState *env, DisasContext *ctx, uint32_t op,
5515                                  int32_t cc, int32_t offset)
5516 {
5517     target_ulong btarget;
5518     const char *opn = "cp1 cond branch";
5519     TCGv_i32 t0 = tcg_temp_new_i32();
5520
5521     if (cc != 0)
5522         check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
5523
5524     btarget = ctx->pc + 4 + offset;
5525
5526     switch (op) {
5527     case OPC_BC1F:
5528         {
5529             int l1 = gen_new_label();
5530             int l2 = gen_new_label();
5531
5532             get_fp_cond(t0);
5533             tcg_gen_andi_i32(t0, t0, 0x1 << cc);
5534             tcg_gen_brcondi_i32(TCG_COND_EQ, t0, 0, l1);
5535             tcg_gen_movi_i32(bcond, 0);
5536             tcg_gen_br(l2);
5537             gen_set_label(l1);
5538             tcg_gen_movi_i32(bcond, 1);
5539             gen_set_label(l2);
5540         }
5541         opn = "bc1f";
5542         goto not_likely;
5543     case OPC_BC1FL:
5544         {
5545             int l1 = gen_new_label();
5546             int l2 = gen_new_label();
5547
5548             get_fp_cond(t0);
5549             tcg_gen_andi_i32(t0, t0, 0x1 << cc);
5550             tcg_gen_brcondi_i32(TCG_COND_EQ, t0, 0, l1);
5551             tcg_gen_movi_i32(bcond, 0);
5552             tcg_gen_br(l2);
5553             gen_set_label(l1);
5554             tcg_gen_movi_i32(bcond, 1);
5555             gen_set_label(l2);
5556         }
5557         opn = "bc1fl";
5558         goto likely;
5559     case OPC_BC1T:
5560         {
5561             int l1 = gen_new_label();
5562             int l2 = gen_new_label();
5563
5564             get_fp_cond(t0);
5565             tcg_gen_andi_i32(t0, t0, 0x1 << cc);
5566             tcg_gen_brcondi_i32(TCG_COND_NE, t0, 0, l1);
5567             tcg_gen_movi_i32(bcond, 0);
5568             tcg_gen_br(l2);
5569             gen_set_label(l1);
5570             tcg_gen_movi_i32(bcond, 1);
5571             gen_set_label(l2);
5572         }
5573         opn = "bc1t";
5574         goto not_likely;
5575     case OPC_BC1TL:
5576         {
5577             int l1 = gen_new_label();
5578             int l2 = gen_new_label();
5579
5580             get_fp_cond(t0);
5581             tcg_gen_andi_i32(t0, t0, 0x1 << cc);
5582             tcg_gen_brcondi_i32(TCG_COND_NE, t0, 0, l1);
5583             tcg_gen_movi_i32(bcond, 0);
5584             tcg_gen_br(l2);
5585             gen_set_label(l1);
5586             tcg_gen_movi_i32(bcond, 1);
5587             gen_set_label(l2);
5588         }
5589         opn = "bc1tl";
5590     likely:
5591         ctx->hflags |= MIPS_HFLAG_BL;
5592         break;
5593     case OPC_BC1FANY2:
5594         {
5595             int l1 = gen_new_label();
5596             int l2 = gen_new_label();
5597
5598             get_fp_cond(t0);
5599             tcg_gen_andi_i32(t0, t0, 0x3 << cc);
5600             tcg_gen_brcondi_i32(TCG_COND_EQ, t0, 0, l1);
5601             tcg_gen_movi_i32(bcond, 0);
5602             tcg_gen_br(l2);
5603             gen_set_label(l1);
5604             tcg_gen_movi_i32(bcond, 1);
5605             gen_set_label(l2);
5606         }
5607         opn = "bc1any2f";
5608         goto not_likely;
5609     case OPC_BC1TANY2:
5610         {
5611             int l1 = gen_new_label();
5612             int l2 = gen_new_label();
5613
5614             get_fp_cond(t0);
5615             tcg_gen_andi_i32(t0, t0, 0x3 << cc);
5616             tcg_gen_brcondi_i32(TCG_COND_NE, t0, 0, l1);
5617             tcg_gen_movi_i32(bcond, 0);
5618             tcg_gen_br(l2);
5619             gen_set_label(l1);
5620             tcg_gen_movi_i32(bcond, 1);
5621             gen_set_label(l2);
5622         }
5623         opn = "bc1any2t";
5624         goto not_likely;
5625     case OPC_BC1FANY4:
5626         {
5627             int l1 = gen_new_label();
5628             int l2 = gen_new_label();
5629
5630             get_fp_cond(t0);
5631             tcg_gen_andi_i32(t0, t0, 0xf << cc);
5632             tcg_gen_brcondi_i32(TCG_COND_EQ, t0, 0, l1);
5633             tcg_gen_movi_i32(bcond, 0);
5634             tcg_gen_br(l2);
5635             gen_set_label(l1);
5636             tcg_gen_movi_i32(bcond, 1);
5637             gen_set_label(l2);
5638         }
5639         opn = "bc1any4f";
5640         goto not_likely;
5641     case OPC_BC1TANY4:
5642         {
5643             int l1 = gen_new_label();
5644             int l2 = gen_new_label();
5645
5646             get_fp_cond(t0);
5647             tcg_gen_andi_i32(t0, t0, 0xf << cc);
5648             tcg_gen_brcondi_i32(TCG_COND_NE, t0, 0, l1);
5649             tcg_gen_movi_i32(bcond, 0);
5650             tcg_gen_br(l2);
5651             gen_set_label(l1);
5652             tcg_gen_movi_i32(bcond, 1);
5653             gen_set_label(l2);
5654         }
5655         opn = "bc1any4t";
5656     not_likely:
5657         ctx->hflags |= MIPS_HFLAG_BC;
5658         break;
5659     default:
5660         MIPS_INVAL(opn);
5661         generate_exception (ctx, EXCP_RI);
5662         goto out;
5663     }
5664     MIPS_DEBUG("%s: cond %02x target " TARGET_FMT_lx, opn,
5665                ctx->hflags, btarget);
5666     ctx->btarget = btarget;
5667
5668  out:
5669     tcg_temp_free_i32(t0);
5670 }
5671
5672 /* Coprocessor 1 (FPU) */
5673
5674 #define FOP(func, fmt) (((fmt) << 21) | (func))
5675
5676 static void gen_cp1 (DisasContext *ctx, uint32_t opc, int rt, int fs)
5677 {
5678     const char *opn = "cp1 move";
5679     TCGv t0 = tcg_temp_local_new();
5680
5681     switch (opc) {
5682     case OPC_MFC1:
5683         {
5684             TCGv_i32 fp0 = tcg_temp_new_i32();
5685
5686             gen_load_fpr32(fp0, fs);
5687             tcg_gen_ext_i32_tl(t0, fp0);
5688             tcg_temp_free_i32(fp0);
5689         }
5690         gen_store_gpr(t0, rt);
5691         opn = "mfc1";
5692         break;
5693     case OPC_MTC1:
5694         gen_load_gpr(t0, rt);
5695         {
5696             TCGv_i32 fp0 = tcg_temp_new_i32();
5697
5698             tcg_gen_trunc_tl_i32(fp0, t0);
5699             gen_store_fpr32(fp0, fs);
5700             tcg_temp_free_i32(fp0);
5701         }
5702         opn = "mtc1";
5703         break;
5704     case OPC_CFC1:
5705         gen_helper_1i(cfc1, t0, fs);
5706         gen_store_gpr(t0, rt);
5707         opn = "cfc1";
5708         break;
5709     case OPC_CTC1:
5710         gen_load_gpr(t0, rt);
5711         gen_helper_1i(ctc1, t0, fs);
5712         opn = "ctc1";
5713         break;
5714     case OPC_DMFC1:
5715         {
5716             TCGv_i64 fp0 = tcg_temp_new_i64();
5717
5718             gen_load_fpr64(ctx, fp0, fs);
5719             tcg_gen_trunc_i64_tl(t0, fp0);
5720             tcg_temp_free_i64(fp0);
5721         }
5722         gen_store_gpr(t0, rt);
5723         opn = "dmfc1";
5724         break;
5725     case OPC_DMTC1:
5726         gen_load_gpr(t0, rt);
5727         {
5728             TCGv_i64 fp0 = tcg_temp_new_i64();
5729
5730             tcg_gen_extu_tl_i64(fp0, t0);
5731             gen_store_fpr64(ctx, fp0, fs);
5732             tcg_temp_free_i64(fp0);
5733         }
5734         opn = "dmtc1";
5735         break;
5736     case OPC_MFHC1:
5737         {
5738             TCGv_i32 fp0 = tcg_temp_new_i32();
5739
5740             gen_load_fpr32h(fp0, fs);
5741             tcg_gen_ext_i32_tl(t0, fp0);
5742             tcg_temp_free_i32(fp0);
5743         }
5744         gen_store_gpr(t0, rt);
5745         opn = "mfhc1";
5746         break;
5747     case OPC_MTHC1:
5748         gen_load_gpr(t0, rt);
5749         {
5750             TCGv_i32 fp0 = tcg_temp_new_i32();
5751
5752             tcg_gen_trunc_tl_i32(fp0, t0);
5753             gen_store_fpr32h(fp0, fs);
5754             tcg_temp_free_i32(fp0);
5755         }
5756         opn = "mthc1";
5757         break;
5758     default:
5759         MIPS_INVAL(opn);
5760         generate_exception (ctx, EXCP_RI);
5761         goto out;
5762     }
5763     MIPS_DEBUG("%s %s %s", opn, regnames[rt], fregnames[fs]);
5764
5765  out:
5766     tcg_temp_free(t0);
5767 }
5768
5769 static void gen_movci (DisasContext *ctx, int rd, int rs, int cc, int tf)
5770 {
5771     int l1 = gen_new_label();
5772     uint32_t ccbit;
5773     TCGCond cond;
5774     TCGv t0 = tcg_temp_local_new();
5775     TCGv_i32 r_tmp = tcg_temp_new_i32();
5776
5777     if (cc)
5778         ccbit = 1 << (24 + cc);
5779     else
5780         ccbit = 1 << 23;
5781     if (tf)
5782         cond = TCG_COND_EQ;
5783     else
5784         cond = TCG_COND_NE;
5785
5786     gen_load_gpr(t0, rd);
5787     tcg_gen_andi_i32(r_tmp, fpu_fcr31, ccbit);
5788     tcg_gen_brcondi_i32(cond, r_tmp, 0, l1);
5789     tcg_temp_free_i32(r_tmp);
5790     gen_load_gpr(t0, rs);
5791     gen_set_label(l1);
5792     gen_store_gpr(t0, rd);
5793     tcg_temp_free(t0);
5794 }
5795
5796 static inline void gen_movcf_s (int fs, int fd, int cc, int tf)
5797 {
5798     uint32_t ccbit;
5799     int cond;
5800     TCGv_i32 r_tmp1 = tcg_temp_new_i32();
5801     TCGv_i32 fp0 = tcg_temp_local_new_i32();
5802     int l1 = gen_new_label();
5803
5804     if (cc)
5805         ccbit = 1 << (24 + cc);
5806     else
5807         ccbit = 1 << 23;
5808
5809     if (tf)
5810         cond = TCG_COND_EQ;
5811     else
5812         cond = TCG_COND_NE;
5813
5814     gen_load_fpr32(fp0, fd);
5815     tcg_gen_andi_i32(r_tmp1, fpu_fcr31, ccbit);
5816     tcg_gen_brcondi_i32(cond, r_tmp1, 0, l1);
5817     tcg_temp_free_i32(r_tmp1);
5818     gen_load_fpr32(fp0, fs);
5819     gen_set_label(l1);
5820     gen_store_fpr32(fp0, fd);
5821     tcg_temp_free_i32(fp0);
5822 }
5823
5824 static inline void gen_movcf_d (DisasContext *ctx, int fs, int fd, int cc, int tf)
5825 {
5826     uint32_t ccbit;
5827     int cond;
5828     TCGv_i32 r_tmp1 = tcg_temp_new_i32();
5829     TCGv_i64 fp0 = tcg_temp_local_new_i64();
5830     int l1 = gen_new_label();
5831
5832     if (cc)
5833         ccbit = 1 << (24 + cc);
5834     else
5835         ccbit = 1 << 23;
5836
5837     if (tf)
5838         cond = TCG_COND_EQ;
5839     else
5840         cond = TCG_COND_NE;
5841
5842     gen_load_fpr64(ctx, fp0, fd);
5843     tcg_gen_andi_i32(r_tmp1, fpu_fcr31, ccbit);
5844     tcg_gen_brcondi_i32(cond, r_tmp1, 0, l1);
5845     tcg_temp_free_i32(r_tmp1);
5846     gen_load_fpr64(ctx, fp0, fs);
5847     gen_set_label(l1);
5848     gen_store_fpr64(ctx, fp0, fd);
5849     tcg_temp_free_i64(fp0);
5850 }
5851
5852 static inline void gen_movcf_ps (int fs, int fd, int cc, int tf)
5853 {
5854     uint32_t ccbit1, ccbit2;
5855     int cond;
5856     TCGv_i32 r_tmp1 = tcg_temp_new_i32();
5857     TCGv_i32 fp0 = tcg_temp_local_new_i32();
5858     int l1 = gen_new_label();
5859     int l2 = gen_new_label();
5860
5861     if (cc) {
5862         ccbit1 = 1 << (24 + cc);
5863         ccbit2 = 1 << (25 + cc);
5864     } else {
5865         ccbit1 = 1 << 23;
5866         ccbit2 = 1 << 25;
5867     }
5868
5869     if (tf)
5870         cond = TCG_COND_EQ;
5871     else
5872         cond = TCG_COND_NE;
5873
5874     gen_load_fpr32(fp0, fd);
5875     tcg_gen_andi_i32(r_tmp1, fpu_fcr31, ccbit1);
5876     tcg_gen_brcondi_i32(cond, r_tmp1, 0, l1);
5877     gen_load_fpr32(fp0, fs);
5878     gen_set_label(l1);
5879     gen_store_fpr32(fp0, fd);
5880
5881     gen_load_fpr32h(fp0, fd);
5882     tcg_gen_andi_i32(r_tmp1, fpu_fcr31, ccbit2);
5883     tcg_gen_brcondi_i32(cond, r_tmp1, 0, l2);
5884     gen_load_fpr32h(fp0, fs);
5885     gen_set_label(l2);
5886     gen_store_fpr32h(fp0, fd);
5887
5888     tcg_temp_free_i32(r_tmp1);
5889     tcg_temp_free_i32(fp0);
5890 }
5891
5892
5893 static void gen_farith (DisasContext *ctx, uint32_t op1,
5894                         int ft, int fs, int fd, int cc)
5895 {
5896     const char *opn = "farith";
5897     const char *condnames[] = {
5898             "c.f",
5899             "c.un",
5900             "c.eq",
5901             "c.ueq",
5902             "c.olt",
5903             "c.ult",
5904             "c.ole",
5905             "c.ule",
5906             "c.sf",
5907             "c.ngle",
5908             "c.seq",
5909             "c.ngl",
5910             "c.lt",
5911             "c.nge",
5912             "c.le",
5913             "c.ngt",
5914     };
5915     const char *condnames_abs[] = {
5916             "cabs.f",
5917             "cabs.un",
5918             "cabs.eq",
5919             "cabs.ueq",
5920             "cabs.olt",
5921             "cabs.ult",
5922             "cabs.ole",
5923             "cabs.ule",
5924             "cabs.sf",
5925             "cabs.ngle",
5926             "cabs.seq",
5927             "cabs.ngl",
5928             "cabs.lt",
5929             "cabs.nge",
5930             "cabs.le",
5931             "cabs.ngt",
5932     };
5933     enum { BINOP, CMPOP, OTHEROP } optype = OTHEROP;
5934     uint32_t func = ctx->opcode & 0x3f;
5935
5936     switch (ctx->opcode & FOP(0x3f, 0x1f)) {
5937     case FOP(0, 16):
5938         {
5939             TCGv_i32 fp0 = tcg_temp_new_i32();
5940             TCGv_i32 fp1 = tcg_temp_new_i32();
5941
5942             gen_load_fpr32(fp0, fs);
5943             gen_load_fpr32(fp1, ft);
5944             gen_helper_float_add_s(fp0, fp0, fp1);
5945             tcg_temp_free_i32(fp1);
5946             gen_store_fpr32(fp0, fd);
5947             tcg_temp_free_i32(fp0);
5948         }
5949         opn = "add.s";
5950         optype = BINOP;
5951         break;
5952     case FOP(1, 16):
5953         {
5954             TCGv_i32 fp0 = tcg_temp_new_i32();
5955             TCGv_i32 fp1 = tcg_temp_new_i32();
5956
5957             gen_load_fpr32(fp0, fs);
5958             gen_load_fpr32(fp1, ft);
5959             gen_helper_float_sub_s(fp0, fp0, fp1);
5960             tcg_temp_free_i32(fp1);
5961             gen_store_fpr32(fp0, fd);
5962             tcg_temp_free_i32(fp0);
5963         }
5964         opn = "sub.s";
5965         optype = BINOP;
5966         break;
5967     case FOP(2, 16):
5968         {
5969             TCGv_i32 fp0 = tcg_temp_new_i32();
5970             TCGv_i32 fp1 = tcg_temp_new_i32();
5971
5972             gen_load_fpr32(fp0, fs);
5973             gen_load_fpr32(fp1, ft);
5974             gen_helper_float_mul_s(fp0, fp0, fp1);
5975             tcg_temp_free_i32(fp1);
5976             gen_store_fpr32(fp0, fd);
5977             tcg_temp_free_i32(fp0);
5978         }
5979         opn = "mul.s";
5980         optype = BINOP;
5981         break;
5982     case FOP(3, 16):
5983         {
5984             TCGv_i32 fp0 = tcg_temp_new_i32();
5985             TCGv_i32 fp1 = tcg_temp_new_i32();
5986
5987             gen_load_fpr32(fp0, fs);
5988             gen_load_fpr32(fp1, ft);
5989             gen_helper_float_div_s(fp0, fp0, fp1);
5990             tcg_temp_free_i32(fp1);
5991             gen_store_fpr32(fp0, fd);
5992             tcg_temp_free_i32(fp0);
5993         }
5994         opn = "div.s";
5995         optype = BINOP;
5996         break;
5997     case FOP(4, 16):
5998         {
5999             TCGv_i32 fp0 = tcg_temp_new_i32();
6000
6001             gen_load_fpr32(fp0, fs);
6002             gen_helper_float_sqrt_s(fp0, fp0);
6003             gen_store_fpr32(fp0, fd);
6004             tcg_temp_free_i32(fp0);
6005         }
6006         opn = "sqrt.s";
6007         break;
6008     case FOP(5, 16):
6009         {
6010             TCGv_i32 fp0 = tcg_temp_new_i32();
6011
6012             gen_load_fpr32(fp0, fs);
6013             gen_helper_float_abs_s(fp0, fp0);
6014             gen_store_fpr32(fp0, fd);
6015             tcg_temp_free_i32(fp0);
6016         }
6017         opn = "abs.s";
6018         break;
6019     case FOP(6, 16):
6020         {
6021             TCGv_i32 fp0 = tcg_temp_new_i32();
6022
6023             gen_load_fpr32(fp0, fs);
6024             gen_store_fpr32(fp0, fd);
6025             tcg_temp_free_i32(fp0);
6026         }
6027         opn = "mov.s";
6028         break;
6029     case FOP(7, 16):
6030         {
6031             TCGv_i32 fp0 = tcg_temp_new_i32();
6032
6033             gen_load_fpr32(fp0, fs);
6034             gen_helper_float_chs_s(fp0, fp0);
6035             gen_store_fpr32(fp0, fd);
6036             tcg_temp_free_i32(fp0);
6037         }
6038         opn = "neg.s";
6039         break;
6040     case FOP(8, 16):
6041         check_cp1_64bitmode(ctx);
6042         {
6043             TCGv_i32 fp32 = tcg_temp_new_i32();
6044             TCGv_i64 fp64 = tcg_temp_new_i64();
6045
6046             gen_load_fpr32(fp32, fs);
6047             gen_helper_float_roundl_s(fp64, fp32);
6048             tcg_temp_free_i32(fp32);
6049             gen_store_fpr64(ctx, fp64, fd);
6050             tcg_temp_free_i64(fp64);
6051         }
6052         opn = "round.l.s";
6053         break;
6054     case FOP(9, 16):
6055         check_cp1_64bitmode(ctx);
6056         {
6057             TCGv_i32 fp32 = tcg_temp_new_i32();
6058             TCGv_i64 fp64 = tcg_temp_new_i64();
6059
6060             gen_load_fpr32(fp32, fs);
6061             gen_helper_float_truncl_s(fp64, fp32);
6062             tcg_temp_free_i32(fp32);
6063             gen_store_fpr64(ctx, fp64, fd);
6064             tcg_temp_free_i64(fp64);
6065         }
6066         opn = "trunc.l.s";
6067         break;
6068     case FOP(10, 16):
6069         check_cp1_64bitmode(ctx);
6070         {
6071             TCGv_i32 fp32 = tcg_temp_new_i32();
6072             TCGv_i64 fp64 = tcg_temp_new_i64();
6073
6074             gen_load_fpr32(fp32, fs);
6075             gen_helper_float_ceill_s(fp64, fp32);
6076             tcg_temp_free_i32(fp32);
6077             gen_store_fpr64(ctx, fp64, fd);
6078             tcg_temp_free_i64(fp64);
6079         }
6080         opn = "ceil.l.s";
6081         break;
6082     case FOP(11, 16):
6083         check_cp1_64bitmode(ctx);
6084         {
6085             TCGv_i32 fp32 = tcg_temp_new_i32();
6086             TCGv_i64 fp64 = tcg_temp_new_i64();
6087
6088             gen_load_fpr32(fp32, fs);
6089             gen_helper_float_floorl_s(fp64, fp32);
6090             tcg_temp_free_i32(fp32);
6091             gen_store_fpr64(ctx, fp64, fd);
6092             tcg_temp_free_i64(fp64);
6093         }
6094         opn = "floor.l.s";
6095         break;
6096     case FOP(12, 16):
6097         {
6098             TCGv_i32 fp0 = tcg_temp_new_i32();
6099
6100             gen_load_fpr32(fp0, fs);
6101             gen_helper_float_roundw_s(fp0, fp0);
6102             gen_store_fpr32(fp0, fd);
6103             tcg_temp_free_i32(fp0);
6104         }
6105         opn = "round.w.s";
6106         break;
6107     case FOP(13, 16):
6108         {
6109             TCGv_i32 fp0 = tcg_temp_new_i32();
6110
6111             gen_load_fpr32(fp0, fs);
6112             gen_helper_float_truncw_s(fp0, fp0);
6113             gen_store_fpr32(fp0, fd);
6114             tcg_temp_free_i32(fp0);
6115         }
6116         opn = "trunc.w.s";
6117         break;
6118     case FOP(14, 16):
6119         {
6120             TCGv_i32 fp0 = tcg_temp_new_i32();
6121
6122             gen_load_fpr32(fp0, fs);
6123             gen_helper_float_ceilw_s(fp0, fp0);
6124             gen_store_fpr32(fp0, fd);
6125             tcg_temp_free_i32(fp0);
6126         }
6127         opn = "ceil.w.s";
6128         break;
6129     case FOP(15, 16):
6130         {
6131             TCGv_i32 fp0 = tcg_temp_new_i32();
6132
6133             gen_load_fpr32(fp0, fs);
6134             gen_helper_float_floorw_s(fp0, fp0);
6135             gen_store_fpr32(fp0, fd);
6136             tcg_temp_free_i32(fp0);
6137         }
6138         opn = "floor.w.s";
6139         break;
6140     case FOP(17, 16):
6141         gen_movcf_s(fs, fd, (ft >> 2) & 0x7, ft & 0x1);
6142         opn = "movcf.s";
6143         break;
6144     case FOP(18, 16):
6145         {
6146             int l1 = gen_new_label();
6147             TCGv t0 = tcg_temp_new();
6148             TCGv_i32 fp0 = tcg_temp_local_new_i32();
6149
6150             gen_load_gpr(t0, ft);
6151             tcg_gen_brcondi_tl(TCG_COND_NE, t0, 0, l1);
6152             gen_load_fpr32(fp0, fs);
6153             gen_store_fpr32(fp0, fd);
6154             tcg_temp_free_i32(fp0);
6155             gen_set_label(l1);
6156             tcg_temp_free(t0);
6157         }
6158         opn = "movz.s";
6159         break;
6160     case FOP(19, 16):
6161         {
6162             int l1 = gen_new_label();
6163             TCGv t0 = tcg_temp_new();
6164             TCGv_i32 fp0 = tcg_temp_local_new_i32();
6165
6166             gen_load_gpr(t0, ft);
6167             tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
6168             gen_load_fpr32(fp0, fs);
6169             gen_store_fpr32(fp0, fd);
6170             tcg_temp_free_i32(fp0);
6171             gen_set_label(l1);
6172             tcg_temp_free(t0);
6173         }
6174         opn = "movn.s";
6175         break;
6176     case FOP(21, 16):
6177         check_cop1x(ctx);
6178         {
6179             TCGv_i32 fp0 = tcg_temp_new_i32();
6180
6181             gen_load_fpr32(fp0, fs);
6182             gen_helper_float_recip_s(fp0, fp0);
6183             gen_store_fpr32(fp0, fd);
6184             tcg_temp_free_i32(fp0);
6185         }
6186         opn = "recip.s";
6187         break;
6188     case FOP(22, 16):
6189         check_cop1x(ctx);
6190         {
6191             TCGv_i32 fp0 = tcg_temp_new_i32();
6192
6193             gen_load_fpr32(fp0, fs);
6194             gen_helper_float_rsqrt_s(fp0, fp0);
6195             gen_store_fpr32(fp0, fd);
6196             tcg_temp_free_i32(fp0);
6197         }
6198         opn = "rsqrt.s";
6199         break;
6200     case FOP(28, 16):
6201         check_cp1_64bitmode(ctx);
6202         {
6203             TCGv_i32 fp0 = tcg_temp_new_i32();
6204             TCGv_i32 fp1 = tcg_temp_new_i32();
6205
6206             gen_load_fpr32(fp0, fs);
6207             gen_load_fpr32(fp1, fd);
6208             gen_helper_float_recip2_s(fp0, fp0, fp1);
6209             tcg_temp_free_i32(fp1);
6210             gen_store_fpr32(fp0, fd);
6211             tcg_temp_free_i32(fp0);
6212         }
6213         opn = "recip2.s";
6214         break;
6215     case FOP(29, 16):
6216         check_cp1_64bitmode(ctx);
6217         {
6218             TCGv_i32 fp0 = tcg_temp_new_i32();
6219
6220             gen_load_fpr32(fp0, fs);
6221             gen_helper_float_recip1_s(fp0, fp0);
6222             gen_store_fpr32(fp0, fd);
6223             tcg_temp_free_i32(fp0);
6224         }
6225         opn = "recip1.s";
6226         break;
6227     case FOP(30, 16):
6228         check_cp1_64bitmode(ctx);
6229         {
6230             TCGv_i32 fp0 = tcg_temp_new_i32();
6231
6232             gen_load_fpr32(fp0, fs);
6233             gen_helper_float_rsqrt1_s(fp0, fp0);
6234             gen_store_fpr32(fp0, fd);
6235             tcg_temp_free_i32(fp0);
6236         }
6237         opn = "rsqrt1.s";
6238         break;
6239     case FOP(31, 16):
6240         check_cp1_64bitmode(ctx);
6241         {
6242             TCGv_i32 fp0 = tcg_temp_new_i32();
6243             TCGv_i32 fp1 = tcg_temp_new_i32();
6244
6245             gen_load_fpr32(fp0, fs);
6246             gen_load_fpr32(fp1, ft);
6247             gen_helper_float_rsqrt2_s(fp0, fp0, fp1);
6248             tcg_temp_free_i32(fp1);
6249             gen_store_fpr32(fp0, fd);
6250             tcg_temp_free_i32(fp0);
6251         }
6252         opn = "rsqrt2.s";
6253         break;
6254     case FOP(33, 16):
6255         check_cp1_registers(ctx, fd);
6256         {
6257             TCGv_i32 fp32 = tcg_temp_new_i32();
6258             TCGv_i64 fp64 = tcg_temp_new_i64();
6259
6260             gen_load_fpr32(fp32, fs);
6261             gen_helper_float_cvtd_s(fp64, fp32);
6262             tcg_temp_free_i32(fp32);
6263             gen_store_fpr64(ctx, fp64, fd);
6264             tcg_temp_free_i64(fp64);
6265         }
6266         opn = "cvt.d.s";
6267         break;
6268     case FOP(36, 16):
6269         {
6270             TCGv_i32 fp0 = tcg_temp_new_i32();
6271
6272             gen_load_fpr32(fp0, fs);
6273             gen_helper_float_cvtw_s(fp0, fp0);
6274             gen_store_fpr32(fp0, fd);
6275             tcg_temp_free_i32(fp0);
6276         }
6277         opn = "cvt.w.s";
6278         break;
6279     case FOP(37, 16):
6280         check_cp1_64bitmode(ctx);
6281         {
6282             TCGv_i32 fp32 = tcg_temp_new_i32();
6283             TCGv_i64 fp64 = tcg_temp_new_i64();
6284
6285             gen_load_fpr32(fp32, fs);
6286             gen_helper_float_cvtl_s(fp64, fp32);
6287             tcg_temp_free_i32(fp32);
6288             gen_store_fpr64(ctx, fp64, fd);
6289             tcg_temp_free_i64(fp64);
6290         }
6291         opn = "cvt.l.s";
6292         break;
6293     case FOP(38, 16):
6294         check_cp1_64bitmode(ctx);
6295         {
6296             TCGv_i64 fp64 = tcg_temp_new_i64();
6297             TCGv_i32 fp32_0 = tcg_temp_new_i32();
6298             TCGv_i32 fp32_1 = tcg_temp_new_i32();
6299
6300             gen_load_fpr32(fp32_0, fs);
6301             gen_load_fpr32(fp32_1, ft);
6302             tcg_gen_concat_i32_i64(fp64, fp32_0, fp32_1);
6303             tcg_temp_free_i32(fp32_1);
6304             tcg_temp_free_i32(fp32_0);
6305             gen_store_fpr64(ctx, fp64, fd);
6306             tcg_temp_free_i64(fp64);
6307         }
6308         opn = "cvt.ps.s";
6309         break;
6310     case FOP(48, 16):
6311     case FOP(49, 16):
6312     case FOP(50, 16):
6313     case FOP(51, 16):
6314     case FOP(52, 16):
6315     case FOP(53, 16):
6316     case FOP(54, 16):
6317     case FOP(55, 16):
6318     case FOP(56, 16):
6319     case FOP(57, 16):
6320     case FOP(58, 16):
6321     case FOP(59, 16):
6322     case FOP(60, 16):
6323     case FOP(61, 16):
6324     case FOP(62, 16):
6325     case FOP(63, 16):
6326         {
6327             TCGv_i32 fp0 = tcg_temp_new_i32();
6328             TCGv_i32 fp1 = tcg_temp_new_i32();
6329
6330             gen_load_fpr32(fp0, fs);
6331             gen_load_fpr32(fp1, ft);
6332             if (ctx->opcode & (1 << 6)) {
6333                 check_cop1x(ctx);
6334                 gen_cmpabs_s(func-48, fp0, fp1, cc);
6335                 opn = condnames_abs[func-48];
6336             } else {
6337                 gen_cmp_s(func-48, fp0, fp1, cc);
6338                 opn = condnames[func-48];
6339             }
6340             tcg_temp_free_i32(fp0);
6341             tcg_temp_free_i32(fp1);
6342         }
6343         break;
6344     case FOP(0, 17):
6345         check_cp1_registers(ctx, fs | ft | fd);
6346         {
6347             TCGv_i64 fp0 = tcg_temp_new_i64();
6348             TCGv_i64 fp1 = tcg_temp_new_i64();
6349
6350             gen_load_fpr64(ctx, fp0, fs);
6351             gen_load_fpr64(ctx, fp1, ft);
6352             gen_helper_float_add_d(fp0, fp0, fp1);
6353             tcg_temp_free_i64(fp1);
6354             gen_store_fpr64(ctx, fp0, fd);
6355             tcg_temp_free_i64(fp0);
6356         }
6357         opn = "add.d";
6358         optype = BINOP;
6359         break;
6360     case FOP(1, 17):
6361         check_cp1_registers(ctx, fs | ft | fd);
6362         {
6363             TCGv_i64 fp0 = tcg_temp_new_i64();
6364             TCGv_i64 fp1 = tcg_temp_new_i64();
6365
6366             gen_load_fpr64(ctx, fp0, fs);
6367             gen_load_fpr64(ctx, fp1, ft);
6368             gen_helper_float_sub_d(fp0, fp0, fp1);
6369             tcg_temp_free_i64(fp1);
6370             gen_store_fpr64(ctx, fp0, fd);
6371             tcg_temp_free_i64(fp0);
6372         }
6373         opn = "sub.d";
6374         optype = BINOP;
6375         break;
6376     case FOP(2, 17):
6377         check_cp1_registers(ctx, fs | ft | fd);
6378         {
6379             TCGv_i64 fp0 = tcg_temp_new_i64();
6380             TCGv_i64 fp1 = tcg_temp_new_i64();
6381
6382             gen_load_fpr64(ctx, fp0, fs);
6383             gen_load_fpr64(ctx, fp1, ft);
6384             gen_helper_float_mul_d(fp0, fp0, fp1);
6385             tcg_temp_free_i64(fp1);
6386             gen_store_fpr64(ctx, fp0, fd);
6387             tcg_temp_free_i64(fp0);
6388         }
6389         opn = "mul.d";
6390         optype = BINOP;
6391         break;
6392     case FOP(3, 17):
6393         check_cp1_registers(ctx, fs | ft | fd);
6394         {
6395             TCGv_i64 fp0 = tcg_temp_new_i64();
6396             TCGv_i64 fp1 = tcg_temp_new_i64();
6397
6398             gen_load_fpr64(ctx, fp0, fs);
6399             gen_load_fpr64(ctx, fp1, ft);
6400             gen_helper_float_div_d(fp0, fp0, fp1);
6401             tcg_temp_free_i64(fp1);
6402             gen_store_fpr64(ctx, fp0, fd);
6403             tcg_temp_free_i64(fp0);
6404         }
6405         opn = "div.d";
6406         optype = BINOP;
6407         break;
6408     case FOP(4, 17):
6409         check_cp1_registers(ctx, fs | fd);
6410         {
6411             TCGv_i64 fp0 = tcg_temp_new_i64();
6412
6413             gen_load_fpr64(ctx, fp0, fs);
6414             gen_helper_float_sqrt_d(fp0, fp0);
6415             gen_store_fpr64(ctx, fp0, fd);
6416             tcg_temp_free_i64(fp0);
6417         }
6418         opn = "sqrt.d";
6419         break;
6420     case FOP(5, 17):
6421         check_cp1_registers(ctx, fs | fd);
6422         {
6423             TCGv_i64 fp0 = tcg_temp_new_i64();
6424
6425             gen_load_fpr64(ctx, fp0, fs);
6426             gen_helper_float_abs_d(fp0, fp0);
6427             gen_store_fpr64(ctx, fp0, fd);
6428             tcg_temp_free_i64(fp0);
6429         }
6430         opn = "abs.d";
6431         break;
6432     case FOP(6, 17):
6433         check_cp1_registers(ctx, fs | fd);
6434         {
6435             TCGv_i64 fp0 = tcg_temp_new_i64();
6436
6437             gen_load_fpr64(ctx, fp0, fs);
6438             gen_store_fpr64(ctx, fp0, fd);
6439             tcg_temp_free_i64(fp0);
6440         }
6441         opn = "mov.d";
6442         break;
6443     case FOP(7, 17):
6444         check_cp1_registers(ctx, fs | fd);
6445         {
6446             TCGv_i64 fp0 = tcg_temp_new_i64();
6447
6448             gen_load_fpr64(ctx, fp0, fs);
6449             gen_helper_float_chs_d(fp0, fp0);
6450             gen_store_fpr64(ctx, fp0, fd);
6451             tcg_temp_free_i64(fp0);
6452         }
6453         opn = "neg.d";
6454         break;
6455     case FOP(8, 17):
6456         check_cp1_64bitmode(ctx);
6457         {
6458             TCGv_i64 fp0 = tcg_temp_new_i64();
6459
6460             gen_load_fpr64(ctx, fp0, fs);
6461             gen_helper_float_roundl_d(fp0, fp0);
6462             gen_store_fpr64(ctx, fp0, fd);
6463             tcg_temp_free_i64(fp0);
6464         }
6465         opn = "round.l.d";
6466         break;
6467     case FOP(9, 17):
6468         check_cp1_64bitmode(ctx);
6469         {
6470             TCGv_i64 fp0 = tcg_temp_new_i64();
6471
6472             gen_load_fpr64(ctx, fp0, fs);
6473             gen_helper_float_truncl_d(fp0, fp0);
6474             gen_store_fpr64(ctx, fp0, fd);
6475             tcg_temp_free_i64(fp0);
6476         }
6477         opn = "trunc.l.d";
6478         break;
6479     case FOP(10, 17):
6480         check_cp1_64bitmode(ctx);
6481         {
6482             TCGv_i64 fp0 = tcg_temp_new_i64();
6483
6484             gen_load_fpr64(ctx, fp0, fs);
6485             gen_helper_float_ceill_d(fp0, fp0);
6486             gen_store_fpr64(ctx, fp0, fd);
6487             tcg_temp_free_i64(fp0);
6488         }
6489         opn = "ceil.l.d";
6490         break;
6491     case FOP(11, 17):
6492         check_cp1_64bitmode(ctx);
6493         {
6494             TCGv_i64 fp0 = tcg_temp_new_i64();
6495
6496             gen_load_fpr64(ctx, fp0, fs);
6497             gen_helper_float_floorl_d(fp0, fp0);
6498             gen_store_fpr64(ctx, fp0, fd);
6499             tcg_temp_free_i64(fp0);
6500         }
6501         opn = "floor.l.d";
6502         break;
6503     case FOP(12, 17):
6504         check_cp1_registers(ctx, fs);
6505         {
6506             TCGv_i32 fp32 = tcg_temp_new_i32();
6507             TCGv_i64 fp64 = tcg_temp_new_i64();
6508
6509             gen_load_fpr64(ctx, fp64, fs);
6510             gen_helper_float_roundw_d(fp32, fp64);
6511             tcg_temp_free_i64(fp64);
6512             gen_store_fpr32(fp32, fd);
6513             tcg_temp_free_i32(fp32);
6514         }
6515         opn = "round.w.d";
6516         break;
6517     case FOP(13, 17):
6518         check_cp1_registers(ctx, fs);
6519         {
6520             TCGv_i32 fp32 = tcg_temp_new_i32();
6521             TCGv_i64 fp64 = tcg_temp_new_i64();
6522
6523             gen_load_fpr64(ctx, fp64, fs);
6524             gen_helper_float_truncw_d(fp32, fp64);
6525             tcg_temp_free_i64(fp64);
6526             gen_store_fpr32(fp32, fd);
6527             tcg_temp_free_i32(fp32);
6528         }
6529         opn = "trunc.w.d";
6530         break;
6531     case FOP(14, 17):
6532         check_cp1_registers(ctx, fs);
6533         {
6534             TCGv_i32 fp32 = tcg_temp_new_i32();
6535             TCGv_i64 fp64 = tcg_temp_new_i64();
6536
6537             gen_load_fpr64(ctx, fp64, fs);
6538             gen_helper_float_ceilw_d(fp32, fp64);
6539             tcg_temp_free_i64(fp64);
6540             gen_store_fpr32(fp32, fd);
6541             tcg_temp_free_i32(fp32);
6542         }
6543         opn = "ceil.w.d";
6544         break;
6545     case FOP(15, 17):
6546         check_cp1_registers(ctx, fs);
6547         {
6548             TCGv_i32 fp32 = tcg_temp_new_i32();
6549             TCGv_i64 fp64 = tcg_temp_new_i64();
6550
6551             gen_load_fpr64(ctx, fp64, fs);
6552             gen_helper_float_floorw_d(fp32, fp64);
6553             tcg_temp_free_i64(fp64);
6554             gen_store_fpr32(fp32, fd);
6555             tcg_temp_free_i32(fp32);
6556         }
6557         opn = "floor.w.d";
6558         break;
6559     case FOP(17, 17):
6560         gen_movcf_d(ctx, fs, fd, (ft >> 2) & 0x7, ft & 0x1);
6561         opn = "movcf.d";
6562         break;
6563     case FOP(18, 17):
6564         {
6565             int l1 = gen_new_label();
6566             TCGv t0 = tcg_temp_new();
6567             TCGv_i64 fp0 = tcg_temp_local_new_i64();
6568
6569             gen_load_gpr(t0, ft);
6570             tcg_gen_brcondi_tl(TCG_COND_NE, t0, 0, l1);
6571             gen_load_fpr64(ctx, fp0, fs);
6572             gen_store_fpr64(ctx, fp0, fd);
6573             tcg_temp_free_i64(fp0);
6574             gen_set_label(l1);
6575             tcg_temp_free(t0);
6576         }
6577         opn = "movz.d";
6578         break;
6579     case FOP(19, 17):
6580         {
6581             int l1 = gen_new_label();
6582             TCGv t0 = tcg_temp_new();
6583             TCGv_i64 fp0 = tcg_temp_local_new_i64();
6584
6585             gen_load_gpr(t0, ft);
6586             tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
6587             gen_load_fpr64(ctx, fp0, fs);
6588             gen_store_fpr64(ctx, fp0, fd);
6589             tcg_temp_free_i64(fp0);
6590             gen_set_label(l1);
6591             tcg_temp_free(t0);
6592         }
6593         opn = "movn.d";
6594         break;
6595     case FOP(21, 17):
6596         check_cp1_64bitmode(ctx);
6597         {
6598             TCGv_i64 fp0 = tcg_temp_new_i64();
6599
6600             gen_load_fpr64(ctx, fp0, fs);
6601             gen_helper_float_recip_d(fp0, fp0);
6602             gen_store_fpr64(ctx, fp0, fd);
6603             tcg_temp_free_i64(fp0);
6604         }
6605         opn = "recip.d";
6606         break;
6607     case FOP(22, 17):
6608         check_cp1_64bitmode(ctx);
6609         {
6610             TCGv_i64 fp0 = tcg_temp_new_i64();
6611
6612             gen_load_fpr64(ctx, fp0, fs);
6613             gen_helper_float_rsqrt_d(fp0, fp0);
6614             gen_store_fpr64(ctx, fp0, fd);
6615             tcg_temp_free_i64(fp0);
6616         }
6617         opn = "rsqrt.d";
6618         break;
6619     case FOP(28, 17):
6620         check_cp1_64bitmode(ctx);
6621         {
6622             TCGv_i64 fp0 = tcg_temp_new_i64();
6623             TCGv_i64 fp1 = tcg_temp_new_i64();
6624
6625             gen_load_fpr64(ctx, fp0, fs);
6626             gen_load_fpr64(ctx, fp1, ft);
6627             gen_helper_float_recip2_d(fp0, fp0, fp1);
6628             tcg_temp_free_i64(fp1);
6629             gen_store_fpr64(ctx, fp0, fd);
6630             tcg_temp_free_i64(fp0);
6631         }
6632         opn = "recip2.d";
6633         break;
6634     case FOP(29, 17):
6635         check_cp1_64bitmode(ctx);
6636         {
6637             TCGv_i64 fp0 = tcg_temp_new_i64();
6638
6639             gen_load_fpr64(ctx, fp0, fs);
6640             gen_helper_float_recip1_d(fp0, fp0);
6641             gen_store_fpr64(ctx, fp0, fd);
6642             tcg_temp_free_i64(fp0);
6643         }
6644         opn = "recip1.d";
6645         break;
6646     case FOP(30, 17):
6647         check_cp1_64bitmode(ctx);
6648         {
6649             TCGv_i64 fp0 = tcg_temp_new_i64();
6650
6651             gen_load_fpr64(ctx, fp0, fs);
6652             gen_helper_float_rsqrt1_d(fp0, fp0);
6653             gen_store_fpr64(ctx, fp0, fd);
6654             tcg_temp_free_i64(fp0);
6655         }
6656         opn = "rsqrt1.d";
6657         break;
6658     case FOP(31, 17):
6659         check_cp1_64bitmode(ctx);
6660         {
6661             TCGv_i64 fp0 = tcg_temp_new_i64();
6662             TCGv_i64 fp1 = tcg_temp_new_i64();
6663
6664             gen_load_fpr64(ctx, fp0, fs);
6665             gen_load_fpr64(ctx, fp1, ft);
6666             gen_helper_float_rsqrt2_d(fp0, fp0, fp1);
6667             tcg_temp_free_i64(fp1);
6668             gen_store_fpr64(ctx, fp0, fd);
6669             tcg_temp_free_i64(fp0);
6670         }
6671         opn = "rsqrt2.d";
6672         break;
6673     case FOP(48, 17):
6674     case FOP(49, 17):
6675     case FOP(50, 17):
6676     case FOP(51, 17):
6677     case FOP(52, 17):
6678     case FOP(53, 17):
6679     case FOP(54, 17):
6680     case FOP(55, 17):
6681     case FOP(56, 17):
6682     case FOP(57, 17):
6683     case FOP(58, 17):
6684     case FOP(59, 17):
6685     case FOP(60, 17):
6686     case FOP(61, 17):
6687     case FOP(62, 17):
6688     case FOP(63, 17):
6689         {
6690             TCGv_i64 fp0 = tcg_temp_new_i64();
6691             TCGv_i64 fp1 = tcg_temp_new_i64();
6692
6693             gen_load_fpr64(ctx, fp0, fs);
6694             gen_load_fpr64(ctx, fp1, ft);
6695             if (ctx->opcode & (1 << 6)) {
6696                 check_cop1x(ctx);
6697                 check_cp1_registers(ctx, fs | ft);
6698                 gen_cmpabs_d(func-48, fp0, fp1, cc);
6699                 opn = condnames_abs[func-48];
6700             } else {
6701                 check_cp1_registers(ctx, fs | ft);
6702                 gen_cmp_d(func-48, fp0, fp1, cc);
6703                 opn = condnames[func-48];
6704             }
6705             tcg_temp_free_i64(fp0);
6706             tcg_temp_free_i64(fp1);
6707         }
6708         break;
6709     case FOP(32, 17):
6710         check_cp1_registers(ctx, fs);
6711         {
6712             TCGv_i32 fp32 = tcg_temp_new_i32();
6713             TCGv_i64 fp64 = tcg_temp_new_i64();
6714
6715             gen_load_fpr64(ctx, fp64, fs);
6716             gen_helper_float_cvts_d(fp32, fp64);
6717             tcg_temp_free_i64(fp64);
6718             gen_store_fpr32(fp32, fd);
6719             tcg_temp_free_i32(fp32);
6720         }
6721         opn = "cvt.s.d";
6722         break;
6723     case FOP(36, 17):
6724         check_cp1_registers(ctx, fs);
6725         {
6726             TCGv_i32 fp32 = tcg_temp_new_i32();
6727             TCGv_i64 fp64 = tcg_temp_new_i64();
6728
6729             gen_load_fpr64(ctx, fp64, fs);
6730             gen_helper_float_cvtw_d(fp32, fp64);
6731             tcg_temp_free_i64(fp64);
6732             gen_store_fpr32(fp32, fd);
6733             tcg_temp_free_i32(fp32);
6734         }
6735         opn = "cvt.w.d";
6736         break;
6737     case FOP(37, 17):
6738         check_cp1_64bitmode(ctx);
6739         {
6740             TCGv_i64 fp0 = tcg_temp_new_i64();
6741
6742             gen_load_fpr64(ctx, fp0, fs);
6743             gen_helper_float_cvtl_d(fp0, fp0);
6744             gen_store_fpr64(ctx, fp0, fd);
6745             tcg_temp_free_i64(fp0);
6746         }
6747         opn = "cvt.l.d";
6748         break;
6749     case FOP(32, 20):
6750         {
6751             TCGv_i32 fp0 = tcg_temp_new_i32();
6752
6753             gen_load_fpr32(fp0, fs);
6754             gen_helper_float_cvts_w(fp0, fp0);
6755             gen_store_fpr32(fp0, fd);
6756             tcg_temp_free_i32(fp0);
6757         }
6758         opn = "cvt.s.w";
6759         break;
6760     case FOP(33, 20):
6761         check_cp1_registers(ctx, fd);
6762         {
6763             TCGv_i32 fp32 = tcg_temp_new_i32();
6764             TCGv_i64 fp64 = tcg_temp_new_i64();
6765
6766             gen_load_fpr32(fp32, fs);
6767             gen_helper_float_cvtd_w(fp64, fp32);
6768             tcg_temp_free_i32(fp32);
6769             gen_store_fpr64(ctx, fp64, fd);
6770             tcg_temp_free_i64(fp64);
6771         }
6772         opn = "cvt.d.w";
6773         break;
6774     case FOP(32, 21):
6775         check_cp1_64bitmode(ctx);
6776         {
6777             TCGv_i32 fp32 = tcg_temp_new_i32();
6778             TCGv_i64 fp64 = tcg_temp_new_i64();
6779
6780             gen_load_fpr64(ctx, fp64, fs);
6781             gen_helper_float_cvts_l(fp32, fp64);
6782             tcg_temp_free_i64(fp64);
6783             gen_store_fpr32(fp32, fd);
6784             tcg_temp_free_i32(fp32);
6785         }
6786         opn = "cvt.s.l";
6787         break;
6788     case FOP(33, 21):
6789         check_cp1_64bitmode(ctx);
6790         {
6791             TCGv_i64 fp0 = tcg_temp_new_i64();
6792
6793             gen_load_fpr64(ctx, fp0, fs);
6794             gen_helper_float_cvtd_l(fp0, fp0);
6795             gen_store_fpr64(ctx, fp0, fd);
6796             tcg_temp_free_i64(fp0);
6797         }
6798         opn = "cvt.d.l";
6799         break;
6800     case FOP(38, 20):
6801         check_cp1_64bitmode(ctx);
6802         {
6803             TCGv_i64 fp0 = tcg_temp_new_i64();
6804
6805             gen_load_fpr64(ctx, fp0, fs);
6806             gen_helper_float_cvtps_pw(fp0, fp0);
6807             gen_store_fpr64(ctx, fp0, fd);
6808             tcg_temp_free_i64(fp0);
6809         }
6810         opn = "cvt.ps.pw";
6811         break;
6812     case FOP(0, 22):
6813         check_cp1_64bitmode(ctx);
6814         {
6815             TCGv_i64 fp0 = tcg_temp_new_i64();
6816             TCGv_i64 fp1 = tcg_temp_new_i64();
6817
6818             gen_load_fpr64(ctx, fp0, fs);
6819             gen_load_fpr64(ctx, fp1, ft);
6820             gen_helper_float_add_ps(fp0, fp0, fp1);
6821             tcg_temp_free_i64(fp1);
6822             gen_store_fpr64(ctx, fp0, fd);
6823             tcg_temp_free_i64(fp0);
6824         }
6825         opn = "add.ps";
6826         break;
6827     case FOP(1, 22):
6828         check_cp1_64bitmode(ctx);
6829         {
6830             TCGv_i64 fp0 = tcg_temp_new_i64();
6831             TCGv_i64 fp1 = tcg_temp_new_i64();
6832
6833             gen_load_fpr64(ctx, fp0, fs);
6834             gen_load_fpr64(ctx, fp1, ft);
6835             gen_helper_float_sub_ps(fp0, fp0, fp1);
6836             tcg_temp_free_i64(fp1);
6837             gen_store_fpr64(ctx, fp0, fd);
6838             tcg_temp_free_i64(fp0);
6839         }
6840         opn = "sub.ps";
6841         break;
6842     case FOP(2, 22):
6843         check_cp1_64bitmode(ctx);
6844         {
6845             TCGv_i64 fp0 = tcg_temp_new_i64();
6846             TCGv_i64 fp1 = tcg_temp_new_i64();
6847
6848             gen_load_fpr64(ctx, fp0, fs);
6849             gen_load_fpr64(ctx, fp1, ft);
6850             gen_helper_float_mul_ps(fp0, fp0, fp1);
6851             tcg_temp_free_i64(fp1);
6852             gen_store_fpr64(ctx, fp0, fd);
6853             tcg_temp_free_i64(fp0);
6854         }
6855         opn = "mul.ps";
6856         break;
6857     case FOP(5, 22):
6858         check_cp1_64bitmode(ctx);
6859         {
6860             TCGv_i64 fp0 = tcg_temp_new_i64();
6861
6862             gen_load_fpr64(ctx, fp0, fs);
6863             gen_helper_float_abs_ps(fp0, fp0);
6864             gen_store_fpr64(ctx, fp0, fd);
6865             tcg_temp_free_i64(fp0);
6866         }
6867         opn = "abs.ps";
6868         break;
6869     case FOP(6, 22):
6870         check_cp1_64bitmode(ctx);
6871         {
6872             TCGv_i64 fp0 = tcg_temp_new_i64();
6873
6874             gen_load_fpr64(ctx, fp0, fs);
6875             gen_store_fpr64(ctx, fp0, fd);
6876             tcg_temp_free_i64(fp0);
6877         }
6878         opn = "mov.ps";
6879         break;
6880     case FOP(7, 22):
6881         check_cp1_64bitmode(ctx);
6882         {
6883             TCGv_i64 fp0 = tcg_temp_new_i64();
6884
6885             gen_load_fpr64(ctx, fp0, fs);
6886             gen_helper_float_chs_ps(fp0, fp0);
6887             gen_store_fpr64(ctx, fp0, fd);
6888             tcg_temp_free_i64(fp0);
6889         }
6890         opn = "neg.ps";
6891         break;
6892     case FOP(17, 22):
6893         check_cp1_64bitmode(ctx);
6894         gen_movcf_ps(fs, fd, (ft >> 2) & 0x7, ft & 0x1);
6895         opn = "movcf.ps";
6896         break;
6897     case FOP(18, 22):
6898         check_cp1_64bitmode(ctx);
6899         {
6900             int l1 = gen_new_label();
6901             TCGv t0 = tcg_temp_new();
6902             TCGv_i32 fp0 = tcg_temp_local_new_i32();
6903             TCGv_i32 fph0 = tcg_temp_local_new_i32();
6904
6905             gen_load_gpr(t0, ft);
6906             tcg_gen_brcondi_tl(TCG_COND_NE, t0, 0, l1);
6907             gen_load_fpr32(fp0, fs);
6908             gen_load_fpr32h(fph0, fs);
6909             gen_store_fpr32(fp0, fd);
6910             gen_store_fpr32h(fph0, fd);
6911             tcg_temp_free_i32(fp0);
6912             tcg_temp_free_i32(fph0);
6913             gen_set_label(l1);
6914             tcg_temp_free(t0);
6915         }
6916         opn = "movz.ps";
6917         break;
6918     case FOP(19, 22):
6919         check_cp1_64bitmode(ctx);
6920         {
6921             int l1 = gen_new_label();
6922             TCGv t0 = tcg_temp_new();
6923             TCGv_i32 fp0 = tcg_temp_local_new_i32();
6924             TCGv_i32 fph0 = tcg_temp_local_new_i32();
6925
6926             gen_load_gpr(t0, ft);
6927             tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1);
6928             gen_load_fpr32(fp0, fs);
6929             gen_load_fpr32h(fph0, fs);
6930             gen_store_fpr32(fp0, fd);
6931             gen_store_fpr32h(fph0, fd);
6932             tcg_temp_free_i32(fp0);
6933             tcg_temp_free_i32(fph0);
6934             gen_set_label(l1);
6935             tcg_temp_free(t0);
6936         }
6937         opn = "movn.ps";
6938         break;
6939     case FOP(24, 22):
6940         check_cp1_64bitmode(ctx);
6941         {
6942             TCGv_i64 fp0 = tcg_temp_new_i64();
6943             TCGv_i64 fp1 = tcg_temp_new_i64();
6944
6945             gen_load_fpr64(ctx, fp0, ft);
6946             gen_load_fpr64(ctx, fp1, fs);
6947             gen_helper_float_addr_ps(fp0, fp0, fp1);
6948             tcg_temp_free_i64(fp1);
6949             gen_store_fpr64(ctx, fp0, fd);
6950             tcg_temp_free_i64(fp0);
6951         }
6952         opn = "addr.ps";
6953         break;
6954     case FOP(26, 22):
6955         check_cp1_64bitmode(ctx);
6956         {
6957             TCGv_i64 fp0 = tcg_temp_new_i64();
6958             TCGv_i64 fp1 = tcg_temp_new_i64();
6959
6960             gen_load_fpr64(ctx, fp0, ft);
6961             gen_load_fpr64(ctx, fp1, fs);
6962             gen_helper_float_mulr_ps(fp0, fp0, fp1);
6963             tcg_temp_free_i64(fp1);
6964             gen_store_fpr64(ctx, fp0, fd);
6965             tcg_temp_free_i64(fp0);
6966         }
6967         opn = "mulr.ps";
6968         break;
6969     case FOP(28, 22):
6970         check_cp1_64bitmode(ctx);
6971         {
6972             TCGv_i64 fp0 = tcg_temp_new_i64();
6973             TCGv_i64 fp1 = tcg_temp_new_i64();
6974
6975             gen_load_fpr64(ctx, fp0, fs);
6976             gen_load_fpr64(ctx, fp1, fd);
6977             gen_helper_float_recip2_ps(fp0, fp0, fp1);
6978             tcg_temp_free_i64(fp1);
6979             gen_store_fpr64(ctx, fp0, fd);
6980             tcg_temp_free_i64(fp0);
6981         }
6982         opn = "recip2.ps";
6983         break;
6984     case FOP(29, 22):
6985         check_cp1_64bitmode(ctx);
6986         {
6987             TCGv_i64 fp0 = tcg_temp_new_i64();
6988
6989             gen_load_fpr64(ctx, fp0, fs);
6990             gen_helper_float_recip1_ps(fp0, fp0);
6991             gen_store_fpr64(ctx, fp0, fd);
6992             tcg_temp_free_i64(fp0);
6993         }
6994         opn = "recip1.ps";
6995         break;
6996     case FOP(30, 22):
6997         check_cp1_64bitmode(ctx);
6998         {
6999             TCGv_i64 fp0 = tcg_temp_new_i64();
7000
7001             gen_load_fpr64(ctx, fp0, fs);
7002             gen_helper_float_rsqrt1_ps(fp0, fp0);
7003             gen_store_fpr64(ctx, fp0, fd);
7004             tcg_temp_free_i64(fp0);
7005         }
7006         opn = "rsqrt1.ps";
7007         break;
7008     case FOP(31, 22):
7009         check_cp1_64bitmode(ctx);
7010         {
7011             TCGv_i64 fp0 = tcg_temp_new_i64();
7012             TCGv_i64 fp1 = tcg_temp_new_i64();
7013
7014             gen_load_fpr64(ctx, fp0, fs);
7015             gen_load_fpr64(ctx, fp1, ft);
7016             gen_helper_float_rsqrt2_ps(fp0, fp0, fp1);
7017             tcg_temp_free_i64(fp1);
7018             gen_store_fpr64(ctx, fp0, fd);
7019             tcg_temp_free_i64(fp0);
7020         }
7021         opn = "rsqrt2.ps";
7022         break;
7023     case FOP(32, 22):
7024         check_cp1_64bitmode(ctx);
7025         {
7026             TCGv_i32 fp0 = tcg_temp_new_i32();
7027
7028             gen_load_fpr32h(fp0, fs);
7029             gen_helper_float_cvts_pu(fp0, fp0);
7030             gen_store_fpr32(fp0, fd);
7031             tcg_temp_free_i32(fp0);
7032         }
7033         opn = "cvt.s.pu";
7034         break;
7035     case FOP(36, 22):
7036         check_cp1_64bitmode(ctx);
7037         {
7038             TCGv_i64 fp0 = tcg_temp_new_i64();
7039
7040             gen_load_fpr64(ctx, fp0, fs);
7041             gen_helper_float_cvtpw_ps(fp0, fp0);
7042             gen_store_fpr64(ctx, fp0, fd);
7043             tcg_temp_free_i64(fp0);
7044         }
7045         opn = "cvt.pw.ps";
7046         break;
7047     case FOP(40, 22):
7048         check_cp1_64bitmode(ctx);
7049         {
7050             TCGv_i32 fp0 = tcg_temp_new_i32();
7051
7052             gen_load_fpr32(fp0, fs);
7053             gen_helper_float_cvts_pl(fp0, fp0);
7054             gen_store_fpr32(fp0, fd);
7055             tcg_temp_free_i32(fp0);
7056         }
7057         opn = "cvt.s.pl";
7058         break;
7059     case FOP(44, 22):
7060         check_cp1_64bitmode(ctx);
7061         {
7062             TCGv_i32 fp0 = tcg_temp_new_i32();
7063             TCGv_i32 fp1 = tcg_temp_new_i32();
7064
7065             gen_load_fpr32(fp0, fs);
7066             gen_load_fpr32(fp1, ft);
7067             gen_store_fpr32h(fp0, fd);
7068             gen_store_fpr32(fp1, fd);
7069             tcg_temp_free_i32(fp0);
7070             tcg_temp_free_i32(fp1);
7071         }
7072         opn = "pll.ps";
7073         break;
7074     case FOP(45, 22):
7075         check_cp1_64bitmode(ctx);
7076         {
7077             TCGv_i32 fp0 = tcg_temp_new_i32();
7078             TCGv_i32 fp1 = tcg_temp_new_i32();
7079
7080             gen_load_fpr32(fp0, fs);
7081             gen_load_fpr32h(fp1, ft);
7082             gen_store_fpr32(fp1, fd);
7083             gen_store_fpr32h(fp0, fd);
7084             tcg_temp_free_i32(fp0);
7085             tcg_temp_free_i32(fp1);
7086         }
7087         opn = "plu.ps";
7088         break;
7089     case FOP(46, 22):
7090         check_cp1_64bitmode(ctx);
7091         {
7092             TCGv_i32 fp0 = tcg_temp_new_i32();
7093             TCGv_i32 fp1 = tcg_temp_new_i32();
7094
7095             gen_load_fpr32h(fp0, fs);
7096             gen_load_fpr32(fp1, ft);
7097             gen_store_fpr32(fp1, fd);
7098             gen_store_fpr32h(fp0, fd);
7099             tcg_temp_free_i32(fp0);
7100             tcg_temp_free_i32(fp1);
7101         }
7102         opn = "pul.ps";
7103         break;
7104     case FOP(47, 22):
7105         check_cp1_64bitmode(ctx);
7106         {
7107             TCGv_i32 fp0 = tcg_temp_new_i32();
7108             TCGv_i32 fp1 = tcg_temp_new_i32();
7109
7110             gen_load_fpr32h(fp0, fs);
7111             gen_load_fpr32h(fp1, ft);
7112             gen_store_fpr32(fp1, fd);
7113             gen_store_fpr32h(fp0, fd);
7114             tcg_temp_free_i32(fp0);
7115             tcg_temp_free_i32(fp1);
7116         }
7117         opn = "puu.ps";
7118         break;
7119     case FOP(48, 22):
7120     case FOP(49, 22):
7121     case FOP(50, 22):
7122     case FOP(51, 22):
7123     case FOP(52, 22):
7124     case FOP(53, 22):
7125     case FOP(54, 22):
7126     case FOP(55, 22):
7127     case FOP(56, 22):
7128     case FOP(57, 22):
7129     case FOP(58, 22):
7130     case FOP(59, 22):
7131     case FOP(60, 22):
7132     case FOP(61, 22):
7133     case FOP(62, 22):
7134     case FOP(63, 22):
7135         check_cp1_64bitmode(ctx);
7136         {
7137             TCGv_i64 fp0 = tcg_temp_new_i64();
7138             TCGv_i64 fp1 = tcg_temp_new_i64();
7139
7140             gen_load_fpr64(ctx, fp0, fs);
7141             gen_load_fpr64(ctx, fp1, ft);
7142             if (ctx->opcode & (1 << 6)) {
7143                 gen_cmpabs_ps(func-48, fp0, fp1, cc);
7144                 opn = condnames_abs[func-48];
7145             } else {
7146                 gen_cmp_ps(func-48, fp0, fp1, cc);
7147                 opn = condnames[func-48];
7148             }
7149             tcg_temp_free_i64(fp0);
7150             tcg_temp_free_i64(fp1);
7151         }
7152         break;
7153     default:
7154         MIPS_INVAL(opn);
7155         generate_exception (ctx, EXCP_RI);
7156         return;
7157     }
7158     switch (optype) {
7159     case BINOP:
7160         MIPS_DEBUG("%s %s, %s, %s", opn, fregnames[fd], fregnames[fs], fregnames[ft]);
7161         break;
7162     case CMPOP:
7163         MIPS_DEBUG("%s %s,%s", opn, fregnames[fs], fregnames[ft]);
7164         break;
7165     default:
7166         MIPS_DEBUG("%s %s,%s", opn, fregnames[fd], fregnames[fs]);
7167         break;
7168     }
7169 }
7170
7171 /* Coprocessor 3 (FPU) */
7172 static void gen_flt3_ldst (DisasContext *ctx, uint32_t opc,
7173                            int fd, int fs, int base, int index)
7174 {
7175     const char *opn = "extended float load/store";
7176     int store = 0;
7177     TCGv t0 = tcg_temp_local_new();
7178     TCGv t1 = tcg_temp_local_new();
7179
7180     if (base == 0) {
7181         gen_load_gpr(t0, index);
7182     } else if (index == 0) {
7183         gen_load_gpr(t0, base);
7184     } else {
7185         gen_load_gpr(t0, index);
7186         gen_op_addr_add(ctx, t0, cpu_gpr[base]);
7187     }
7188     /* Don't do NOP if destination is zero: we must perform the actual
7189        memory access. */
7190     switch (opc) {
7191     case OPC_LWXC1:
7192         check_cop1x(ctx);
7193         {
7194             TCGv_i32 fp0 = tcg_temp_new_i32();
7195
7196             tcg_gen_qemu_ld32s(t1, t0, ctx->mem_idx);
7197             tcg_gen_trunc_tl_i32(fp0, t1);
7198             gen_store_fpr32(fp0, fd);
7199             tcg_temp_free_i32(fp0);
7200         }
7201         opn = "lwxc1";
7202         break;
7203     case OPC_LDXC1:
7204         check_cop1x(ctx);
7205         check_cp1_registers(ctx, fd);
7206         {
7207             TCGv_i64 fp0 = tcg_temp_new_i64();
7208
7209             tcg_gen_qemu_ld64(fp0, t0, ctx->mem_idx);
7210             gen_store_fpr64(ctx, fp0, fd);
7211             tcg_temp_free_i64(fp0);
7212         }
7213         opn = "ldxc1";
7214         break;
7215     case OPC_LUXC1:
7216         check_cp1_64bitmode(ctx);
7217         tcg_gen_andi_tl(t0, t0, ~0x7);
7218         {
7219             TCGv_i64 fp0 = tcg_temp_new_i64();
7220
7221             tcg_gen_qemu_ld64(fp0, t0, ctx->mem_idx);
7222             gen_store_fpr64(ctx, fp0, fd);
7223             tcg_temp_free_i64(fp0);
7224         }
7225         opn = "luxc1";
7226         break;
7227     case OPC_SWXC1:
7228         check_cop1x(ctx);
7229         {
7230             TCGv_i32 fp0 = tcg_temp_new_i32();
7231
7232             gen_load_fpr32(fp0, fs);
7233             tcg_gen_extu_i32_tl(t1, fp0);
7234             tcg_gen_qemu_st32(t1, t0, ctx->mem_idx);
7235             tcg_temp_free_i32(fp0);
7236         }
7237         opn = "swxc1";
7238         store = 1;
7239         break;
7240     case OPC_SDXC1:
7241         check_cop1x(ctx);
7242         check_cp1_registers(ctx, fs);
7243         {
7244             TCGv_i64 fp0 = tcg_temp_new_i64();
7245
7246             gen_load_fpr64(ctx, fp0, fs);
7247             tcg_gen_qemu_st64(fp0, t0, ctx->mem_idx);
7248             tcg_temp_free_i64(fp0);
7249         }
7250         opn = "sdxc1";
7251         store = 1;
7252         break;
7253     case OPC_SUXC1:
7254         check_cp1_64bitmode(ctx);
7255         tcg_gen_andi_tl(t0, t0, ~0x7);
7256         {
7257             TCGv_i64 fp0 = tcg_temp_new_i64();
7258
7259             gen_load_fpr64(ctx, fp0, fs);
7260             tcg_gen_qemu_st64(fp0, t0, ctx->mem_idx);
7261             tcg_temp_free_i64(fp0);
7262         }
7263         opn = "suxc1";
7264         store = 1;
7265         break;
7266     default:
7267         MIPS_INVAL(opn);
7268         generate_exception(ctx, EXCP_RI);
7269         tcg_temp_free(t0);
7270         tcg_temp_free(t1);
7271         return;
7272     }
7273     tcg_temp_free(t0);
7274     tcg_temp_free(t1);
7275     MIPS_DEBUG("%s %s, %s(%s)", opn, fregnames[store ? fs : fd],
7276                regnames[index], regnames[base]);
7277 }
7278
7279 static void gen_flt3_arith (DisasContext *ctx, uint32_t opc,
7280                             int fd, int fr, int fs, int ft)
7281 {
7282     const char *opn = "flt3_arith";
7283
7284     switch (opc) {
7285     case OPC_ALNV_PS:
7286         check_cp1_64bitmode(ctx);
7287         {
7288             TCGv t0 = tcg_temp_local_new();
7289             TCGv_i32 fp0 = tcg_temp_local_new_i32();
7290             TCGv_i32 fph0 = tcg_temp_local_new_i32();
7291             TCGv_i32 fp1 = tcg_temp_local_new_i32();
7292             TCGv_i32 fph1 = tcg_temp_local_new_i32();
7293             int l1 = gen_new_label();
7294             int l2 = gen_new_label();
7295
7296             gen_load_gpr(t0, fr);
7297             tcg_gen_andi_tl(t0, t0, 0x7);
7298             gen_load_fpr32(fp0, fs);
7299             gen_load_fpr32h(fph0, fs);
7300             gen_load_fpr32(fp1, ft);
7301             gen_load_fpr32h(fph1, ft);
7302
7303             tcg_gen_brcondi_tl(TCG_COND_NE, t0, 0, l1);
7304             gen_store_fpr32(fp0, fd);
7305             gen_store_fpr32h(fph0, fd);
7306             tcg_gen_br(l2);
7307             gen_set_label(l1);
7308             tcg_gen_brcondi_tl(TCG_COND_NE, t0, 4, l2);
7309             tcg_temp_free(t0);
7310 #ifdef TARGET_WORDS_BIGENDIAN
7311             gen_store_fpr32(fph1, fd);
7312             gen_store_fpr32h(fp0, fd);
7313 #else
7314             gen_store_fpr32(fph0, fd);
7315             gen_store_fpr32h(fp1, fd);
7316 #endif
7317             gen_set_label(l2);
7318             tcg_temp_free_i32(fp0);
7319             tcg_temp_free_i32(fph0);
7320             tcg_temp_free_i32(fp1);
7321             tcg_temp_free_i32(fph1);
7322         }
7323         opn = "alnv.ps";
7324         break;
7325     case OPC_MADD_S:
7326         check_cop1x(ctx);
7327         {
7328             TCGv_i32 fp0 = tcg_temp_new_i32();
7329             TCGv_i32 fp1 = tcg_temp_new_i32();
7330             TCGv_i32 fp2 = tcg_temp_new_i32();
7331
7332             gen_load_fpr32(fp0, fs);
7333             gen_load_fpr32(fp1, ft);
7334             gen_load_fpr32(fp2, fr);
7335             gen_helper_float_muladd_s(fp2, fp0, fp1, fp2);
7336             tcg_temp_free_i32(fp0);
7337             tcg_temp_free_i32(fp1);
7338             gen_store_fpr32(fp2, fd);
7339             tcg_temp_free_i32(fp2);
7340         }
7341         opn = "madd.s";
7342         break;
7343     case OPC_MADD_D:
7344         check_cop1x(ctx);
7345         check_cp1_registers(ctx, fd | fs | ft | fr);
7346         {
7347             TCGv_i64 fp0 = tcg_temp_new_i64();
7348             TCGv_i64 fp1 = tcg_temp_new_i64();
7349             TCGv_i64 fp2 = tcg_temp_new_i64();
7350
7351             gen_load_fpr64(ctx, fp0, fs);
7352             gen_load_fpr64(ctx, fp1, ft);
7353             gen_load_fpr64(ctx, fp2, fr);
7354             gen_helper_float_muladd_d(fp2, fp0, fp1, fp2);
7355             tcg_temp_free_i64(fp0);
7356             tcg_temp_free_i64(fp1);
7357             gen_store_fpr64(ctx, fp2, fd);
7358             tcg_temp_free_i64(fp2);
7359         }
7360         opn = "madd.d";
7361         break;
7362     case OPC_MADD_PS:
7363         check_cp1_64bitmode(ctx);
7364         {
7365             TCGv_i64 fp0 = tcg_temp_new_i64();
7366             TCGv_i64 fp1 = tcg_temp_new_i64();
7367             TCGv_i64 fp2 = tcg_temp_new_i64();
7368
7369             gen_load_fpr64(ctx, fp0, fs);
7370             gen_load_fpr64(ctx, fp1, ft);
7371             gen_load_fpr64(ctx, fp2, fr);
7372             gen_helper_float_muladd_ps(fp2, fp0, fp1, fp2);
7373             tcg_temp_free_i64(fp0);
7374             tcg_temp_free_i64(fp1);
7375             gen_store_fpr64(ctx, fp2, fd);
7376             tcg_temp_free_i64(fp2);
7377         }
7378         opn = "madd.ps";
7379         break;
7380     case OPC_MSUB_S:
7381         check_cop1x(ctx);
7382         {
7383             TCGv_i32 fp0 = tcg_temp_new_i32();
7384             TCGv_i32 fp1 = tcg_temp_new_i32();
7385             TCGv_i32 fp2 = tcg_temp_new_i32();
7386
7387             gen_load_fpr32(fp0, fs);
7388             gen_load_fpr32(fp1, ft);
7389             gen_load_fpr32(fp2, fr);
7390             gen_helper_float_mulsub_s(fp2, fp0, fp1, fp2);
7391             tcg_temp_free_i32(fp0);
7392             tcg_temp_free_i32(fp1);
7393             gen_store_fpr32(fp2, fd);
7394             tcg_temp_free_i32(fp2);
7395         }
7396         opn = "msub.s";
7397         break;
7398     case OPC_MSUB_D:
7399         check_cop1x(ctx);
7400         check_cp1_registers(ctx, fd | fs | ft | fr);
7401         {
7402             TCGv_i64 fp0 = tcg_temp_new_i64();
7403             TCGv_i64 fp1 = tcg_temp_new_i64();
7404             TCGv_i64 fp2 = tcg_temp_new_i64();
7405
7406             gen_load_fpr64(ctx, fp0, fs);
7407             gen_load_fpr64(ctx, fp1, ft);
7408             gen_load_fpr64(ctx, fp2, fr);
7409             gen_helper_float_mulsub_d(fp2, fp0, fp1, fp2);
7410             tcg_temp_free_i64(fp0);
7411             tcg_temp_free_i64(fp1);
7412             gen_store_fpr64(ctx, fp2, fd);
7413             tcg_temp_free_i64(fp2);
7414         }
7415         opn = "msub.d";
7416         break;
7417     case OPC_MSUB_PS:
7418         check_cp1_64bitmode(ctx);
7419         {
7420             TCGv_i64 fp0 = tcg_temp_new_i64();
7421             TCGv_i64 fp1 = tcg_temp_new_i64();
7422             TCGv_i64 fp2 = tcg_temp_new_i64();
7423
7424             gen_load_fpr64(ctx, fp0, fs);
7425             gen_load_fpr64(ctx, fp1, ft);
7426             gen_load_fpr64(ctx, fp2, fr);
7427             gen_helper_float_mulsub_ps(fp2, fp0, fp1, fp2);
7428             tcg_temp_free_i64(fp0);
7429             tcg_temp_free_i64(fp1);
7430             gen_store_fpr64(ctx, fp2, fd);
7431             tcg_temp_free_i64(fp2);
7432         }
7433         opn = "msub.ps";
7434         break;
7435     case OPC_NMADD_S:
7436         check_cop1x(ctx);
7437         {
7438             TCGv_i32 fp0 = tcg_temp_new_i32();
7439             TCGv_i32 fp1 = tcg_temp_new_i32();
7440             TCGv_i32 fp2 = tcg_temp_new_i32();
7441
7442             gen_load_fpr32(fp0, fs);
7443             gen_load_fpr32(fp1, ft);
7444             gen_load_fpr32(fp2, fr);
7445             gen_helper_float_nmuladd_s(fp2, fp0, fp1, fp2);
7446             tcg_temp_free_i32(fp0);
7447             tcg_temp_free_i32(fp1);
7448             gen_store_fpr32(fp2, fd);
7449             tcg_temp_free_i32(fp2);
7450         }
7451         opn = "nmadd.s";
7452         break;
7453     case OPC_NMADD_D:
7454         check_cop1x(ctx);
7455         check_cp1_registers(ctx, fd | fs | ft | fr);
7456         {
7457             TCGv_i64 fp0 = tcg_temp_new_i64();
7458             TCGv_i64 fp1 = tcg_temp_new_i64();
7459             TCGv_i64 fp2 = tcg_temp_new_i64();
7460
7461             gen_load_fpr64(ctx, fp0, fs);
7462             gen_load_fpr64(ctx, fp1, ft);
7463             gen_load_fpr64(ctx, fp2, fr);
7464             gen_helper_float_nmuladd_d(fp2, fp0, fp1, fp2);
7465             tcg_temp_free_i64(fp0);
7466             tcg_temp_free_i64(fp1);
7467             gen_store_fpr64(ctx, fp2, fd);
7468             tcg_temp_free_i64(fp2);
7469         }
7470         opn = "nmadd.d";
7471         break;
7472     case OPC_NMADD_PS:
7473         check_cp1_64bitmode(ctx);
7474         {
7475             TCGv_i64 fp0 = tcg_temp_new_i64();
7476             TCGv_i64 fp1 = tcg_temp_new_i64();
7477             TCGv_i64 fp2 = tcg_temp_new_i64();
7478
7479             gen_load_fpr64(ctx, fp0, fs);
7480             gen_load_fpr64(ctx, fp1, ft);
7481             gen_load_fpr64(ctx, fp2, fr);
7482             gen_helper_float_nmuladd_ps(fp2, fp0, fp1, fp2);
7483             tcg_temp_free_i64(fp0);
7484             tcg_temp_free_i64(fp1);
7485             gen_store_fpr64(ctx, fp2, fd);
7486             tcg_temp_free_i64(fp2);
7487         }
7488         opn = "nmadd.ps";
7489         break;
7490     case OPC_NMSUB_S:
7491         check_cop1x(ctx);
7492         {
7493             TCGv_i32 fp0 = tcg_temp_new_i32();
7494             TCGv_i32 fp1 = tcg_temp_new_i32();
7495             TCGv_i32 fp2 = tcg_temp_new_i32();
7496
7497             gen_load_fpr32(fp0, fs);
7498             gen_load_fpr32(fp1, ft);
7499             gen_load_fpr32(fp2, fr);
7500             gen_helper_float_nmulsub_s(fp2, fp0, fp1, fp2);
7501             tcg_temp_free_i32(fp0);
7502             tcg_temp_free_i32(fp1);
7503             gen_store_fpr32(fp2, fd);
7504             tcg_temp_free_i32(fp2);
7505         }
7506         opn = "nmsub.s";
7507         break;
7508     case OPC_NMSUB_D:
7509         check_cop1x(ctx);
7510         check_cp1_registers(ctx, fd | fs | ft | fr);
7511         {
7512             TCGv_i64 fp0 = tcg_temp_new_i64();
7513             TCGv_i64 fp1 = tcg_temp_new_i64();
7514             TCGv_i64 fp2 = tcg_temp_new_i64();
7515
7516             gen_load_fpr64(ctx, fp0, fs);
7517             gen_load_fpr64(ctx, fp1, ft);
7518             gen_load_fpr64(ctx, fp2, fr);
7519             gen_helper_float_nmulsub_d(fp2, fp0, fp1, fp2);
7520             tcg_temp_free_i64(fp0);
7521             tcg_temp_free_i64(fp1);
7522             gen_store_fpr64(ctx, fp2, fd);
7523             tcg_temp_free_i64(fp2);
7524         }
7525         opn = "nmsub.d";
7526         break;
7527     case OPC_NMSUB_PS:
7528         check_cp1_64bitmode(ctx);
7529         {
7530             TCGv_i64 fp0 = tcg_temp_new_i64();
7531             TCGv_i64 fp1 = tcg_temp_new_i64();
7532             TCGv_i64 fp2 = tcg_temp_new_i64();
7533
7534             gen_load_fpr64(ctx, fp0, fs);
7535             gen_load_fpr64(ctx, fp1, ft);
7536             gen_load_fpr64(ctx, fp2, fr);
7537             gen_helper_float_nmulsub_ps(fp2, fp0, fp1, fp2);
7538             tcg_temp_free_i64(fp0);
7539             tcg_temp_free_i64(fp1);
7540             gen_store_fpr64(ctx, fp2, fd);
7541             tcg_temp_free_i64(fp2);
7542         }
7543         opn = "nmsub.ps";
7544         break;
7545     default:
7546         MIPS_INVAL(opn);
7547         generate_exception (ctx, EXCP_RI);
7548         return;
7549     }
7550     MIPS_DEBUG("%s %s, %s, %s, %s", opn, fregnames[fd], fregnames[fr],
7551                fregnames[fs], fregnames[ft]);
7552 }
7553
7554 /* ISA extensions (ASEs) */
7555 /* MIPS16 extension to MIPS32 */
7556 /* SmartMIPS extension to MIPS32 */
7557
7558 #if defined(TARGET_MIPS64)
7559
7560 /* MDMX extension to MIPS64 */
7561
7562 #endif
7563
7564 static void decode_opc (CPUState *env, DisasContext *ctx)
7565 {
7566     int32_t offset;
7567     int rs, rt, rd, sa;
7568     uint32_t op, op1, op2;
7569     int16_t imm;
7570
7571     /* make sure instructions are on a word boundary */
7572     if (ctx->pc & 0x3) {
7573         env->CP0_BadVAddr = ctx->pc;
7574         generate_exception(ctx, EXCP_AdEL);
7575         return;
7576     }
7577
7578     /* Handle blikely not taken case */
7579     if ((ctx->hflags & MIPS_HFLAG_BMASK) == MIPS_HFLAG_BL) {
7580         int l1 = gen_new_label();
7581
7582         MIPS_DEBUG("blikely condition (" TARGET_FMT_lx ")", ctx->pc + 4);
7583         tcg_gen_brcondi_i32(TCG_COND_NE, bcond, 0, l1);
7584         {
7585             TCGv_i32 r_tmp = tcg_temp_new_i32();
7586
7587             tcg_gen_movi_i32(r_tmp, ctx->hflags & ~MIPS_HFLAG_BMASK);
7588             tcg_gen_st_i32(r_tmp, cpu_env, offsetof(CPUState, hflags));
7589             tcg_temp_free_i32(r_tmp);
7590         }
7591         gen_goto_tb(ctx, 1, ctx->pc + 4);
7592         gen_set_label(l1);
7593     }
7594     op = MASK_OP_MAJOR(ctx->opcode);
7595     rs = (ctx->opcode >> 21) & 0x1f;
7596     rt = (ctx->opcode >> 16) & 0x1f;
7597     rd = (ctx->opcode >> 11) & 0x1f;
7598     sa = (ctx->opcode >> 6) & 0x1f;
7599     imm = (int16_t)ctx->opcode;
7600     switch (op) {
7601     case OPC_SPECIAL:
7602         op1 = MASK_SPECIAL(ctx->opcode);
7603         switch (op1) {
7604         case OPC_SLL:          /* Arithmetic with immediate */
7605         case OPC_SRL ... OPC_SRA:
7606             gen_arith_imm(env, ctx, op1, rd, rt, sa);
7607             break;
7608         case OPC_MOVZ ... OPC_MOVN:
7609             check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
7610         case OPC_SLLV:         /* Arithmetic */
7611         case OPC_SRLV ... OPC_SRAV:
7612         case OPC_ADD ... OPC_NOR:
7613         case OPC_SLT ... OPC_SLTU:
7614             gen_arith(env, ctx, op1, rd, rs, rt);
7615             break;
7616         case OPC_MULT ... OPC_DIVU:
7617             if (sa) {
7618                 check_insn(env, ctx, INSN_VR54XX);
7619                 op1 = MASK_MUL_VR54XX(ctx->opcode);
7620                 gen_mul_vr54xx(ctx, op1, rd, rs, rt);
7621             } else
7622                 gen_muldiv(ctx, op1, rs, rt);
7623             break;
7624         case OPC_JR ... OPC_JALR:
7625             gen_compute_branch(ctx, op1, rs, rd, sa);
7626             return;
7627         case OPC_TGE ... OPC_TEQ: /* Traps */
7628         case OPC_TNE:
7629             gen_trap(ctx, op1, rs, rt, -1);
7630             break;
7631         case OPC_MFHI:          /* Move from HI/LO */
7632         case OPC_MFLO:
7633             gen_HILO(ctx, op1, rd);
7634             break;
7635         case OPC_MTHI:
7636         case OPC_MTLO:          /* Move to HI/LO */
7637             gen_HILO(ctx, op1, rs);
7638             break;
7639         case OPC_PMON:          /* Pmon entry point, also R4010 selsl */
7640 #ifdef MIPS_STRICT_STANDARD
7641             MIPS_INVAL("PMON / selsl");
7642             generate_exception(ctx, EXCP_RI);
7643 #else
7644             gen_helper_0i(pmon, sa);
7645 #endif
7646             break;
7647         case OPC_SYSCALL:
7648             generate_exception(ctx, EXCP_SYSCALL);
7649             break;
7650         case OPC_BREAK:
7651             generate_exception(ctx, EXCP_BREAK);
7652             break;
7653         case OPC_SPIM:
7654 #ifdef MIPS_STRICT_STANDARD
7655             MIPS_INVAL("SPIM");
7656             generate_exception(ctx, EXCP_RI);
7657 #else
7658            /* Implemented as RI exception for now. */
7659             MIPS_INVAL("spim (unofficial)");
7660             generate_exception(ctx, EXCP_RI);
7661 #endif
7662             break;
7663         case OPC_SYNC:
7664             /* Treat as NOP. */
7665             break;
7666
7667         case OPC_MOVCI:
7668             check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
7669             if (env->CP0_Config1 & (1 << CP0C1_FP)) {
7670                 save_cpu_state(ctx, 1);
7671                 check_cp1_enabled(ctx);
7672                 gen_movci(ctx, rd, rs, (ctx->opcode >> 18) & 0x7,
7673                           (ctx->opcode >> 16) & 1);
7674             } else {
7675                 generate_exception_err(ctx, EXCP_CpU, 1);
7676             }
7677             break;
7678
7679 #if defined(TARGET_MIPS64)
7680        /* MIPS64 specific opcodes */
7681         case OPC_DSLL:
7682         case OPC_DSRL ... OPC_DSRA:
7683         case OPC_DSLL32:
7684         case OPC_DSRL32 ... OPC_DSRA32:
7685             check_insn(env, ctx, ISA_MIPS3);
7686             check_mips_64(ctx);
7687             gen_arith_imm(env, ctx, op1, rd, rt, sa);
7688             break;
7689         case OPC_DSLLV:
7690         case OPC_DSRLV ... OPC_DSRAV:
7691         case OPC_DADD ... OPC_DSUBU:
7692             check_insn(env, ctx, ISA_MIPS3);
7693             check_mips_64(ctx);
7694             gen_arith(env, ctx, op1, rd, rs, rt);
7695             break;
7696         case OPC_DMULT ... OPC_DDIVU:
7697             check_insn(env, ctx, ISA_MIPS3);
7698             check_mips_64(ctx);
7699             gen_muldiv(ctx, op1, rs, rt);
7700             break;
7701 #endif
7702         default:            /* Invalid */
7703             MIPS_INVAL("special");
7704             generate_exception(ctx, EXCP_RI);
7705             break;
7706         }
7707         break;
7708     case OPC_SPECIAL2:
7709         op1 = MASK_SPECIAL2(ctx->opcode);
7710         switch (op1) {
7711         case OPC_MADD ... OPC_MADDU: /* Multiply and add/sub */
7712         case OPC_MSUB ... OPC_MSUBU:
7713             check_insn(env, ctx, ISA_MIPS32);
7714             gen_muldiv(ctx, op1, rs, rt);
7715             break;
7716         case OPC_MUL:
7717             gen_arith(env, ctx, op1, rd, rs, rt);
7718             break;
7719         case OPC_CLZ ... OPC_CLO:
7720             check_insn(env, ctx, ISA_MIPS32);
7721             gen_cl(ctx, op1, rd, rs);
7722             break;
7723         case OPC_SDBBP:
7724             /* XXX: not clear which exception should be raised
7725              *      when in debug mode...
7726              */
7727             check_insn(env, ctx, ISA_MIPS32);
7728             if (!(ctx->hflags & MIPS_HFLAG_DM)) {
7729                 generate_exception(ctx, EXCP_DBp);
7730             } else {
7731                 generate_exception(ctx, EXCP_DBp);
7732             }
7733             /* Treat as NOP. */
7734             break;
7735 #if defined(TARGET_MIPS64)
7736         case OPC_DCLZ ... OPC_DCLO:
7737             check_insn(env, ctx, ISA_MIPS64);
7738             check_mips_64(ctx);
7739             gen_cl(ctx, op1, rd, rs);
7740             break;
7741 #endif
7742         default:            /* Invalid */
7743             MIPS_INVAL("special2");
7744             generate_exception(ctx, EXCP_RI);
7745             break;
7746         }
7747         break;
7748     case OPC_SPECIAL3:
7749         op1 = MASK_SPECIAL3(ctx->opcode);
7750         switch (op1) {
7751         case OPC_EXT:
7752         case OPC_INS:
7753             check_insn(env, ctx, ISA_MIPS32R2);
7754             gen_bitops(ctx, op1, rt, rs, sa, rd);
7755             break;
7756         case OPC_BSHFL:
7757             check_insn(env, ctx, ISA_MIPS32R2);
7758             op2 = MASK_BSHFL(ctx->opcode);
7759             gen_bshfl(ctx, op2, rt, rd);
7760             break;
7761         case OPC_RDHWR:
7762             check_insn(env, ctx, ISA_MIPS32R2);
7763             {
7764                 TCGv t0 = tcg_temp_local_new();
7765
7766                 switch (rd) {
7767                 case 0:
7768                     save_cpu_state(ctx, 1);
7769                     gen_helper_rdhwr_cpunum(t0);
7770                     break;
7771                 case 1:
7772                     save_cpu_state(ctx, 1);
7773                     gen_helper_rdhwr_synci_step(t0);
7774                     break;
7775                 case 2:
7776                     save_cpu_state(ctx, 1);
7777                     gen_helper_rdhwr_cc(t0);
7778                     break;
7779                 case 3:
7780                     save_cpu_state(ctx, 1);
7781                     gen_helper_rdhwr_ccres(t0);
7782                     break;
7783                 case 29:
7784 #if defined(CONFIG_USER_ONLY)
7785                     tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, tls_value));
7786                     break;
7787 #else
7788                     /* XXX: Some CPUs implement this in hardware.
7789                        Not supported yet. */
7790 #endif
7791                 default:            /* Invalid */
7792                     MIPS_INVAL("rdhwr");
7793                     generate_exception(ctx, EXCP_RI);
7794                     break;
7795                 }
7796                 gen_store_gpr(t0, rt);
7797                 tcg_temp_free(t0);
7798             }
7799             break;
7800         case OPC_FORK:
7801             check_insn(env, ctx, ASE_MT);
7802             {
7803                 TCGv t0 = tcg_temp_local_new();
7804                 TCGv t1 = tcg_temp_local_new();
7805
7806                 gen_load_gpr(t0, rt);
7807                 gen_load_gpr(t1, rs);
7808                 gen_helper_fork(t0, t1);
7809                 tcg_temp_free(t0);
7810                 tcg_temp_free(t1);
7811             }
7812             break;
7813         case OPC_YIELD:
7814             check_insn(env, ctx, ASE_MT);
7815             {
7816                 TCGv t0 = tcg_temp_local_new();
7817
7818                 gen_load_gpr(t0, rs);
7819                 gen_helper_yield(t0, t0);
7820                 gen_store_gpr(t0, rd);
7821                 tcg_temp_free(t0);
7822             }
7823             break;
7824 #if defined(TARGET_MIPS64)
7825         case OPC_DEXTM ... OPC_DEXT:
7826         case OPC_DINSM ... OPC_DINS:
7827             check_insn(env, ctx, ISA_MIPS64R2);
7828             check_mips_64(ctx);
7829             gen_bitops(ctx, op1, rt, rs, sa, rd);
7830             break;
7831         case OPC_DBSHFL:
7832             check_insn(env, ctx, ISA_MIPS64R2);
7833             check_mips_64(ctx);
7834             op2 = MASK_DBSHFL(ctx->opcode);
7835             gen_bshfl(ctx, op2, rt, rd);
7836             break;
7837 #endif
7838         default:            /* Invalid */
7839             MIPS_INVAL("special3");
7840             generate_exception(ctx, EXCP_RI);
7841             break;
7842         }
7843         break;
7844     case OPC_REGIMM:
7845         op1 = MASK_REGIMM(ctx->opcode);
7846         switch (op1) {
7847         case OPC_BLTZ ... OPC_BGEZL: /* REGIMM branches */
7848         case OPC_BLTZAL ... OPC_BGEZALL:
7849             gen_compute_branch(ctx, op1, rs, -1, imm << 2);
7850             return;
7851         case OPC_TGEI ... OPC_TEQI: /* REGIMM traps */
7852         case OPC_TNEI:
7853             gen_trap(ctx, op1, rs, -1, imm);
7854             break;
7855         case OPC_SYNCI:
7856             check_insn(env, ctx, ISA_MIPS32R2);
7857             /* Treat as NOP. */
7858             break;
7859         default:            /* Invalid */
7860             MIPS_INVAL("regimm");
7861             generate_exception(ctx, EXCP_RI);
7862             break;
7863         }
7864         break;
7865     case OPC_CP0:
7866         check_cp0_enabled(ctx);
7867         op1 = MASK_CP0(ctx->opcode);
7868         switch (op1) {
7869         case OPC_MFC0:
7870         case OPC_MTC0:
7871         case OPC_MFTR:
7872         case OPC_MTTR:
7873 #if defined(TARGET_MIPS64)
7874         case OPC_DMFC0:
7875         case OPC_DMTC0:
7876 #endif
7877 #ifndef CONFIG_USER_ONLY
7878             gen_cp0(env, ctx, op1, rt, rd);
7879 #endif /* !CONFIG_USER_ONLY */
7880             break;
7881         case OPC_C0_FIRST ... OPC_C0_LAST:
7882 #ifndef CONFIG_USER_ONLY
7883             gen_cp0(env, ctx, MASK_C0(ctx->opcode), rt, rd);
7884 #endif /* !CONFIG_USER_ONLY */
7885             break;
7886         case OPC_MFMC0:
7887 #ifndef CONFIG_USER_ONLY
7888             {
7889                 TCGv t0 = tcg_temp_local_new();
7890
7891                 op2 = MASK_MFMC0(ctx->opcode);
7892                 switch (op2) {
7893                 case OPC_DMT:
7894                     check_insn(env, ctx, ASE_MT);
7895                     gen_helper_dmt(t0, t0);
7896                     break;
7897                 case OPC_EMT:
7898                     check_insn(env, ctx, ASE_MT);
7899                     gen_helper_emt(t0, t0);
7900                     break;
7901                 case OPC_DVPE:
7902                     check_insn(env, ctx, ASE_MT);
7903                     gen_helper_dvpe(t0, t0);
7904                     break;
7905                 case OPC_EVPE:
7906                     check_insn(env, ctx, ASE_MT);
7907                     gen_helper_evpe(t0, t0);
7908                     break;
7909                 case OPC_DI:
7910                     check_insn(env, ctx, ISA_MIPS32R2);
7911                     save_cpu_state(ctx, 1);
7912                     gen_helper_di(t0);
7913                     /* Stop translation as we may have switched the execution mode */
7914                     ctx->bstate = BS_STOP;
7915                     break;
7916                 case OPC_EI:
7917                     check_insn(env, ctx, ISA_MIPS32R2);
7918                     save_cpu_state(ctx, 1);
7919                     gen_helper_ei(t0);
7920                     /* Stop translation as we may have switched the execution mode */
7921                     ctx->bstate = BS_STOP;
7922                     break;
7923                 default:            /* Invalid */
7924                     MIPS_INVAL("mfmc0");
7925                     generate_exception(ctx, EXCP_RI);
7926                     break;
7927                 }
7928                 gen_store_gpr(t0, rt);
7929                 tcg_temp_free(t0);
7930             }
7931 #endif /* !CONFIG_USER_ONLY */
7932             break;
7933         case OPC_RDPGPR:
7934             check_insn(env, ctx, ISA_MIPS32R2);
7935             gen_load_srsgpr(rt, rd);
7936             break;
7937         case OPC_WRPGPR:
7938             check_insn(env, ctx, ISA_MIPS32R2);
7939             gen_store_srsgpr(rt, rd);
7940             break;
7941         default:
7942             MIPS_INVAL("cp0");
7943             generate_exception(ctx, EXCP_RI);
7944             break;
7945         }
7946         break;
7947     case OPC_ADDI ... OPC_LUI: /* Arithmetic with immediate opcode */
7948          gen_arith_imm(env, ctx, op, rt, rs, imm);
7949          break;
7950     case OPC_J ... OPC_JAL: /* Jump */
7951          offset = (int32_t)(ctx->opcode & 0x3FFFFFF) << 2;
7952          gen_compute_branch(ctx, op, rs, rt, offset);
7953          return;
7954     case OPC_BEQ ... OPC_BGTZ: /* Branch */
7955     case OPC_BEQL ... OPC_BGTZL:
7956          gen_compute_branch(ctx, op, rs, rt, imm << 2);
7957          return;
7958     case OPC_LB ... OPC_LWR: /* Load and stores */
7959     case OPC_SB ... OPC_SW:
7960     case OPC_SWR:
7961     case OPC_LL:
7962     case OPC_SC:
7963          gen_ldst(ctx, op, rt, rs, imm);
7964          break;
7965     case OPC_CACHE:
7966         check_insn(env, ctx, ISA_MIPS3 | ISA_MIPS32);
7967         /* Treat as NOP. */
7968         break;
7969     case OPC_PREF:
7970         check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
7971         /* Treat as NOP. */
7972         break;
7973
7974     /* Floating point (COP1). */
7975     case OPC_LWC1:
7976     case OPC_LDC1:
7977     case OPC_SWC1:
7978     case OPC_SDC1:
7979         if (env->CP0_Config1 & (1 << CP0C1_FP)) {
7980             save_cpu_state(ctx, 1);
7981             check_cp1_enabled(ctx);
7982             gen_flt_ldst(ctx, op, rt, rs, imm);
7983         } else {
7984             generate_exception_err(ctx, EXCP_CpU, 1);
7985         }
7986         break;
7987
7988     case OPC_CP1:
7989         if (env->CP0_Config1 & (1 << CP0C1_FP)) {
7990             save_cpu_state(ctx, 1);
7991             check_cp1_enabled(ctx);
7992             op1 = MASK_CP1(ctx->opcode);
7993             switch (op1) {
7994             case OPC_MFHC1:
7995             case OPC_MTHC1:
7996                 check_insn(env, ctx, ISA_MIPS32R2);
7997             case OPC_MFC1:
7998             case OPC_CFC1:
7999             case OPC_MTC1:
8000             case OPC_CTC1:
8001                 gen_cp1(ctx, op1, rt, rd);
8002                 break;
8003 #if defined(TARGET_MIPS64)
8004             case OPC_DMFC1:
8005             case OPC_DMTC1:
8006                 check_insn(env, ctx, ISA_MIPS3);
8007                 gen_cp1(ctx, op1, rt, rd);
8008                 break;
8009 #endif
8010             case OPC_BC1ANY2:
8011             case OPC_BC1ANY4:
8012                 check_cop1x(ctx);
8013                 check_insn(env, ctx, ASE_MIPS3D);
8014                 /* fall through */
8015             case OPC_BC1:
8016                 gen_compute_branch1(env, ctx, MASK_BC1(ctx->opcode),
8017                                     (rt >> 2) & 0x7, imm << 2);
8018                 return;
8019             case OPC_S_FMT:
8020             case OPC_D_FMT:
8021             case OPC_W_FMT:
8022             case OPC_L_FMT:
8023             case OPC_PS_FMT:
8024                 gen_farith(ctx, MASK_CP1_FUNC(ctx->opcode), rt, rd, sa,
8025                            (imm >> 8) & 0x7);
8026                 break;
8027             default:
8028                 MIPS_INVAL("cp1");
8029                 generate_exception (ctx, EXCP_RI);
8030                 break;
8031             }
8032         } else {
8033             generate_exception_err(ctx, EXCP_CpU, 1);
8034         }
8035         break;
8036
8037     /* COP2.  */
8038     case OPC_LWC2:
8039     case OPC_LDC2:
8040     case OPC_SWC2:
8041     case OPC_SDC2:
8042     case OPC_CP2:
8043         /* COP2: Not implemented. */
8044         generate_exception_err(ctx, EXCP_CpU, 2);
8045         break;
8046
8047     case OPC_CP3:
8048         if (env->CP0_Config1 & (1 << CP0C1_FP)) {
8049             save_cpu_state(ctx, 1);
8050             check_cp1_enabled(ctx);
8051             op1 = MASK_CP3(ctx->opcode);
8052             switch (op1) {
8053             case OPC_LWXC1:
8054             case OPC_LDXC1:
8055             case OPC_LUXC1:
8056             case OPC_SWXC1:
8057             case OPC_SDXC1:
8058             case OPC_SUXC1:
8059                 gen_flt3_ldst(ctx, op1, sa, rd, rs, rt);
8060                 break;
8061             case OPC_PREFX:
8062                 /* Treat as NOP. */
8063                 break;
8064             case OPC_ALNV_PS:
8065             case OPC_MADD_S:
8066             case OPC_MADD_D:
8067             case OPC_MADD_PS:
8068             case OPC_MSUB_S:
8069             case OPC_MSUB_D:
8070             case OPC_MSUB_PS:
8071             case OPC_NMADD_S:
8072             case OPC_NMADD_D:
8073             case OPC_NMADD_PS:
8074             case OPC_NMSUB_S:
8075             case OPC_NMSUB_D:
8076             case OPC_NMSUB_PS:
8077                 gen_flt3_arith(ctx, op1, sa, rs, rd, rt);
8078                 break;
8079             default:
8080                 MIPS_INVAL("cp3");
8081                 generate_exception (ctx, EXCP_RI);
8082                 break;
8083             }
8084         } else {
8085             generate_exception_err(ctx, EXCP_CpU, 1);
8086         }
8087         break;
8088
8089 #if defined(TARGET_MIPS64)
8090     /* MIPS64 opcodes */
8091     case OPC_LWU:
8092     case OPC_LDL ... OPC_LDR:
8093     case OPC_SDL ... OPC_SDR:
8094     case OPC_LLD:
8095     case OPC_LD:
8096     case OPC_SCD:
8097     case OPC_SD:
8098         check_insn(env, ctx, ISA_MIPS3);
8099         check_mips_64(ctx);
8100         gen_ldst(ctx, op, rt, rs, imm);
8101         break;
8102     case OPC_DADDI ... OPC_DADDIU:
8103         check_insn(env, ctx, ISA_MIPS3);
8104         check_mips_64(ctx);
8105         gen_arith_imm(env, ctx, op, rt, rs, imm);
8106         break;
8107 #endif
8108     case OPC_JALX:
8109         check_insn(env, ctx, ASE_MIPS16);
8110         /* MIPS16: Not implemented. */
8111     case OPC_MDMX:
8112         check_insn(env, ctx, ASE_MDMX);
8113         /* MDMX: Not implemented. */
8114     default:            /* Invalid */
8115         MIPS_INVAL("major opcode");
8116         generate_exception(ctx, EXCP_RI);
8117         break;
8118     }
8119     if (ctx->hflags & MIPS_HFLAG_BMASK) {
8120         int hflags = ctx->hflags & MIPS_HFLAG_BMASK;
8121         /* Branches completion */
8122         ctx->hflags &= ~MIPS_HFLAG_BMASK;
8123         ctx->bstate = BS_BRANCH;
8124         save_cpu_state(ctx, 0);
8125         /* FIXME: Need to clear can_do_io.  */
8126         switch (hflags) {
8127         case MIPS_HFLAG_B:
8128             /* unconditional branch */
8129             MIPS_DEBUG("unconditional branch");
8130             gen_goto_tb(ctx, 0, ctx->btarget);
8131             break;
8132         case MIPS_HFLAG_BL:
8133             /* blikely taken case */
8134             MIPS_DEBUG("blikely branch taken");
8135             gen_goto_tb(ctx, 0, ctx->btarget);
8136             break;
8137         case MIPS_HFLAG_BC:
8138             /* Conditional branch */
8139             MIPS_DEBUG("conditional branch");
8140             {
8141                 int l1 = gen_new_label();
8142
8143                 tcg_gen_brcondi_i32(TCG_COND_NE, bcond, 0, l1);
8144                 gen_goto_tb(ctx, 1, ctx->pc + 4);
8145                 gen_set_label(l1);
8146                 gen_goto_tb(ctx, 0, ctx->btarget);
8147             }
8148             break;
8149         case MIPS_HFLAG_BR:
8150             /* unconditional branch to register */
8151             MIPS_DEBUG("branch to register");
8152             tcg_gen_mov_tl(cpu_PC, btarget);
8153             tcg_gen_exit_tb(0);
8154             break;
8155         default:
8156             MIPS_DEBUG("unknown branch");
8157             break;
8158         }
8159     }
8160 }
8161
8162 static inline void
8163 gen_intermediate_code_internal (CPUState *env, TranslationBlock *tb,
8164                                 int search_pc)
8165 {
8166     DisasContext ctx;
8167     target_ulong pc_start;
8168     uint16_t *gen_opc_end;
8169     CPUBreakpoint *bp;
8170     int j, lj = -1;
8171     int num_insns;
8172     int max_insns;
8173
8174     if (search_pc)
8175         qemu_log("search pc %d\n", search_pc);
8176
8177     pc_start = tb->pc;
8178     /* Leave some spare opc slots for branch handling. */
8179     gen_opc_end = gen_opc_buf + OPC_MAX_SIZE - 16;
8180     ctx.pc = pc_start;
8181     ctx.saved_pc = -1;
8182     ctx.tb = tb;
8183     ctx.bstate = BS_NONE;
8184     /* Restore delay slot state from the tb context.  */
8185     ctx.hflags = (uint32_t)tb->flags; /* FIXME: maybe use 64 bits here? */
8186     restore_cpu_state(env, &ctx);
8187 #ifdef CONFIG_USER_ONLY
8188         ctx.mem_idx = MIPS_HFLAG_UM;
8189 #else
8190         ctx.mem_idx = ctx.hflags & MIPS_HFLAG_KSU;
8191 #endif
8192     num_insns = 0;
8193     max_insns = tb->cflags & CF_COUNT_MASK;
8194     if (max_insns == 0)
8195         max_insns = CF_COUNT_MASK;
8196 #ifdef DEBUG_DISAS
8197     qemu_log_mask(CPU_LOG_TB_CPU, "------------------------------------------------\n");
8198     /* FIXME: This may print out stale hflags from env... */
8199     log_cpu_state_mask(CPU_LOG_TB_CPU, env, 0);
8200 #endif
8201     LOG_DISAS("\ntb %p idx %d hflags %04x\n", tb, ctx.mem_idx, ctx.hflags);
8202     gen_icount_start();
8203     while (ctx.bstate == BS_NONE) {
8204         if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) {
8205             TAILQ_FOREACH(bp, &env->breakpoints, entry) {
8206                 if (bp->pc == ctx.pc) {
8207                     save_cpu_state(&ctx, 1);
8208                     ctx.bstate = BS_BRANCH;
8209                     gen_helper_0i(raise_exception, EXCP_DEBUG);
8210                     /* Include the breakpoint location or the tb won't
8211                      * be flushed when it must be.  */
8212                     ctx.pc += 4;
8213                     goto done_generating;
8214                 }
8215             }
8216         }
8217
8218         if (search_pc) {
8219             j = gen_opc_ptr - gen_opc_buf;
8220             if (lj < j) {
8221                 lj++;
8222                 while (lj < j)
8223                     gen_opc_instr_start[lj++] = 0;
8224             }
8225             gen_opc_pc[lj] = ctx.pc;
8226             gen_opc_hflags[lj] = ctx.hflags & MIPS_HFLAG_BMASK;
8227             gen_opc_instr_start[lj] = 1;
8228             gen_opc_icount[lj] = num_insns;
8229         }
8230         if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
8231             gen_io_start();
8232         ctx.opcode = ldl_code(ctx.pc);
8233         decode_opc(env, &ctx);
8234         ctx.pc += 4;
8235         num_insns++;
8236
8237         if (env->singlestep_enabled)
8238             break;
8239
8240         if ((ctx.pc & (TARGET_PAGE_SIZE - 1)) == 0)
8241             break;
8242
8243         if (gen_opc_ptr >= gen_opc_end)
8244             break;
8245
8246         if (num_insns >= max_insns)
8247             break;
8248 #if defined (MIPS_SINGLE_STEP)
8249         break;
8250 #endif
8251     }
8252     if (tb->cflags & CF_LAST_IO)
8253         gen_io_end();
8254     if (env->singlestep_enabled) {
8255         save_cpu_state(&ctx, ctx.bstate == BS_NONE);
8256         gen_helper_0i(raise_exception, EXCP_DEBUG);
8257     } else {
8258         switch (ctx.bstate) {
8259         case BS_STOP:
8260             gen_helper_interrupt_restart();
8261             gen_goto_tb(&ctx, 0, ctx.pc);
8262             break;
8263         case BS_NONE:
8264             save_cpu_state(&ctx, 0);
8265             gen_goto_tb(&ctx, 0, ctx.pc);
8266             break;
8267         case BS_EXCP:
8268             gen_helper_interrupt_restart();
8269             tcg_gen_exit_tb(0);
8270             break;
8271         case BS_BRANCH:
8272         default:
8273             break;
8274         }
8275     }
8276 done_generating:
8277     gen_icount_end(tb, num_insns);
8278     *gen_opc_ptr = INDEX_op_end;
8279     if (search_pc) {
8280         j = gen_opc_ptr - gen_opc_buf;
8281         lj++;
8282         while (lj <= j)
8283             gen_opc_instr_start[lj++] = 0;
8284     } else {
8285         tb->size = ctx.pc - pc_start;
8286         tb->icount = num_insns;
8287     }
8288 #ifdef DEBUG_DISAS
8289     LOG_DISAS("\n");
8290     if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
8291         qemu_log("IN: %s\n", lookup_symbol(pc_start));
8292         log_target_disas(pc_start, ctx.pc - pc_start, 0);
8293         qemu_log("\n");
8294     }
8295     qemu_log_mask(CPU_LOG_TB_CPU, "---------------- %d %08x\n", ctx.bstate, ctx.hflags);
8296 #endif
8297 }
8298
8299 void gen_intermediate_code (CPUState *env, struct TranslationBlock *tb)
8300 {
8301     gen_intermediate_code_internal(env, tb, 0);
8302 }
8303
8304 void gen_intermediate_code_pc (CPUState *env, struct TranslationBlock *tb)
8305 {
8306     gen_intermediate_code_internal(env, tb, 1);
8307 }
8308
8309 static void fpu_dump_state(CPUState *env, FILE *f,
8310                            int (*fpu_fprintf)(FILE *f, const char *fmt, ...),
8311                            int flags)
8312 {
8313     int i;
8314     int is_fpu64 = !!(env->hflags & MIPS_HFLAG_F64);
8315
8316 #define printfpr(fp)                                                        \
8317     do {                                                                    \
8318         if (is_fpu64)                                                       \
8319             fpu_fprintf(f, "w:%08x d:%016lx fd:%13g fs:%13g psu: %13g\n",   \
8320                         (fp)->w[FP_ENDIAN_IDX], (fp)->d, (fp)->fd,          \
8321                         (fp)->fs[FP_ENDIAN_IDX], (fp)->fs[!FP_ENDIAN_IDX]); \
8322         else {                                                              \
8323             fpr_t tmp;                                                      \
8324             tmp.w[FP_ENDIAN_IDX] = (fp)->w[FP_ENDIAN_IDX];                  \
8325             tmp.w[!FP_ENDIAN_IDX] = ((fp) + 1)->w[FP_ENDIAN_IDX];           \
8326             fpu_fprintf(f, "w:%08x d:%016lx fd:%13g fs:%13g psu:%13g\n",    \
8327                         tmp.w[FP_ENDIAN_IDX], tmp.d, tmp.fd,                \
8328                         tmp.fs[FP_ENDIAN_IDX], tmp.fs[!FP_ENDIAN_IDX]);     \
8329         }                                                                   \
8330     } while(0)
8331
8332
8333     fpu_fprintf(f, "CP1 FCR0 0x%08x  FCR31 0x%08x  SR.FR %d  fp_status 0x%08x(0x%02x)\n",
8334                 env->active_fpu.fcr0, env->active_fpu.fcr31, is_fpu64, env->active_fpu.fp_status,
8335                 get_float_exception_flags(&env->active_fpu.fp_status));
8336     for (i = 0; i < 32; (is_fpu64) ? i++ : (i += 2)) {
8337         fpu_fprintf(f, "%3s: ", fregnames[i]);
8338         printfpr(&env->active_fpu.fpr[i]);
8339     }
8340
8341 #undef printfpr
8342 }
8343
8344 #if defined(TARGET_MIPS64) && defined(MIPS_DEBUG_SIGN_EXTENSIONS)
8345 /* Debug help: The architecture requires 32bit code to maintain proper
8346    sign-extended values on 64bit machines.  */
8347
8348 #define SIGN_EXT_P(val) ((((val) & ~0x7fffffff) == 0) || (((val) & ~0x7fffffff) == ~0x7fffffff))
8349
8350 static void
8351 cpu_mips_check_sign_extensions (CPUState *env, FILE *f,
8352                                 int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
8353                                 int flags)
8354 {
8355     int i;
8356
8357     if (!SIGN_EXT_P(env->active_tc.PC))
8358         cpu_fprintf(f, "BROKEN: pc=0x" TARGET_FMT_lx "\n", env->active_tc.PC);
8359     if (!SIGN_EXT_P(env->active_tc.HI[0]))
8360         cpu_fprintf(f, "BROKEN: HI=0x" TARGET_FMT_lx "\n", env->active_tc.HI[0]);
8361     if (!SIGN_EXT_P(env->active_tc.LO[0]))
8362         cpu_fprintf(f, "BROKEN: LO=0x" TARGET_FMT_lx "\n", env->active_tc.LO[0]);
8363     if (!SIGN_EXT_P(env->btarget))
8364         cpu_fprintf(f, "BROKEN: btarget=0x" TARGET_FMT_lx "\n", env->btarget);
8365
8366     for (i = 0; i < 32; i++) {
8367         if (!SIGN_EXT_P(env->active_tc.gpr[i]))
8368             cpu_fprintf(f, "BROKEN: %s=0x" TARGET_FMT_lx "\n", regnames[i], env->active_tc.gpr[i]);
8369     }
8370
8371     if (!SIGN_EXT_P(env->CP0_EPC))
8372         cpu_fprintf(f, "BROKEN: EPC=0x" TARGET_FMT_lx "\n", env->CP0_EPC);
8373     if (!SIGN_EXT_P(env->CP0_LLAddr))
8374         cpu_fprintf(f, "BROKEN: LLAddr=0x" TARGET_FMT_lx "\n", env->CP0_LLAddr);
8375 }
8376 #endif
8377
8378 void cpu_dump_state (CPUState *env, FILE *f,
8379                      int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
8380                      int flags)
8381 {
8382     int i;
8383
8384     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",
8385                 env->active_tc.PC, env->active_tc.HI[0], env->active_tc.LO[0],
8386                 env->hflags, env->btarget, env->bcond);
8387     for (i = 0; i < 32; i++) {
8388         if ((i & 3) == 0)
8389             cpu_fprintf(f, "GPR%02d:", i);
8390         cpu_fprintf(f, " %s " TARGET_FMT_lx, regnames[i], env->active_tc.gpr[i]);
8391         if ((i & 3) == 3)
8392             cpu_fprintf(f, "\n");
8393     }
8394
8395     cpu_fprintf(f, "CP0 Status  0x%08x Cause   0x%08x EPC    0x" TARGET_FMT_lx "\n",
8396                 env->CP0_Status, env->CP0_Cause, env->CP0_EPC);
8397     cpu_fprintf(f, "    Config0 0x%08x Config1 0x%08x LLAddr 0x" TARGET_FMT_lx "\n",
8398                 env->CP0_Config0, env->CP0_Config1, env->CP0_LLAddr);
8399     if (env->hflags & MIPS_HFLAG_FPU)
8400         fpu_dump_state(env, f, cpu_fprintf, flags);
8401 #if defined(TARGET_MIPS64) && defined(MIPS_DEBUG_SIGN_EXTENSIONS)
8402     cpu_mips_check_sign_extensions(env, f, cpu_fprintf, flags);
8403 #endif
8404 }
8405
8406 static void mips_tcg_init(void)
8407 {
8408     int i;
8409     static int inited;
8410
8411     /* Initialize various static tables. */
8412     if (inited)
8413         return;
8414
8415     cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
8416     for (i = 0; i < 32; i++)
8417         cpu_gpr[i] = tcg_global_mem_new(TCG_AREG0,
8418                                         offsetof(CPUState, active_tc.gpr[i]),
8419                                         regnames[i]);
8420     cpu_PC = tcg_global_mem_new(TCG_AREG0,
8421                                 offsetof(CPUState, active_tc.PC), "PC");
8422     for (i = 0; i < MIPS_DSP_ACC; i++) {
8423         cpu_HI[i] = tcg_global_mem_new(TCG_AREG0,
8424                                        offsetof(CPUState, active_tc.HI[i]),
8425                                        regnames_HI[i]);
8426         cpu_LO[i] = tcg_global_mem_new(TCG_AREG0,
8427                                        offsetof(CPUState, active_tc.LO[i]),
8428                                        regnames_LO[i]);
8429         cpu_ACX[i] = tcg_global_mem_new(TCG_AREG0,
8430                                         offsetof(CPUState, active_tc.ACX[i]),
8431                                         regnames_ACX[i]);
8432     }
8433     cpu_dspctrl = tcg_global_mem_new(TCG_AREG0,
8434                                      offsetof(CPUState, active_tc.DSPControl),
8435                                      "DSPControl");
8436     bcond = tcg_global_mem_new_i32(TCG_AREG0,
8437                                    offsetof(CPUState, bcond), "bcond");
8438     btarget = tcg_global_mem_new(TCG_AREG0,
8439                                  offsetof(CPUState, btarget), "btarget");
8440     for (i = 0; i < 32; i++)
8441         fpu_fpr32[i] = tcg_global_mem_new_i32(TCG_AREG0,
8442             offsetof(CPUState, active_fpu.fpr[i].w[FP_ENDIAN_IDX]),
8443             fregnames[i]);
8444     for (i = 0; i < 32; i++)
8445         fpu_fpr64[i] = tcg_global_mem_new_i64(TCG_AREG0,
8446             offsetof(CPUState, active_fpu.fpr[i]),
8447             fregnames_64[i]);
8448     for (i = 0; i < 32; i++)
8449         fpu_fpr32h[i] = tcg_global_mem_new_i32(TCG_AREG0,
8450             offsetof(CPUState, active_fpu.fpr[i].w[!FP_ENDIAN_IDX]),
8451             fregnames_h[i]);
8452     fpu_fcr0 = tcg_global_mem_new_i32(TCG_AREG0,
8453                                       offsetof(CPUState, active_fpu.fcr0),
8454                                       "fcr0");
8455     fpu_fcr31 = tcg_global_mem_new_i32(TCG_AREG0,
8456                                        offsetof(CPUState, active_fpu.fcr31),
8457                                        "fcr31");
8458
8459     /* register helpers */
8460 #define GEN_HELPER 2
8461 #include "helper.h"
8462
8463     inited = 1;
8464 }
8465
8466 #include "translate_init.c"
8467
8468 CPUMIPSState *cpu_mips_init (const char *cpu_model)
8469 {
8470     CPUMIPSState *env;
8471     const mips_def_t *def;
8472
8473     def = cpu_mips_find_by_name(cpu_model);
8474     if (!def)
8475         return NULL;
8476     env = qemu_mallocz(sizeof(CPUMIPSState));
8477     env->cpu_model = def;
8478
8479     cpu_exec_init(env);
8480     env->cpu_model_str = cpu_model;
8481     mips_tcg_init();
8482     cpu_reset(env);
8483     return env;
8484 }
8485
8486 void cpu_reset (CPUMIPSState *env)
8487 {
8488     if (qemu_loglevel_mask(CPU_LOG_RESET)) {
8489         qemu_log("CPU Reset (CPU %d)\n", env->cpu_index);
8490         log_cpu_state(env, 0);
8491     }
8492
8493     memset(env, 0, offsetof(CPUMIPSState, breakpoints));
8494
8495     tlb_flush(env, 1);
8496
8497     /* Minimal init */
8498 #if defined(CONFIG_USER_ONLY)
8499     env->hflags = MIPS_HFLAG_UM;
8500 #else
8501     if (env->hflags & MIPS_HFLAG_BMASK) {
8502         /* If the exception was raised from a delay slot,
8503            come back to the jump.  */
8504         env->CP0_ErrorEPC = env->active_tc.PC - 4;
8505     } else {
8506         env->CP0_ErrorEPC = env->active_tc.PC;
8507     }
8508     env->active_tc.PC = (int32_t)0xBFC00000;
8509     env->CP0_Wired = 0;
8510     /* SMP not implemented */
8511     env->CP0_EBase = 0x80000000;
8512     env->CP0_Status = (1 << CP0St_BEV) | (1 << CP0St_ERL);
8513     /* vectored interrupts not implemented, timer on int 7,
8514        no performance counters. */
8515     env->CP0_IntCtl = 0xe0000000;
8516     {
8517         int i;
8518
8519         for (i = 0; i < 7; i++) {
8520             env->CP0_WatchLo[i] = 0;
8521             env->CP0_WatchHi[i] = 0x80000000;
8522         }
8523         env->CP0_WatchLo[7] = 0;
8524         env->CP0_WatchHi[7] = 0;
8525     }
8526     /* Count register increments in debug mode, EJTAG version 1 */
8527     env->CP0_Debug = (1 << CP0DB_CNT) | (0x1 << CP0DB_VER);
8528     env->hflags = MIPS_HFLAG_CP0;
8529 #endif
8530     env->exception_index = EXCP_NONE;
8531     cpu_mips_register(env, env->cpu_model);
8532 }
8533
8534 void gen_pc_load(CPUState *env, TranslationBlock *tb,
8535                 unsigned long searched_pc, int pc_pos, void *puc)
8536 {
8537     env->active_tc.PC = gen_opc_pc[pc_pos];
8538     env->hflags &= ~MIPS_HFLAG_BMASK;
8539     env->hflags |= gen_opc_hflags[pc_pos];
8540 }