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