?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hw/ac97.c: convert to PCIDeviceInfo to initialize ids
[qemu.git] / target-mips / translate.c
blob4eaa8261c35fc1d49f18122d294a7e8d7d2aa637
1 /*
2 * MIPS32 emulation for qemu: main translation routines.
3 *
4 * Copyright (c) 2004-2005 Jocelyn Mayer
5 * Copyright (c) 2006 Marius Groeger (FPU operations)
6 * Copyright (c) 2006 Thiemo Seufer (MIPS32R2 support)
7 * Copyright (c) 2009 CodeSourcery (MIPS16 and microMIPS support)
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include <stdarg.h>
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <inttypes.h>
28
29 #include "cpu.h"
30 #include "exec-all.h"
31 #include "disas.h"
32 #include "tcg-op.h"
33 #include "qemu-common.h"
34
35 #include "helper.h"
36 #define GEN_HELPER 1
37 #include "helper.h"
38
39 //#define MIPS_DEBUG_DISAS
40 //#define MIPS_DEBUG_SIGN_EXTENSIONS
41
42 /* MIPS major opcodes */
43 #define MASK_OP_MAJOR(op) (op & (0x3F << 26))
44
45 enum {
46 /* indirect opcode tables */
47 OPC_SPECIAL = (0x00 << 26),
48 OPC_REGIMM = (0x01 << 26),
49 OPC_CP0 = (0x10 << 26),
50 OPC_CP1 = (0x11 << 26),
51 OPC_CP2 = (0x12 << 26),
52 OPC_CP3 = (0x13 << 26),
53 OPC_SPECIAL2 = (0x1C << 26),
54 OPC_SPECIAL3 = (0x1F << 26),
55 /* arithmetic with immediate */
56 OPC_ADDI = (0x08 << 26),
57 OPC_ADDIU = (0x09 << 26),
58 OPC_SLTI = (0x0A << 26),
59 OPC_SLTIU = (0x0B << 26),
60 /* logic with immediate */
61 OPC_ANDI = (0x0C << 26),
62 OPC_ORI = (0x0D << 26),
63 OPC_XORI = (0x0E << 26),
64 OPC_LUI = (0x0F << 26),
65 /* arithmetic with immediate */
66 OPC_DADDI = (0x18 << 26),
67 OPC_DADDIU = (0x19 << 26),
68 /* Jump and branches */
69 OPC_J = (0x02 << 26),
70 OPC_JAL = (0x03 << 26),
71 OPC_JALS = OPC_JAL | 0x5,
72 OPC_BEQ = (0x04 << 26), /* Unconditional if rs = rt = 0 (B) */
73 OPC_BEQL = (0x14 << 26),
74 OPC_BNE = (0x05 << 26),
75 OPC_BNEL = (0x15 << 26),
76 OPC_BLEZ = (0x06 << 26),
77 OPC_BLEZL = (0x16 << 26),
78 OPC_BGTZ = (0x07 << 26),
79 OPC_BGTZL = (0x17 << 26),
80 OPC_JALX = (0x1D << 26), /* MIPS 16 only */
81 OPC_JALXS = OPC_JALX | 0x5,
82 /* Load and stores */
83 OPC_LDL = (0x1A << 26),
84 OPC_LDR = (0x1B << 26),
85 OPC_LB = (0x20 << 26),
86 OPC_LH = (0x21 << 26),
87 OPC_LWL = (0x22 << 26),
88 OPC_LW = (0x23 << 26),
89 OPC_LWPC = OPC_LW | 0x5,
90 OPC_LBU = (0x24 << 26),
91 OPC_LHU = (0x25 << 26),
92 OPC_LWR = (0x26 << 26),
93 OPC_LWU = (0x27 << 26),
94 OPC_SB = (0x28 << 26),
95 OPC_SH = (0x29 << 26),
96 OPC_SWL = (0x2A << 26),
97 OPC_SW = (0x2B << 26),
98 OPC_SDL = (0x2C << 26),
99 OPC_SDR = (0x2D << 26),
100 OPC_SWR = (0x2E << 26),
101 OPC_LL = (0x30 << 26),
102 OPC_LLD = (0x34 << 26),
103 OPC_LD = (0x37 << 26),
104 OPC_LDPC = OPC_LD | 0x5,
105 OPC_SC = (0x38 << 26),
106 OPC_SCD = (0x3C << 26),
107 OPC_SD = (0x3F << 26),
108 /* Floating point load/store */
109 OPC_LWC1 = (0x31 << 26),
110 OPC_LWC2 = (0x32 << 26),
111 OPC_LDC1 = (0x35 << 26),
112 OPC_LDC2 = (0x36 << 26),
113 OPC_SWC1 = (0x39 << 26),
114 OPC_SWC2 = (0x3A << 26),
115 OPC_SDC1 = (0x3D << 26),
116 OPC_SDC2 = (0x3E << 26),
117 /* MDMX ASE specific */
118 OPC_MDMX = (0x1E << 26),
119 /* Cache and prefetch */
120 OPC_CACHE = (0x2F << 26),
121 OPC_PREF = (0x33 << 26),
122 /* Reserved major opcode */
123 OPC_MAJOR3B_RESERVED = (0x3B << 26),
124 };
125
126 /* MIPS special opcodes */
127 #define MASK_SPECIAL(op) MASK_OP_MAJOR(op) | (op & 0x3F)
128
129 enum {
130 /* Shifts */
131 OPC_SLL = 0x00 | OPC_SPECIAL,
132 /* NOP is SLL r0, r0, 0 */
133 /* SSNOP is SLL r0, r0, 1 */
134 /* EHB is SLL r0, r0, 3 */
135 OPC_SRL = 0x02 | OPC_SPECIAL, /* also ROTR */
136 OPC_ROTR = OPC_SRL | (1 << 21),
137 OPC_SRA = 0x03 | OPC_SPECIAL,
138 OPC_SLLV = 0x04 | OPC_SPECIAL,
139 OPC_SRLV = 0x06 | OPC_SPECIAL, /* also ROTRV */
140 OPC_ROTRV = OPC_SRLV | (1 << 6),
141 OPC_SRAV = 0x07 | OPC_SPECIAL,
142 OPC_DSLLV = 0x14 | OPC_SPECIAL,
143 OPC_DSRLV = 0x16 | OPC_SPECIAL, /* also DROTRV */
144 OPC_DROTRV = OPC_DSRLV | (1 << 6),
145 OPC_DSRAV = 0x17 | OPC_SPECIAL,
146 OPC_DSLL = 0x38 | OPC_SPECIAL,
147 OPC_DSRL = 0x3A | OPC_SPECIAL, /* also DROTR */
148 OPC_DROTR = OPC_DSRL | (1 << 21),
149 OPC_DSRA = 0x3B | OPC_SPECIAL,
150 OPC_DSLL32 = 0x3C | OPC_SPECIAL,
151 OPC_DSRL32 = 0x3E | OPC_SPECIAL, /* also DROTR32 */
152 OPC_DROTR32 = OPC_DSRL32 | (1 << 21),
153 OPC_DSRA32 = 0x3F | OPC_SPECIAL,
154 /* Multiplication / division */
155 OPC_MULT = 0x18 | OPC_SPECIAL,
156 OPC_MULTU = 0x19 | OPC_SPECIAL,
157 OPC_DIV = 0x1A | OPC_SPECIAL,
158 OPC_DIVU = 0x1B | OPC_SPECIAL,
159 OPC_DMULT = 0x1C | OPC_SPECIAL,
160 OPC_DMULTU = 0x1D | OPC_SPECIAL,
161 OPC_DDIV = 0x1E | OPC_SPECIAL,
162 OPC_DDIVU = 0x1F | OPC_SPECIAL,
163 /* 2 registers arithmetic / logic */
164 OPC_ADD = 0x20 | OPC_SPECIAL,
165 OPC_ADDU = 0x21 | OPC_SPECIAL,
166 OPC_SUB = 0x22 | OPC_SPECIAL,
167 OPC_SUBU = 0x23 | OPC_SPECIAL,
168 OPC_AND = 0x24 | OPC_SPECIAL,
169 OPC_OR = 0x25 | OPC_SPECIAL,
170 OPC_XOR = 0x26 | OPC_SPECIAL,
171 OPC_NOR = 0x27 | OPC_SPECIAL,
172 OPC_SLT = 0x2A | OPC_SPECIAL,
173 OPC_SLTU = 0x2B | OPC_SPECIAL,
174 OPC_DADD = 0x2C | OPC_SPECIAL,
175 OPC_DADDU = 0x2D | OPC_SPECIAL,
176 OPC_DSUB = 0x2E | OPC_SPECIAL,
177 OPC_DSUBU = 0x2F | OPC_SPECIAL,
178 /* Jumps */
179 OPC_JR = 0x08 | OPC_SPECIAL, /* Also JR.HB */
180 OPC_JALR = 0x09 | OPC_SPECIAL, /* Also JALR.HB */
181 OPC_JALRC = OPC_JALR | (0x5 << 6),
182 OPC_JALRS = 0x10 | OPC_SPECIAL | (0x5 << 6),
183 /* Traps */
184 OPC_TGE = 0x30 | OPC_SPECIAL,
185 OPC_TGEU = 0x31 | OPC_SPECIAL,
186 OPC_TLT = 0x32 | OPC_SPECIAL,
187 OPC_TLTU = 0x33 | OPC_SPECIAL,
188 OPC_TEQ = 0x34 | OPC_SPECIAL,
189 OPC_TNE = 0x36 | OPC_SPECIAL,
190 /* HI / LO registers load & stores */
191 OPC_MFHI = 0x10 | OPC_SPECIAL,
192 OPC_MTHI = 0x11 | OPC_SPECIAL,
193 OPC_MFLO = 0x12 | OPC_SPECIAL,
194 OPC_MTLO = 0x13 | OPC_SPECIAL,
195 /* Conditional moves */
196 OPC_MOVZ = 0x0A | OPC_SPECIAL,
197 OPC_MOVN = 0x0B | OPC_SPECIAL,
198
199 OPC_MOVCI = 0x01 | OPC_SPECIAL,
200
201 /* Special */
202 OPC_PMON = 0x05 | OPC_SPECIAL, /* unofficial */
203 OPC_SYSCALL = 0x0C | OPC_SPECIAL,
204 OPC_BREAK = 0x0D | OPC_SPECIAL,
205 OPC_SPIM = 0x0E | OPC_SPECIAL, /* unofficial */
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 /* Multiplication variants of the vr54xx. */
218 #define MASK_MUL_VR54XX(op) MASK_SPECIAL(op) | (op & (0x1F << 6))
219
220 enum {
221 OPC_VR54XX_MULS = (0x03 << 6) | OPC_MULT,
222 OPC_VR54XX_MULSU = (0x03 << 6) | OPC_MULTU,
223 OPC_VR54XX_MACC = (0x05 << 6) | OPC_MULT,
224 OPC_VR54XX_MACCU = (0x05 << 6) | OPC_MULTU,
225 OPC_VR54XX_MSAC = (0x07 << 6) | OPC_MULT,
226 OPC_VR54XX_MSACU = (0x07 << 6) | OPC_MULTU,
227 OPC_VR54XX_MULHI = (0x09 << 6) | OPC_MULT,
228 OPC_VR54XX_MULHIU = (0x09 << 6) | OPC_MULTU,
229 OPC_VR54XX_MULSHI = (0x0B << 6) | OPC_MULT,
230 OPC_VR54XX_MULSHIU = (0x0B << 6) | OPC_MULTU,
231 OPC_VR54XX_MACCHI = (0x0D << 6) | OPC_MULT,
232 OPC_VR54XX_MACCHIU = (0x0D << 6) | OPC_MULTU,
233 OPC_VR54XX_MSACHI = (0x0F << 6) | OPC_MULT,
234 OPC_VR54XX_MSACHIU = (0x0F << 6) | OPC_MULTU,
235 };
236
237 /* REGIMM (rt field) opcodes */
238 #define MASK_REGIMM(op) MASK_OP_MAJOR(op) | (op & (0x1F << 16))
239
240 enum {
241 OPC_BLTZ = (0x00 << 16) | OPC_REGIMM,
242 OPC_BLTZL = (0x02 << 16) | OPC_REGIMM,
243 OPC_BGEZ = (0x01 << 16) | OPC_REGIMM,
244 OPC_BGEZL = (0x03 << 16) | OPC_REGIMM,
245 OPC_BLTZAL = (0x10 << 16) | OPC_REGIMM,
246 OPC_BLTZALS = OPC_BLTZAL | 0x5, /* microMIPS */
247 OPC_BLTZALL = (0x12 << 16) | OPC_REGIMM,
248 OPC_BGEZAL = (0x11 << 16) | OPC_REGIMM,
249 OPC_BGEZALS = OPC_BGEZAL | 0x5, /* microMIPS */
250 OPC_BGEZALL = (0x13 << 16) | OPC_REGIMM,
251 OPC_TGEI = (0x08 << 16) | OPC_REGIMM,
252 OPC_TGEIU = (0x09 << 16) | OPC_REGIMM,
253 OPC_TLTI = (0x0A << 16) | OPC_REGIMM,
254 OPC_TLTIU = (0x0B << 16) | OPC_REGIMM,
255 OPC_TEQI = (0x0C << 16) | OPC_REGIMM,
256 OPC_TNEI = (0x0E << 16) | OPC_REGIMM,
257 OPC_SYNCI = (0x1F << 16) | OPC_REGIMM,
258 };
259
260 /* Special2 opcodes */
261 #define MASK_SPECIAL2(op) MASK_OP_MAJOR(op) | (op & 0x3F)
262
263 enum {
264 /* Multiply & xxx operations */
265 OPC_MADD = 0x00 | OPC_SPECIAL2,
266 OPC_MADDU = 0x01 | OPC_SPECIAL2,
267 OPC_MUL = 0x02 | OPC_SPECIAL2,
268 OPC_MSUB = 0x04 | OPC_SPECIAL2,
269 OPC_MSUBU = 0x05 | OPC_SPECIAL2,
270 /* Loongson 2F */
271 OPC_MULT_G_2F = 0x10 | OPC_SPECIAL2,
272 OPC_DMULT_G_2F = 0x11 | OPC_SPECIAL2,
273 OPC_MULTU_G_2F = 0x12 | OPC_SPECIAL2,
274 OPC_DMULTU_G_2F = 0x13 | OPC_SPECIAL2,
275 OPC_DIV_G_2F = 0x14 | OPC_SPECIAL2,
276 OPC_DDIV_G_2F = 0x15 | OPC_SPECIAL2,
277 OPC_DIVU_G_2F = 0x16 | OPC_SPECIAL2,
278 OPC_DDIVU_G_2F = 0x17 | OPC_SPECIAL2,
279 OPC_MOD_G_2F = 0x1c | OPC_SPECIAL2,
280 OPC_DMOD_G_2F = 0x1d | OPC_SPECIAL2,
281 OPC_MODU_G_2F = 0x1e | OPC_SPECIAL2,
282 OPC_DMODU_G_2F = 0x1f | OPC_SPECIAL2,
283 /* Misc */
284 OPC_CLZ = 0x20 | OPC_SPECIAL2,
285 OPC_CLO = 0x21 | OPC_SPECIAL2,
286 OPC_DCLZ = 0x24 | OPC_SPECIAL2,
287 OPC_DCLO = 0x25 | OPC_SPECIAL2,
288 /* Special */
289 OPC_SDBBP = 0x3F | OPC_SPECIAL2,
290 };
291
292 /* Special3 opcodes */
293 #define MASK_SPECIAL3(op) MASK_OP_MAJOR(op) | (op & 0x3F)
294
295 enum {
296 OPC_EXT = 0x00 | OPC_SPECIAL3,
297 OPC_DEXTM = 0x01 | OPC_SPECIAL3,
298 OPC_DEXTU = 0x02 | OPC_SPECIAL3,
299 OPC_DEXT = 0x03 | OPC_SPECIAL3,
300 OPC_INS = 0x04 | OPC_SPECIAL3,
301 OPC_DINSM = 0x05 | OPC_SPECIAL3,
302 OPC_DINSU = 0x06 | OPC_SPECIAL3,
303 OPC_DINS = 0x07 | OPC_SPECIAL3,
304 OPC_FORK = 0x08 | OPC_SPECIAL3,
305 OPC_YIELD = 0x09 | OPC_SPECIAL3,
306 OPC_BSHFL = 0x20 | OPC_SPECIAL3,
307 OPC_DBSHFL = 0x24 | OPC_SPECIAL3,
308 OPC_RDHWR = 0x3B | OPC_SPECIAL3,
309
310 /* Loongson 2E */
311 OPC_MULT_G_2E = 0x18 | OPC_SPECIAL3,
312 OPC_MULTU_G_2E = 0x19 | OPC_SPECIAL3,
313 OPC_DIV_G_2E = 0x1A | OPC_SPECIAL3,
314 OPC_DIVU_G_2E = 0x1B | OPC_SPECIAL3,
315 OPC_DMULT_G_2E = 0x1C | OPC_SPECIAL3,
316 OPC_DMULTU_G_2E = 0x1D | OPC_SPECIAL3,
317 OPC_DDIV_G_2E = 0x1E | OPC_SPECIAL3,
318 OPC_DDIVU_G_2E = 0x1F | OPC_SPECIAL3,
319 OPC_MOD_G_2E = 0x22 | OPC_SPECIAL3,
320 OPC_MODU_G_2E = 0x23 | OPC_SPECIAL3,
321 OPC_DMOD_G_2E = 0x26 | OPC_SPECIAL3,
322 OPC_DMODU_G_2E = 0x27 | OPC_SPECIAL3,
323 };
324
325 /* BSHFL opcodes */
326 #define MASK_BSHFL(op) MASK_SPECIAL3(op) | (op & (0x1F << 6))
327
328 enum {
329 OPC_WSBH = (0x02 << 6) | OPC_BSHFL,
330 OPC_SEB = (0x10 << 6) | OPC_BSHFL,
331 OPC_SEH = (0x18 << 6) | OPC_BSHFL,
332 };
333
334 /* DBSHFL opcodes */
335 #define MASK_DBSHFL(op) MASK_SPECIAL3(op) | (op & (0x1F << 6))
336
337 enum {
338 OPC_DSBH = (0x02 << 6) | OPC_DBSHFL,
339 OPC_DSHD = (0x05 << 6) | OPC_DBSHFL,
340 };
341
342 /* Coprocessor 0 (rs field) */
343 #define MASK_CP0(op) MASK_OP_MAJOR(op) | (op & (0x1F << 21))
344
345 enum {
346 OPC_MFC0 = (0x00 << 21) | OPC_CP0,
347 OPC_DMFC0 = (0x01 << 21) | OPC_CP0,
348 OPC_MTC0 = (0x04 << 21) | OPC_CP0,
349 OPC_DMTC0 = (0x05 << 21) | OPC_CP0,
350 OPC_MFTR = (0x08 << 21) | OPC_CP0,
351 OPC_RDPGPR = (0x0A << 21) | OPC_CP0,
352 OPC_MFMC0 = (0x0B << 21) | OPC_CP0,
353 OPC_MTTR = (0x0C << 21) | OPC_CP0,
354 OPC_WRPGPR = (0x0E << 21) | OPC_CP0,
355 OPC_C0 = (0x10 << 21) | OPC_CP0,
356 OPC_C0_FIRST = (0x10 << 21) | OPC_CP0,
357 OPC_C0_LAST = (0x1F << 21) | OPC_CP0,
358 };
359
360 /* MFMC0 opcodes */
361 #define MASK_MFMC0(op) MASK_CP0(op) | (op & 0xFFFF)
362
363 enum {
364 OPC_DMT = 0x01 | (0 << 5) | (0x0F << 6) | (0x01 << 11) | OPC_MFMC0,
365 OPC_EMT = 0x01 | (1 << 5) | (0x0F << 6) | (0x01 << 11) | OPC_MFMC0,
366 OPC_DVPE = 0x01 | (0 << 5) | OPC_MFMC0,
367 OPC_EVPE = 0x01 | (1 << 5) | OPC_MFMC0,
368 OPC_DI = (0 << 5) | (0x0C << 11) | OPC_MFMC0,
369 OPC_EI = (1 << 5) | (0x0C << 11) | OPC_MFMC0,
370 };
371
372 /* Coprocessor 0 (with rs == C0) */
373 #define MASK_C0(op) MASK_CP0(op) | (op & 0x3F)
374
375 enum {
376 OPC_TLBR = 0x01 | OPC_C0,
377 OPC_TLBWI = 0x02 | OPC_C0,
378 OPC_TLBWR = 0x06 | OPC_C0,
379 OPC_TLBP = 0x08 | OPC_C0,
380 OPC_RFE = 0x10 | OPC_C0,
381 OPC_ERET = 0x18 | OPC_C0,
382 OPC_DERET = 0x1F | OPC_C0,
383 OPC_WAIT = 0x20 | OPC_C0,
384 };
385
386 /* Coprocessor 1 (rs field) */
387 #define MASK_CP1(op) MASK_OP_MAJOR(op) | (op & (0x1F << 21))
388
389 /* Values for the fmt field in FP instructions */
390 enum {
391 /* 0 - 15 are reserved */
392 FMT_S = 16, /* single fp */
393 FMT_D = 17, /* double fp */
394 FMT_E = 18, /* extended fp */
395 FMT_Q = 19, /* quad fp */
396 FMT_W = 20, /* 32-bit fixed */
397 FMT_L = 21, /* 64-bit fixed */
398 FMT_PS = 22, /* paired single fp */
399 /* 23 - 31 are reserved */
400 };
401
402 enum {
403 OPC_MFC1 = (0x00 << 21) | OPC_CP1,
404 OPC_DMFC1 = (0x01 << 21) | OPC_CP1,
405 OPC_CFC1 = (0x02 << 21) | OPC_CP1,
406 OPC_MFHC1 = (0x03 << 21) | OPC_CP1,
407 OPC_MTC1 = (0x04 << 21) | OPC_CP1,
408 OPC_DMTC1 = (0x05 << 21) | OPC_CP1,
409 OPC_CTC1 = (0x06 << 21) | OPC_CP1,
410 OPC_MTHC1 = (0x07 << 21) | OPC_CP1,
411 OPC_BC1 = (0x08 << 21) | OPC_CP1, /* bc */
412 OPC_BC1ANY2 = (0x09 << 21) | OPC_CP1,
413 OPC_BC1ANY4 = (0x0A << 21) | OPC_CP1,
414 OPC_S_FMT = (FMT_S << 21) | OPC_CP1,
415 OPC_D_FMT = (FMT_D << 21) | OPC_CP1,
416 OPC_E_FMT = (FMT_E << 21) | OPC_CP1,
417 OPC_Q_FMT = (FMT_Q << 21) | OPC_CP1,
418 OPC_W_FMT = (FMT_W << 21) | OPC_CP1,
419 OPC_L_FMT = (FMT_L << 21) | OPC_CP1,
420 OPC_PS_FMT = (FMT_PS << 21) | OPC_CP1,
421 };
422
423 #define MASK_CP1_FUNC(op) MASK_CP1(op) | (op & 0x3F)
424 #define MASK_BC1(op) MASK_CP1(op) | (op & (0x3 << 16))
425
426 enum {
427 OPC_BC1F = (0x00 << 16) | OPC_BC1,
428 OPC_BC1T = (0x01 << 16) | OPC_BC1,
429 OPC_BC1FL = (0x02 << 16) | OPC_BC1,
430 OPC_BC1TL = (0x03 << 16) | OPC_BC1,
431 };
432
433 enum {
434 OPC_BC1FANY2 = (0x00 << 16) | OPC_BC1ANY2,
435 OPC_BC1TANY2 = (0x01 << 16) | OPC_BC1ANY2,
436 };
437
438 enum {
439 OPC_BC1FANY4 = (0x00 << 16) | OPC_BC1ANY4,
440 OPC_BC1TANY4 = (0x01 << 16) | OPC_BC1ANY4,
441 };
442
443 #define MASK_CP2(op) MASK_OP_MAJOR(op) | (op & (0x1F << 21))
444
445 enum {
446 OPC_MFC2 = (0x00 << 21) | OPC_CP2,
447 OPC_DMFC2 = (0x01 << 21) | OPC_CP2,
448 OPC_CFC2 = (0x02 << 21) | OPC_CP2,
449 OPC_MFHC2 = (0x03 << 21) | OPC_CP2,
450 OPC_MTC2 = (0x04 << 21) | OPC_CP2,
451 OPC_DMTC2 = (0x05 << 21) | OPC_CP2,
452 OPC_CTC2 = (0x06 << 21) | OPC_CP2,
453 OPC_MTHC2 = (0x07 << 21) | OPC_CP2,
454 OPC_BC2 = (0x08 << 21) | OPC_CP2,
455 };
456
457 #define MASK_CP3(op) MASK_OP_MAJOR(op) | (op & 0x3F)
458
459 enum {
460 OPC_LWXC1 = 0x00 | OPC_CP3,
461 OPC_LDXC1 = 0x01 | OPC_CP3,
462 OPC_LUXC1 = 0x05 | OPC_CP3,
463 OPC_SWXC1 = 0x08 | OPC_CP3,
464 OPC_SDXC1 = 0x09 | OPC_CP3,
465 OPC_SUXC1 = 0x0D | OPC_CP3,
466 OPC_PREFX = 0x0F | OPC_CP3,
467 OPC_ALNV_PS = 0x1E | OPC_CP3,
468 OPC_MADD_S = 0x20 | OPC_CP3,
469 OPC_MADD_D = 0x21 | OPC_CP3,
470 OPC_MADD_PS = 0x26 | OPC_CP3,
471 OPC_MSUB_S = 0x28 | OPC_CP3,
472 OPC_MSUB_D = 0x29 | OPC_CP3,
473 OPC_MSUB_PS = 0x2E | OPC_CP3,
474 OPC_NMADD_S = 0x30 | OPC_CP3,
475 OPC_NMADD_D = 0x31 | OPC_CP3,
476 OPC_NMADD_PS= 0x36 | OPC_CP3,
477 OPC_NMSUB_S = 0x38 | OPC_CP3,
478 OPC_NMSUB_D = 0x39 | OPC_CP3,
479 OPC_NMSUB_PS= 0x3E | OPC_CP3,
480 };
481
482 /* global register indices */
483 static TCGv_ptr cpu_env;
484 static TCGv cpu_gpr[32], cpu_PC;
485 static TCGv cpu_HI[MIPS_DSP_ACC], cpu_LO[MIPS_DSP_ACC], cpu_ACX[MIPS_DSP_ACC];
486 static TCGv cpu_dspctrl, btarget, bcond;
487 static TCGv_i32 hflags;
488 static TCGv_i32 fpu_fcr0, fpu_fcr31;
489
490 static uint32_t gen_opc_hflags[OPC_BUF_SIZE];
491
492 #include "gen-icount.h"
493
494 #define gen_helper_0i(name, arg) do { \
495 TCGv_i32 helper_tmp = tcg_const_i32(arg); \
496 gen_helper_##name(helper_tmp); \
497 tcg_temp_free_i32(helper_tmp); \
498 } while(0)
499
500 #define gen_helper_1i(name, arg1, arg2) do { \
501 TCGv_i32 helper_tmp = tcg_const_i32(arg2); \
502 gen_helper_##name(arg1, helper_tmp); \
503 tcg_temp_free_i32(helper_tmp); \
504 } while(0)
505
506 #define gen_helper_2i(name, arg1, arg2, arg3) do { \
507 TCGv_i32 helper_tmp = tcg_const_i32(arg3); \
508 gen_helper_##name(arg1, arg2, helper_tmp); \
509 tcg_temp_free_i32(helper_tmp); \
510 } while(0)
511
512 #define gen_helper_3i(name, arg1, arg2, arg3, arg4) do { \
513 TCGv_i32 helper_tmp = tcg_const_i32(arg4); \
514 gen_helper_##name(arg1, arg2, arg3, helper_tmp); \
515 tcg_temp_free_i32(helper_tmp); \
516 } while(0)
517
518 typedef struct DisasContext {
519 struct TranslationBlock *tb;
520 target_ulong pc, saved_pc;
521 uint32_t opcode;
522 int singlestep_enabled;
523 /* Routine used to access memory */
524 int mem_idx;
525 uint32_t hflags, saved_hflags;
526 int bstate;
527 target_ulong btarget;
528 } DisasContext;
529
530 enum {
531 BS_NONE = 0, /* We go out of the TB without reaching a branch or an
532 * exception condition */
533 BS_STOP = 1, /* We want to stop translation for any reason */
534 BS_BRANCH = 2, /* We reached a branch condition */
535 BS_EXCP = 3, /* We reached an exception condition */
536 };
537
538 static const char *regnames[] =
539 { "r0", "at", "v0", "v1", "a0", "a1", "a2", "a3",
540 "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
541 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
542 "t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra", };
543
544 static const char *regnames_HI[] =
545 { "HI0", "HI1", "HI2", "HI3", };
546
547 static const char *regnames_LO[] =
548 { "LO0", "LO1", "LO2", "LO3", };
549
550 static const char *regnames_ACX[] =
551 { "ACX0", "ACX1", "ACX2", "ACX3", };
552
553 static const char *fregnames[] =
554 { "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
555 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
556 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
557 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", };
558
559 #ifdef MIPS_DEBUG_DISAS
560 #define MIPS_DEBUG(fmt, ...) \
561 qemu_log_mask(CPU_LOG_TB_IN_ASM, \
562 TARGET_FMT_lx ": %08x " fmt "\n", \
563 ctx->pc, ctx->opcode , ## __VA_ARGS__)
564 #define LOG_DISAS(...) qemu_log_mask(CPU_LOG_TB_IN_ASM, ## __VA_ARGS__)
565 #else
566 #define MIPS_DEBUG(fmt, ...) do { } while(0)
567 #define LOG_DISAS(...) do { } while (0)
568 #endif
569
570 #define MIPS_INVAL(op) \
571 do { \
572 MIPS_DEBUG("Invalid %s %03x %03x %03x", op, ctx->opcode >> 26, \
573 ctx->opcode & 0x3F, ((ctx->opcode >> 16) & 0x1F)); \
574 } while (0)
575
576 /* General purpose registers moves. */
577 static inline void gen_load_gpr (TCGv t, int reg)
578 {
579 if (reg == 0)
580 tcg_gen_movi_tl(t, 0);
581 else
582 tcg_gen_mov_tl(t, cpu_gpr[reg]);
583 }
584
585 static inline void gen_store_gpr (TCGv t, int reg)
586 {
587 if (reg != 0)
588 tcg_gen_mov_tl(cpu_gpr[reg], t);
589 }
590
591 /* Moves to/from ACX register. */
592 static inline void gen_load_ACX (TCGv t, int reg)
593 {
594 tcg_gen_mov_tl(t, cpu_ACX[reg]);
595 }
596
597 static inline void gen_store_ACX (TCGv t, int reg)
598 {
599 tcg_gen_mov_tl(cpu_ACX[reg], t);
600 }
601
602 /* Moves to/from shadow registers. */
603 static inline void gen_load_srsgpr (int from, int to)
604 {
605 TCGv t0 = tcg_temp_new();
606
607 if (from == 0)
608 tcg_gen_movi_tl(t0, 0);
609 else {
610 TCGv_i32 t2 = tcg_temp_new_i32();
611 TCGv_ptr addr = tcg_temp_new_ptr();
612
613 tcg_gen_ld_i32(t2, cpu_env, offsetof(CPUState, CP0_SRSCtl));
614 tcg_gen_shri_i32(t2, t2, CP0SRSCtl_PSS);
615 tcg_gen_andi_i32(t2, t2, 0xf);
616 tcg_gen_muli_i32(t2, t2, sizeof(target_ulong) * 32);
617 tcg_gen_ext_i32_ptr(addr, t2);
618 tcg_gen_add_ptr(addr, cpu_env, addr);
619
620 tcg_gen_ld_tl(t0, addr, sizeof(target_ulong) * from);
621 tcg_temp_free_ptr(addr);
622 tcg_temp_free_i32(t2);
623 }
624 gen_store_gpr(t0, to);
625 tcg_temp_free(t0);
626 }
627
628 static inline void gen_store_srsgpr (int from, int to)
629 {
630 if (to != 0) {
631 TCGv t0 = tcg_temp_new();
632 TCGv_i32 t2 = tcg_temp_new_i32();
633 TCGv_ptr addr = tcg_temp_new_ptr();
634
635 gen_load_gpr(t0, from);
636 tcg_gen_ld_i32(t2, cpu_env, offsetof(CPUState, CP0_SRSCtl));
637 tcg_gen_shri_i32(t2, t2, CP0SRSCtl_PSS);
638 tcg_gen_andi_i32(t2, t2, 0xf);
639 tcg_gen_muli_i32(t2, t2, sizeof(target_ulong) * 32);
640 tcg_gen_ext_i32_ptr(addr, t2);
641 tcg_gen_add_ptr(addr, cpu_env, addr);
642
643 tcg_gen_st_tl(t0, addr, sizeof(target_ulong) * to);
644 tcg_temp_free_ptr(addr);
645 tcg_temp_free_i32(t2);
646 tcg_temp_free(t0);
647 }
648 }
649
650 /* Floating point register moves. */
651 static inline void gen_load_fpr32 (TCGv_i32 t, int reg)
652 {
653 tcg_gen_ld_i32(t, cpu_env, offsetof(CPUState, active_fpu.fpr[reg].w[FP_ENDIAN_IDX]));
654 }
655
656 static inline void gen_store_fpr32 (TCGv_i32 t, int reg)
657 {
658 tcg_gen_st_i32(t, cpu_env, offsetof(CPUState, active_fpu.fpr[reg].w[FP_ENDIAN_IDX]));
659 }
660
661 static inline void gen_load_fpr32h (TCGv_i32 t, int reg)
662 {
663 tcg_gen_ld_i32(t, cpu_env, offsetof(CPUState, active_fpu.fpr[reg].w[!FP_ENDIAN_IDX]));
664 }
665
666 static inline void gen_store_fpr32h (TCGv_i32 t, int reg)
667 {
668 tcg_gen_st_i32(t, cpu_env, offsetof(CPUState, active_fpu.fpr[reg].w[!FP_ENDIAN_IDX]));
669 }
670
671 static inline void gen_load_fpr64 (DisasContext *ctx, TCGv_i64 t, int reg)
672 {
673 if (ctx->hflags & MIPS_HFLAG_F64) {
674 tcg_gen_ld_i64(t, cpu_env, offsetof(CPUState, active_fpu.fpr[reg].d));
675 } else {
676 TCGv_i32 t0 = tcg_temp_new_i32();
677 TCGv_i32 t1 = tcg_temp_new_i32();
678 gen_load_fpr32(t0, reg & ~1);
679 gen_load_fpr32(t1, reg | 1);
680 tcg_gen_concat_i32_i64(t, t0, t1);
681 tcg_temp_free_i32(t0);
682 tcg_temp_free_i32(t1);
683 }
684 }
685
686 static inline void gen_store_fpr64 (DisasContext *ctx, TCGv_i64 t, int reg)
687 {
688 if (ctx->hflags & MIPS_HFLAG_F64) {
689 tcg_gen_st_i64(t, cpu_env, offsetof(CPUState, active_fpu.fpr[reg].d));
690 } else {
691 TCGv_i64 t0 = tcg_temp_new_i64();
692 TCGv_i32 t1 = tcg_temp_new_i32();
693 tcg_gen_trunc_i64_i32(t1, t);
694 gen_store_fpr32(t1, reg & ~1);
695 tcg_gen_shri_i64(t0, t, 32);
696 tcg_gen_trunc_i64_i32(t1, t0);
697 gen_store_fpr32(t1, reg | 1);
698 tcg_temp_free_i32(t1);
699 tcg_temp_free_i64(t0);
700 }
701 }
702
703 static inline int get_fp_bit (int cc)
704 {
705 if (cc)
706 return 24 + cc;
707 else
708 return 23;
709 }
710
711 /* Tests */
712 static inline void gen_save_pc(target_ulong pc)
713 {
714 tcg_gen_movi_tl(cpu_PC, pc);
715 }
716
717 static inline void save_cpu_state (DisasContext *ctx, int do_save_pc)
718 {
719 LOG_DISAS("hflags %08x saved %08x\n", ctx->hflags, ctx->saved_hflags);
720 if (do_save_pc && ctx->pc != ctx->saved_pc) {
721 gen_save_pc(ctx->pc);
722 ctx->saved_pc = ctx->pc;
723 }
724 if (ctx->hflags != ctx->saved_hflags) {
725 tcg_gen_movi_i32(hflags, ctx->hflags);
726 ctx->saved_hflags = ctx->hflags;
727 switch (ctx->hflags & MIPS_HFLAG_BMASK_BASE) {
728 case MIPS_HFLAG_BR:
729 break;
730 case MIPS_HFLAG_BC:
731 case MIPS_HFLAG_BL:
732 case MIPS_HFLAG_B:
733 tcg_gen_movi_tl(btarget, ctx->btarget);
734 break;
735 }
736 }
737 }
738
739 static inline void restore_cpu_state (CPUState *env, DisasContext *ctx)
740 {
741 ctx->saved_hflags = ctx->hflags;
742 switch (ctx->hflags & MIPS_HFLAG_BMASK_BASE) {
743 case MIPS_HFLAG_BR:
744 break;
745 case MIPS_HFLAG_BC:
746 case MIPS_HFLAG_BL:
747 case MIPS_HFLAG_B:
748 ctx->btarget = env->btarget;
749 break;
750 }
751 }
752
753 static inline void
754 generate_exception_err (DisasContext *ctx, int excp, int err)
755 {
756 TCGv_i32 texcp = tcg_const_i32(excp);
757 TCGv_i32 terr = tcg_const_i32(err);
758 save_cpu_state(ctx, 1);
759 gen_helper_raise_exception_err(texcp, terr);
760 tcg_temp_free_i32(terr);
761 tcg_temp_free_i32(texcp);
762 }
763
764 static inline void
765 generate_exception (DisasContext *ctx, int excp)
766 {
767 save_cpu_state(ctx, 1);
768 gen_helper_0i(raise_exception, excp);
769 }
770
771 /* Addresses computation */
772 static inline void gen_op_addr_add (DisasContext *ctx, TCGv ret, TCGv arg0, TCGv arg1)
773 {
774 tcg_gen_add_tl(ret, arg0, arg1);
775
776 #if defined(TARGET_MIPS64)
777 /* For compatibility with 32-bit code, data reference in user mode
778 with Status_UX = 0 should be casted to 32-bit and sign extended.
779 See the MIPS64 PRA manual, section 4.10. */
780 if (((ctx->hflags & MIPS_HFLAG_KSU) == MIPS_HFLAG_UM) &&
781 !(ctx->hflags & MIPS_HFLAG_UX)) {
782 tcg_gen_ext32s_i64(ret, ret);
783 }
784 #endif
785 }
786
787 static inline void check_cp0_enabled(DisasContext *ctx)
788 {
789 if (unlikely(!(ctx->hflags & MIPS_HFLAG_CP0)))
790 generate_exception_err(ctx, EXCP_CpU, 0);
791 }
792
793 static inline void check_cp1_enabled(DisasContext *ctx)
794 {
795 if (unlikely(!(ctx->hflags & MIPS_HFLAG_FPU)))
796 generate_exception_err(ctx, EXCP_CpU, 1);
797 }
798
799 /* Verify that the processor is running with COP1X instructions enabled.
800 This is associated with the nabla symbol in the MIPS32 and MIPS64
801 opcode tables. */
802
803 static inline void check_cop1x(DisasContext *ctx)
804 {
805 if (unlikely(!(ctx->hflags & MIPS_HFLAG_COP1X)))
806 generate_exception(ctx, EXCP_RI);
807 }
808
809 /* Verify that the processor is running with 64-bit floating-point
810 operations enabled. */
811
812 static inline void check_cp1_64bitmode(DisasContext *ctx)
813 {
814 if (unlikely(~ctx->hflags & (MIPS_HFLAG_F64 | MIPS_HFLAG_COP1X)))
815 generate_exception(ctx, EXCP_RI);
816 }
817
818 /*
819 * Verify if floating point register is valid; an operation is not defined
820 * if bit 0 of any register specification is set and the FR bit in the
821 * Status register equals zero, since the register numbers specify an
822 * even-odd pair of adjacent coprocessor general registers. When the FR bit
823 * in the Status register equals one, both even and odd register numbers
824 * are valid. This limitation exists only for 64 bit wide (d,l,ps) registers.
825 *
826 * Multiple 64 bit wide registers can be checked by calling
827 * gen_op_cp1_registers(freg1 | freg2 | ... | fregN);
828 */
829 static inline void check_cp1_registers(DisasContext *ctx, int regs)
830 {
831 if (unlikely(!(ctx->hflags & MIPS_HFLAG_F64) && (regs & 1)))
832 generate_exception(ctx, EXCP_RI);
833 }
834
835 /* This code generates a "reserved instruction" exception if the
836 CPU does not support the instruction set corresponding to flags. */
837 static inline void check_insn(CPUState *env, DisasContext *ctx, int flags)
838 {
839 if (unlikely(!(env->insn_flags & flags)))
840 generate_exception(ctx, EXCP_RI);
841 }
842
843 /* This code generates a "reserved instruction" exception if 64-bit
844 instructions are not enabled. */
845 static inline void check_mips_64(DisasContext *ctx)
846 {
847 if (unlikely(!(ctx->hflags & MIPS_HFLAG_64)))
848 generate_exception(ctx, EXCP_RI);
849 }
850
851 /* Define small wrappers for gen_load_fpr* so that we have a uniform
852 calling interface for 32 and 64-bit FPRs. No sense in changing
853 all callers for gen_load_fpr32 when we need the CTX parameter for
854 this one use. */
855 #define gen_ldcmp_fpr32(ctx, x, y) gen_load_fpr32(x, y)
856 #define gen_ldcmp_fpr64(ctx, x, y) gen_load_fpr64(ctx, x, y)
857 #define FOP_CONDS(type, abs, fmt, ifmt, bits) \
858 static inline void gen_cmp ## type ## _ ## fmt(DisasContext *ctx, int n, \
859 int ft, int fs, int cc) \
860 { \
861 TCGv_i##bits fp0 = tcg_temp_new_i##bits (); \
862 TCGv_i##bits fp1 = tcg_temp_new_i##bits (); \
863 switch (ifmt) { \
864 case FMT_PS: \
865 check_cp1_64bitmode(ctx); \
866 break; \
867 case FMT_D: \
868 if (abs) { \
869 check_cop1x(ctx); \
870 } \
871 check_cp1_registers(ctx, fs | ft); \
872 break; \
873 case FMT_S: \
874 if (abs) { \
875 check_cop1x(ctx); \
876 } \
877 break; \
878 } \
879 gen_ldcmp_fpr##bits (ctx, fp0, fs); \
880 gen_ldcmp_fpr##bits (ctx, fp1, ft); \
881 switch (n) { \
882 case 0: gen_helper_2i(cmp ## type ## _ ## fmt ## _f, fp0, fp1, cc); break;\
883 case 1: gen_helper_2i(cmp ## type ## _ ## fmt ## _un, fp0, fp1, cc); break;\
884 case 2: gen_helper_2i(cmp ## type ## _ ## fmt ## _eq, fp0, fp1, cc); break;\
885 case 3: gen_helper_2i(cmp ## type ## _ ## fmt ## _ueq, fp0, fp1, cc); break;\
886 case 4: gen_helper_2i(cmp ## type ## _ ## fmt ## _olt, fp0, fp1, cc); break;\
887 case 5: gen_helper_2i(cmp ## type ## _ ## fmt ## _ult, fp0, fp1, cc); break;\
888 case 6: gen_helper_2i(cmp ## type ## _ ## fmt ## _ole, fp0, fp1, cc); break;\
889 case 7: gen_helper_2i(cmp ## type ## _ ## fmt ## _ule, fp0, fp1, cc); break;\
890 case 8: gen_helper_2i(cmp ## type ## _ ## fmt ## _sf, fp0, fp1, cc); break;\
891 case 9: gen_helper_2i(cmp ## type ## _ ## fmt ## _ngle, fp0, fp1, cc); break;\
892 case 10: gen_helper_2i(cmp ## type ## _ ## fmt ## _seq, fp0, fp1, cc); break;\
893 case 11: gen_helper_2i(cmp ## type ## _ ## fmt ## _ngl, fp0, fp1, cc); break;\
894 case 12: gen_helper_2i(cmp ## type ## _ ## fmt ## _lt, fp0, fp1, cc); break;\
895 case 13: gen_helper_2i(cmp ## type ## _ ## fmt ## _nge, fp0, fp1, cc); break;\
896 case 14: gen_helper_2i(cmp ## type ## _ ## fmt ## _le, fp0, fp1, cc); break;\
897 case 15: gen_helper_2i(cmp ## type ## _ ## fmt ## _ngt, fp0, fp1, cc); break;\
898 default: abort(); \
899 } \
900 tcg_temp_free_i##bits (fp0); \
901 tcg_temp_free_i##bits (fp1); \
902 }
903
904 FOP_CONDS(, 0, d, FMT_D, 64)
905 FOP_CONDS(abs, 1, d, FMT_D, 64)
906 FOP_CONDS(, 0, s, FMT_S, 32)
907 FOP_CONDS(abs, 1, s, FMT_S, 32)
908 FOP_CONDS(, 0, ps, FMT_PS, 64)
909 FOP_CONDS(abs, 1, ps, FMT_PS, 64)
910 #undef FOP_CONDS
911 #undef gen_ldcmp_fpr32
912 #undef gen_ldcmp_fpr64
913
914 /* load/store instructions. */
915 #define OP_LD(insn,fname) \
916 static inline void op_ld_##insn(TCGv ret, TCGv arg1, DisasContext *ctx) \
917 { \
918 tcg_gen_qemu_##fname(ret, arg1, ctx->mem_idx); \
919 }
920 OP_LD(lb,ld8s);
921 OP_LD(lbu,ld8u);
922 OP_LD(lh,ld16s);
923 OP_LD(lhu,ld16u);
924 OP_LD(lw,ld32s);
925 #if defined(TARGET_MIPS64)
926 OP_LD(lwu,ld32u);
927 OP_LD(ld,ld64);
928 #endif
929 #undef OP_LD
930
931 #define OP_ST(insn,fname) \
932 static inline void op_st_##insn(TCGv arg1, TCGv arg2, DisasContext *ctx) \
933 { \
934 tcg_gen_qemu_##fname(arg1, arg2, ctx->mem_idx); \
935 }
936 OP_ST(sb,st8);
937 OP_ST(sh,st16);
938 OP_ST(sw,st32);
939 #if defined(TARGET_MIPS64)
940 OP_ST(sd,st64);
941 #endif
942 #undef OP_ST
943
944 #ifdef CONFIG_USER_ONLY
945 #define OP_LD_ATOMIC(insn,fname) \
946 static inline void op_ld_##insn(TCGv ret, TCGv arg1, DisasContext *ctx) \
947 { \
948 TCGv t0 = tcg_temp_new(); \
949 tcg_gen_mov_tl(t0, arg1); \
950 tcg_gen_qemu_##fname(ret, arg1, ctx->mem_idx); \
951 tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, lladdr)); \
952 tcg_gen_st_tl(ret, cpu_env, offsetof(CPUState, llval)); \
953 tcg_temp_free(t0); \
954 }
955 #else
956 #define OP_LD_ATOMIC(insn,fname) \
957 static inline void op_ld_##insn(TCGv ret, TCGv arg1, DisasContext *ctx) \
958 { \
959 gen_helper_2i(insn, ret, arg1, ctx->mem_idx); \
960 }
961 #endif
962 OP_LD_ATOMIC(ll,ld32s);
963 #if defined(TARGET_MIPS64)
964 OP_LD_ATOMIC(lld,ld64);
965 #endif
966 #undef OP_LD_ATOMIC
967
968 #ifdef CONFIG_USER_ONLY
969 #define OP_ST_ATOMIC(insn,fname,ldname,almask) \
970 static inline void op_st_##insn(TCGv arg1, TCGv arg2, int rt, DisasContext *ctx) \
971 { \
972 TCGv t0 = tcg_temp_new(); \
973 int l1 = gen_new_label(); \
974 int l2 = gen_new_label(); \
975 \
976 tcg_gen_andi_tl(t0, arg2, almask); \
977 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1); \
978 tcg_gen_st_tl(arg2, cpu_env, offsetof(CPUState, CP0_BadVAddr)); \
979 generate_exception(ctx, EXCP_AdES); \
980 gen_set_label(l1); \
981 tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, lladdr)); \
982 tcg_gen_brcond_tl(TCG_COND_NE, arg2, t0, l2); \
983 tcg_gen_movi_tl(t0, rt | ((almask << 3) & 0x20)); \
984 tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, llreg)); \
985 tcg_gen_st_tl(arg1, cpu_env, offsetof(CPUState, llnewval)); \
986 gen_helper_0i(raise_exception, EXCP_SC); \
987 gen_set_label(l2); \
988 tcg_gen_movi_tl(t0, 0); \
989 gen_store_gpr(t0, rt); \
990 tcg_temp_free(t0); \
991 }
992 #else
993 #define OP_ST_ATOMIC(insn,fname,ldname,almask) \
994 static inline void op_st_##insn(TCGv arg1, TCGv arg2, int rt, DisasContext *ctx) \
995 { \
996 TCGv t0 = tcg_temp_new(); \
997 gen_helper_3i(insn, t0, arg1, arg2, ctx->mem_idx); \
998 gen_store_gpr(t0, rt); \
999 tcg_temp_free(t0); \
1000 }
1001 #endif
1002 OP_ST_ATOMIC(sc,st32,ld32s,0x3);
1003 #if defined(TARGET_MIPS64)
1004 OP_ST_ATOMIC(scd,st64,ld64,0x7);
1005 #endif
1006 #undef OP_ST_ATOMIC
1007
1008 static void gen_base_offset_addr (DisasContext *ctx, TCGv addr,
1009 int base, int16_t offset)
1010 {
1011 if (base == 0) {
1012 tcg_gen_movi_tl(addr, offset);
1013 } else if (offset == 0) {
1014 gen_load_gpr(addr, base);
1015 } else {
1016 tcg_gen_movi_tl(addr, offset);
1017 gen_op_addr_add(ctx, addr, cpu_gpr[base], addr);
1018 }
1019 }
1020
1021 static target_ulong pc_relative_pc (DisasContext *ctx)
1022 {
1023 target_ulong pc = ctx->pc;
1024
1025 if (ctx->hflags & MIPS_HFLAG_BMASK) {
1026 int branch_bytes = ctx->hflags & MIPS_HFLAG_BDS16 ? 2 : 4;
1027
1028 pc -= branch_bytes;
1029 }
1030
1031 pc &= ~(target_ulong)3;
1032 return pc;
1033 }
1034
1035 /* Load */
1036 static void gen_ld (CPUState *env, DisasContext *ctx, uint32_t opc,
1037 int rt, int base, int16_t offset)
1038 {
1039 const char *opn = "ld";
1040 TCGv t0, t1;
1041
1042 if (rt == 0 && env->insn_flags & (INSN_LOONGSON2E | INSN_LOONGSON2F)) {
1043 /* Loongson CPU uses a load to zero register for prefetch.
1044 We emulate it as a NOP. On other CPU we must perform the
1045 actual memory access. */
1046 MIPS_DEBUG("NOP");
1047 return;
1048 }
1049
1050 t0 = tcg_temp_new();
1051 t1 = tcg_temp_new();
1052 gen_base_offset_addr(ctx, t0, base, offset);
1053
1054 switch (opc) {
1055 #if defined(TARGET_MIPS64)
1056 case OPC_LWU:
1057 save_cpu_state(ctx, 0);
1058 op_ld_lwu(t0, t0, ctx);
1059 gen_store_gpr(t0, rt);
1060 opn = "lwu";
1061 break;
1062 case OPC_LD:
1063 save_cpu_state(ctx, 0);
1064 op_ld_ld(t0, t0, ctx);
1065 gen_store_gpr(t0, rt);
1066 opn = "ld";
1067 break;
1068 case OPC_LLD:
1069 save_cpu_state(ctx, 1);
1070 op_ld_lld(t0, t0, ctx);
1071 gen_store_gpr(t0, rt);
1072 opn = "lld";
1073 break;
1074 case OPC_LDL:
1075 save_cpu_state(ctx, 1);
1076 gen_load_gpr(t1, rt);
1077 gen_helper_3i(ldl, t1, t1, t0, ctx->mem_idx);
1078 gen_store_gpr(t1, rt);
1079 opn = "ldl";
1080 break;
1081 case OPC_LDR:
1082 save_cpu_state(ctx, 1);
1083 gen_load_gpr(t1, rt);
1084 gen_helper_3i(ldr, t1, t1, t0, ctx->mem_idx);
1085 gen_store_gpr(t1, rt);
1086 opn = "ldr";
1087 break;
1088 case OPC_LDPC:
1089 save_cpu_state(ctx, 0);
1090 tcg_gen_movi_tl(t1, pc_relative_pc(ctx));
1091 gen_op_addr_add(ctx, t0, t0, t1);
1092 op_ld_ld(t0, t0, ctx);
1093 gen_store_gpr(t0, rt);
1094 opn = "ldpc";
1095 break;
1096 #endif
1097 case OPC_LWPC:
1098 save_cpu_state(ctx, 0);
1099 tcg_gen_movi_tl(t1, pc_relative_pc(ctx));
1100 gen_op_addr_add(ctx, t0, t0, t1);
1101 op_ld_lw(t0, t0, ctx);
1102 gen_store_gpr(t0, rt);
1103 opn = "lwpc";
1104 break;
1105 case OPC_LW:
1106 save_cpu_state(ctx, 0);
1107 op_ld_lw(t0, t0, ctx);
1108 gen_store_gpr(t0, rt);
1109 opn = "lw";
1110 break;
1111 case OPC_LH:
1112 save_cpu_state(ctx, 0);
1113 op_ld_lh(t0, t0, ctx);
1114 gen_store_gpr(t0, rt);
1115 opn = "lh";
1116 break;
1117 case OPC_LHU:
1118 save_cpu_state(ctx, 0);
1119 op_ld_lhu(t0, t0, ctx);
1120 gen_store_gpr(t0, rt);
1121 opn = "lhu";
1122 break;
1123 case OPC_LB:
1124 save_cpu_state(ctx, 0);
1125 op_ld_lb(t0, t0, ctx);
1126 gen_store_gpr(t0, rt);
1127 opn = "lb";
1128 break;
1129 case OPC_LBU:
1130 save_cpu_state(ctx, 0);
1131 op_ld_lbu(t0, t0, ctx);
1132 gen_store_gpr(t0, rt);
1133 opn = "lbu";
1134 break;
1135 case OPC_LWL:
1136 save_cpu_state(ctx, 1);
1137 gen_load_gpr(t1, rt);
1138 gen_helper_3i(lwl, t1, t1, t0, ctx->mem_idx);
1139 gen_store_gpr(t1, rt);
1140 opn = "lwl";
1141 break;
1142 case OPC_LWR:
1143 save_cpu_state(ctx, 1);
1144 gen_load_gpr(t1, rt);
1145 gen_helper_3i(lwr, t1, t1, t0, ctx->mem_idx);
1146 gen_store_gpr(t1, rt);
1147 opn = "lwr";
1148 break;
1149 case OPC_LL:
1150 save_cpu_state(ctx, 1);
1151 op_ld_ll(t0, t0, ctx);
1152 gen_store_gpr(t0, rt);
1153 opn = "ll";
1154 break;
1155 }
1156 (void)opn; /* avoid a compiler warning */
1157 MIPS_DEBUG("%s %s, %d(%s)", opn, regnames[rt], offset, regnames[base]);
1158 tcg_temp_free(t0);
1159 tcg_temp_free(t1);
1160 }
1161
1162 /* Store */
1163 static void gen_st (DisasContext *ctx, uint32_t opc, int rt,
1164 int base, int16_t offset)
1165 {
1166 const char *opn = "st";
1167 TCGv t0 = tcg_temp_new();
1168 TCGv t1 = tcg_temp_new();
1169
1170 gen_base_offset_addr(ctx, t0, base, offset);
1171 gen_load_gpr(t1, rt);
1172 switch (opc) {
1173 #if defined(TARGET_MIPS64)
1174 case OPC_SD:
1175 save_cpu_state(ctx, 0);
1176 op_st_sd(t1, t0, ctx);
1177 opn = "sd";
1178 break;
1179 case OPC_SDL:
1180 save_cpu_state(ctx, 1);
1181 gen_helper_2i(sdl, t1, t0, ctx->mem_idx);
1182 opn = "sdl";
1183 break;
1184 case OPC_SDR:
1185 save_cpu_state(ctx, 1);
1186 gen_helper_2i(sdr, t1, t0, ctx->mem_idx);
1187 opn = "sdr";
1188 break;
1189 #endif
1190 case OPC_SW:
1191 save_cpu_state(ctx, 0);
1192 op_st_sw(t1, t0, ctx);
1193 opn = "sw";
1194 break;
1195 case OPC_SH:
1196 save_cpu_state(ctx, 0);
1197 op_st_sh(t1, t0, ctx);
1198 opn = "sh";
1199 break;
1200 case OPC_SB:
1201 save_cpu_state(ctx, 0);
1202 op_st_sb(t1, t0, ctx);
1203 opn = "sb";
1204 break;
1205 case OPC_SWL:
1206 save_cpu_state(ctx, 1);
1207 gen_helper_2i(swl, t1, t0, ctx->mem_idx);
1208 opn = "swl";
1209 break;
1210 case OPC_SWR:
1211 save_cpu_state(ctx, 1);
1212 gen_helper_2i(swr, t1, t0, ctx->mem_idx);
1213 opn = "swr";
1214 break;
1215 }
1216 (void)opn; /* avoid a compiler warning */
1217 MIPS_DEBUG("%s %s, %d(%s)", opn, regnames[rt], offset, regnames[base]);
1218 tcg_temp_free(t0);
1219 tcg_temp_free(t1);
1220 }
1221
1222
1223 /* Store conditional */
1224 static void gen_st_cond (DisasContext *ctx, uint32_t opc, int rt,
1225 int base, int16_t offset)
1226 {
1227 const char *opn = "st_cond";
1228 TCGv t0, t1;
1229
1230 t0 = tcg_temp_local_new();
1231
1232 gen_base_offset_addr(ctx, t0, base, offset);
1233 /* Don't do NOP if destination is zero: we must perform the actual
1234 memory access. */
1235
1236 t1 = tcg_temp_local_new();
1237 gen_load_gpr(t1, rt);
1238 switch (opc) {
1239 #if defined(TARGET_MIPS64)
1240 case OPC_SCD:
1241 save_cpu_state(ctx, 1);
1242 op_st_scd(t1, t0, rt, ctx);
1243 opn = "scd";
1244 break;
1245 #endif
1246 case OPC_SC:
1247 save_cpu_state(ctx, 1);
1248 op_st_sc(t1, t0, rt, ctx);
1249 opn = "sc";
1250 break;
1251 }
1252 (void)opn; /* avoid a compiler warning */
1253 MIPS_DEBUG("%s %s, %d(%s)", opn, regnames[rt], offset, regnames[base]);
1254 tcg_temp_free(t1);
1255 tcg_temp_free(t0);
1256 }
1257
1258 /* Load and store */
1259 static void gen_flt_ldst (DisasContext *ctx, uint32_t opc, int ft,
1260 int base, int16_t offset)
1261 {
1262 const char *opn = "flt_ldst";
1263 TCGv t0 = tcg_temp_new();
1264
1265 gen_base_offset_addr(ctx, t0, base, offset);
1266 /* Don't do NOP if destination is zero: we must perform the actual
1267 memory access. */
1268 switch (opc) {
1269 case OPC_LWC1:
1270 {
1271 TCGv_i32 fp0 = tcg_temp_new_i32();
1272
1273 tcg_gen_qemu_ld32s(t0, t0, ctx->mem_idx);
1274 tcg_gen_trunc_tl_i32(fp0, t0);
1275 gen_store_fpr32(fp0, ft);
1276 tcg_temp_free_i32(fp0);
1277 }
1278 opn = "lwc1";
1279 break;
1280 case OPC_SWC1:
1281 {
1282 TCGv_i32 fp0 = tcg_temp_new_i32();
1283 TCGv t1 = tcg_temp_new();
1284
1285 gen_load_fpr32(fp0, ft);
1286 tcg_gen_extu_i32_tl(t1, fp0);
1287 tcg_gen_qemu_st32(t1, t0, ctx->mem_idx);
1288 tcg_temp_free(t1);
1289 tcg_temp_free_i32(fp0);
1290 }
1291 opn = "swc1";
1292 break;
1293 case OPC_LDC1:
1294 {
1295 TCGv_i64 fp0 = tcg_temp_new_i64();
1296
1297 tcg_gen_qemu_ld64(fp0, t0, ctx->mem_idx);
1298 gen_store_fpr64(ctx, fp0, ft);
1299 tcg_temp_free_i64(fp0);
1300 }
1301 opn = "ldc1";
1302 break;
1303 case OPC_SDC1:
1304 {
1305 TCGv_i64 fp0 = tcg_temp_new_i64();
1306
1307 gen_load_fpr64(ctx, fp0, ft);
1308 tcg_gen_qemu_st64(fp0, t0, ctx->mem_idx);
1309 tcg_temp_free_i64(fp0);
1310 }
1311 opn = "sdc1";
1312 break;
1313 default:
1314 MIPS_INVAL(opn);
1315 generate_exception(ctx, EXCP_RI);
1316 goto out;
1317 }
1318 (void)opn; /* avoid a compiler warning */
1319 MIPS_DEBUG("%s %s, %d(%s)", opn, fregnames[ft], offset, regnames[base]);
1320 out:
1321 tcg_temp_free(t0);
1322 }
1323
1324 static void gen_cop1_ldst(CPUState *env, DisasContext *ctx,
1325 uint32_t op, int rt, int rs, int16_t imm)
1326 {
1327 if (env->CP0_Config1 & (1 << CP0C1_FP)) {
1328 check_cp1_enabled(ctx);
1329 gen_flt_ldst(ctx, op, rt, rs, imm);
1330 } else {
1331 generate_exception_err(ctx, EXCP_CpU, 1);
1332 }
1333 }
1334
1335 /* Arithmetic with immediate operand */
1336 static void gen_arith_imm (CPUState *env, DisasContext *ctx, uint32_t opc,
1337 int rt, int rs, int16_t imm)
1338 {
1339 target_ulong uimm = (target_long)imm; /* Sign extend to 32/64 bits */
1340 const char *opn = "imm arith";
1341
1342 if (rt == 0 && opc != OPC_ADDI && opc != OPC_DADDI) {
1343 /* If no destination, treat it as a NOP.
1344 For addi, we must generate the overflow exception when needed. */
1345 MIPS_DEBUG("NOP");
1346 return;
1347 }
1348 switch (opc) {
1349 case OPC_ADDI:
1350 {
1351 TCGv t0 = tcg_temp_local_new();
1352 TCGv t1 = tcg_temp_new();
1353 TCGv t2 = tcg_temp_new();
1354 int l1 = gen_new_label();
1355
1356 gen_load_gpr(t1, rs);
1357 tcg_gen_addi_tl(t0, t1, uimm);
1358 tcg_gen_ext32s_tl(t0, t0);
1359
1360 tcg_gen_xori_tl(t1, t1, ~uimm);
1361 tcg_gen_xori_tl(t2, t0, uimm);
1362 tcg_gen_and_tl(t1, t1, t2);
1363 tcg_temp_free(t2);
1364 tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
1365 tcg_temp_free(t1);
1366 /* operands of same sign, result different sign */
1367 generate_exception(ctx, EXCP_OVERFLOW);
1368 gen_set_label(l1);
1369 tcg_gen_ext32s_tl(t0, t0);
1370 gen_store_gpr(t0, rt);
1371 tcg_temp_free(t0);
1372 }
1373 opn = "addi";
1374 break;
1375 case OPC_ADDIU:
1376 if (rs != 0) {
1377 tcg_gen_addi_tl(cpu_gpr[rt], cpu_gpr[rs], uimm);
1378 tcg_gen_ext32s_tl(cpu_gpr[rt], cpu_gpr[rt]);
1379 } else {
1380 tcg_gen_movi_tl(cpu_gpr[rt], uimm);
1381 }
1382 opn = "addiu";
1383 break;
1384 #if defined(TARGET_MIPS64)
1385 case OPC_DADDI:
1386 {
1387 TCGv t0 = tcg_temp_local_new();
1388 TCGv t1 = tcg_temp_new();
1389 TCGv t2 = tcg_temp_new();
1390 int l1 = gen_new_label();
1391
1392 gen_load_gpr(t1, rs);
1393 tcg_gen_addi_tl(t0, t1, uimm);
1394
1395 tcg_gen_xori_tl(t1, t1, ~uimm);
1396 tcg_gen_xori_tl(t2, t0, uimm);
1397 tcg_gen_and_tl(t1, t1, t2);
1398 tcg_temp_free(t2);
1399 tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
1400 tcg_temp_free(t1);
1401 /* operands of same sign, result different sign */
1402 generate_exception(ctx, EXCP_OVERFLOW);
1403 gen_set_label(l1);
1404 gen_store_gpr(t0, rt);
1405 tcg_temp_free(t0);
1406 }
1407 opn = "daddi";
1408 break;
1409 case OPC_DADDIU:
1410 if (rs != 0) {
1411 tcg_gen_addi_tl(cpu_gpr[rt], cpu_gpr[rs], uimm);
1412 } else {
1413 tcg_gen_movi_tl(cpu_gpr[rt], uimm);
1414 }
1415 opn = "daddiu";
1416 break;
1417 #endif
1418 }
1419 (void)opn; /* avoid a compiler warning */
1420 MIPS_DEBUG("%s %s, %s, " TARGET_FMT_lx, opn, regnames[rt], regnames[rs], uimm);
1421 }
1422
1423 /* Logic with immediate operand */
1424 static void gen_logic_imm (CPUState *env, uint32_t opc, int rt, int rs, int16_t imm)
1425 {
1426 target_ulong uimm;
1427 const char *opn = "imm logic";
1428
1429 if (rt == 0) {
1430 /* If no destination, treat it as a NOP. */
1431 MIPS_DEBUG("NOP");
1432 return;
1433 }
1434 uimm = (uint16_t)imm;
1435 switch (opc) {
1436 case OPC_ANDI:
1437 if (likely(rs != 0))
1438 tcg_gen_andi_tl(cpu_gpr[rt], cpu_gpr[rs], uimm);
1439 else
1440 tcg_gen_movi_tl(cpu_gpr[rt], 0);
1441 opn = "andi";
1442 break;
1443 case OPC_ORI:
1444 if (rs != 0)
1445 tcg_gen_ori_tl(cpu_gpr[rt], cpu_gpr[rs], uimm);
1446 else
1447 tcg_gen_movi_tl(cpu_gpr[rt], uimm);
1448 opn = "ori";
1449 break;
1450 case OPC_XORI:
1451 if (likely(rs != 0))
1452 tcg_gen_xori_tl(cpu_gpr[rt], cpu_gpr[rs], uimm);
1453 else
1454 tcg_gen_movi_tl(cpu_gpr[rt], uimm);
1455 opn = "xori";
1456 break;
1457 case OPC_LUI:
1458 tcg_gen_movi_tl(cpu_gpr[rt], imm << 16);
1459 opn = "lui";
1460 break;
1461 }
1462 (void)opn; /* avoid a compiler warning */
1463 MIPS_DEBUG("%s %s, %s, " TARGET_FMT_lx, opn, regnames[rt], regnames[rs], uimm);
1464 }
1465
1466 /* Set on less than with immediate operand */
1467 static void gen_slt_imm (CPUState *env, uint32_t opc, int rt, int rs, int16_t imm)
1468 {
1469 target_ulong uimm = (target_long)imm; /* Sign extend to 32/64 bits */
1470 const char *opn = "imm arith";
1471 TCGv t0;
1472
1473 if (rt == 0) {
1474 /* If no destination, treat it as a NOP. */
1475 MIPS_DEBUG("NOP");
1476 return;
1477 }
1478 t0 = tcg_temp_new();
1479 gen_load_gpr(t0, rs);
1480 switch (opc) {
1481 case OPC_SLTI:
1482 tcg_gen_setcondi_tl(TCG_COND_LT, cpu_gpr[rt], t0, uimm);
1483 opn = "slti";
1484 break;
1485 case OPC_SLTIU:
1486 tcg_gen_setcondi_tl(TCG_COND_LTU, cpu_gpr[rt], t0, uimm);
1487 opn = "sltiu";
1488 break;
1489 }
1490 (void)opn; /* avoid a compiler warning */
1491 MIPS_DEBUG("%s %s, %s, " TARGET_FMT_lx, opn, regnames[rt], regnames[rs], uimm);
1492 tcg_temp_free(t0);
1493 }
1494
1495 /* Shifts with immediate operand */
1496 static void gen_shift_imm(CPUState *env, DisasContext *ctx, uint32_t opc,
1497 int rt, int rs, int16_t imm)
1498 {
1499 target_ulong uimm = ((uint16_t)imm) & 0x1f;
1500 const char *opn = "imm shift";
1501 TCGv t0;
1502
1503 if (rt == 0) {
1504 /* If no destination, treat it as a NOP. */
1505 MIPS_DEBUG("NOP");
1506 return;
1507 }
1508
1509 t0 = tcg_temp_new();
1510 gen_load_gpr(t0, rs);
1511 switch (opc) {
1512 case OPC_SLL:
1513 tcg_gen_shli_tl(t0, t0, uimm);
1514 tcg_gen_ext32s_tl(cpu_gpr[rt], t0);
1515 opn = "sll";
1516 break;
1517 case OPC_SRA:
1518 tcg_gen_sari_tl(cpu_gpr[rt], t0, uimm);
1519 opn = "sra";
1520 break;
1521 case OPC_SRL:
1522 if (uimm != 0) {
1523 tcg_gen_ext32u_tl(t0, t0);
1524 tcg_gen_shri_tl(cpu_gpr[rt], t0, uimm);
1525 } else {
1526 tcg_gen_ext32s_tl(cpu_gpr[rt], t0);
1527 }
1528 opn = "srl";
1529 break;
1530 case OPC_ROTR:
1531 if (uimm != 0) {
1532 TCGv_i32 t1 = tcg_temp_new_i32();
1533
1534 tcg_gen_trunc_tl_i32(t1, t0);
1535 tcg_gen_rotri_i32(t1, t1, uimm);
1536 tcg_gen_ext_i32_tl(cpu_gpr[rt], t1);
1537 tcg_temp_free_i32(t1);
1538 } else {
1539 tcg_gen_ext32s_tl(cpu_gpr[rt], t0);
1540 }
1541 opn = "rotr";
1542 break;
1543 #if defined(TARGET_MIPS64)
1544 case OPC_DSLL:
1545 tcg_gen_shli_tl(cpu_gpr[rt], t0, uimm);
1546 opn = "dsll";
1547 break;
1548 case OPC_DSRA:
1549 tcg_gen_sari_tl(cpu_gpr[rt], t0, uimm);
1550 opn = "dsra";
1551 break;
1552 case OPC_DSRL:
1553 tcg_gen_shri_tl(cpu_gpr[rt], t0, uimm);
1554 opn = "dsrl";
1555 break;
1556 case OPC_DROTR:
1557 if (uimm != 0) {
1558 tcg_gen_rotri_tl(cpu_gpr[rt], t0, uimm);
1559 } else {
1560 tcg_gen_mov_tl(cpu_gpr[rt], t0);
1561 }
1562 opn = "drotr";
1563 break;
1564 case OPC_DSLL32:
1565 tcg_gen_shli_tl(cpu_gpr[rt], t0, uimm + 32);
1566 opn = "dsll32";
1567 break;
1568 case OPC_DSRA32:
1569 tcg_gen_sari_tl(cpu_gpr[rt], t0, uimm + 32);
1570 opn = "dsra32";
1571 break;
1572 case OPC_DSRL32:
1573 tcg_gen_shri_tl(cpu_gpr[rt], t0, uimm + 32);
1574 opn = "dsrl32";
1575 break;
1576 case OPC_DROTR32:
1577 tcg_gen_rotri_tl(cpu_gpr[rt], t0, uimm + 32);
1578 opn = "drotr32";
1579 break;
1580 #endif
1581 }
1582 (void)opn; /* avoid a compiler warning */
1583 MIPS_DEBUG("%s %s, %s, " TARGET_FMT_lx, opn, regnames[rt], regnames[rs], uimm);
1584 tcg_temp_free(t0);
1585 }
1586
1587 /* Arithmetic */
1588 static void gen_arith (CPUState *env, DisasContext *ctx, uint32_t opc,
1589 int rd, int rs, int rt)
1590 {
1591 const char *opn = "arith";
1592
1593 if (rd == 0 && opc != OPC_ADD && opc != OPC_SUB
1594 && opc != OPC_DADD && opc != OPC_DSUB) {
1595 /* If no destination, treat it as a NOP.
1596 For add & sub, we must generate the overflow exception when needed. */
1597 MIPS_DEBUG("NOP");
1598 return;
1599 }
1600
1601 switch (opc) {
1602 case OPC_ADD:
1603 {
1604 TCGv t0 = tcg_temp_local_new();
1605 TCGv t1 = tcg_temp_new();
1606 TCGv t2 = tcg_temp_new();
1607 int l1 = gen_new_label();
1608
1609 gen_load_gpr(t1, rs);
1610 gen_load_gpr(t2, rt);
1611 tcg_gen_add_tl(t0, t1, t2);
1612 tcg_gen_ext32s_tl(t0, t0);
1613 tcg_gen_xor_tl(t1, t1, t2);
1614 tcg_gen_xor_tl(t2, t0, t2);
1615 tcg_gen_andc_tl(t1, t2, t1);
1616 tcg_temp_free(t2);
1617 tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
1618 tcg_temp_free(t1);
1619 /* operands of same sign, result different sign */
1620 generate_exception(ctx, EXCP_OVERFLOW);
1621 gen_set_label(l1);
1622 gen_store_gpr(t0, rd);
1623 tcg_temp_free(t0);
1624 }
1625 opn = "add";
1626 break;
1627 case OPC_ADDU:
1628 if (rs != 0 && rt != 0) {
1629 tcg_gen_add_tl(cpu_gpr[rd], cpu_gpr[rs], cpu_gpr[rt]);
1630 tcg_gen_ext32s_tl(cpu_gpr[rd], cpu_gpr[rd]);
1631 } else if (rs == 0 && rt != 0) {
1632 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rt]);
1633 } else if (rs != 0 && rt == 0) {
1634 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rs]);
1635 } else {
1636 tcg_gen_movi_tl(cpu_gpr[rd], 0);
1637 }
1638 opn = "addu";
1639 break;
1640 case OPC_SUB:
1641 {
1642 TCGv t0 = tcg_temp_local_new();
1643 TCGv t1 = tcg_temp_new();
1644 TCGv t2 = tcg_temp_new();
1645 int l1 = gen_new_label();
1646
1647 gen_load_gpr(t1, rs);
1648 gen_load_gpr(t2, rt);
1649 tcg_gen_sub_tl(t0, t1, t2);
1650 tcg_gen_ext32s_tl(t0, t0);
1651 tcg_gen_xor_tl(t2, t1, t2);
1652 tcg_gen_xor_tl(t1, t0, t1);
1653 tcg_gen_and_tl(t1, t1, t2);
1654 tcg_temp_free(t2);
1655 tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
1656 tcg_temp_free(t1);
1657 /* operands of different sign, first operand and result different sign */
1658 generate_exception(ctx, EXCP_OVERFLOW);
1659 gen_set_label(l1);
1660 gen_store_gpr(t0, rd);
1661 tcg_temp_free(t0);
1662 }
1663 opn = "sub";
1664 break;
1665 case OPC_SUBU:
1666 if (rs != 0 && rt != 0) {
1667 tcg_gen_sub_tl(cpu_gpr[rd], cpu_gpr[rs], cpu_gpr[rt]);
1668 tcg_gen_ext32s_tl(cpu_gpr[rd], cpu_gpr[rd]);
1669 } else if (rs == 0 && rt != 0) {
1670 tcg_gen_neg_tl(cpu_gpr[rd], cpu_gpr[rt]);
1671 tcg_gen_ext32s_tl(cpu_gpr[rd], cpu_gpr[rd]);
1672 } else if (rs != 0 && rt == 0) {
1673 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rs]);
1674 } else {
1675 tcg_gen_movi_tl(cpu_gpr[rd], 0);
1676 }
1677 opn = "subu";
1678 break;
1679 #if defined(TARGET_MIPS64)
1680 case OPC_DADD:
1681 {
1682 TCGv t0 = tcg_temp_local_new();
1683 TCGv t1 = tcg_temp_new();
1684 TCGv t2 = tcg_temp_new();
1685 int l1 = gen_new_label();
1686
1687 gen_load_gpr(t1, rs);
1688 gen_load_gpr(t2, rt);
1689 tcg_gen_add_tl(t0, t1, t2);
1690 tcg_gen_xor_tl(t1, t1, t2);
1691 tcg_gen_xor_tl(t2, t0, t2);
1692 tcg_gen_andc_tl(t1, t2, t1);
1693 tcg_temp_free(t2);
1694 tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
1695 tcg_temp_free(t1);
1696 /* operands of same sign, result different sign */
1697 generate_exception(ctx, EXCP_OVERFLOW);
1698 gen_set_label(l1);
1699 gen_store_gpr(t0, rd);
1700 tcg_temp_free(t0);
1701 }
1702 opn = "dadd";
1703 break;
1704 case OPC_DADDU:
1705 if (rs != 0 && rt != 0) {
1706 tcg_gen_add_tl(cpu_gpr[rd], cpu_gpr[rs], cpu_gpr[rt]);
1707 } else if (rs == 0 && rt != 0) {
1708 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rt]);
1709 } else if (rs != 0 && rt == 0) {
1710 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rs]);
1711 } else {
1712 tcg_gen_movi_tl(cpu_gpr[rd], 0);
1713 }
1714 opn = "daddu";
1715 break;
1716 case OPC_DSUB:
1717 {
1718 TCGv t0 = tcg_temp_local_new();
1719 TCGv t1 = tcg_temp_new();
1720 TCGv t2 = tcg_temp_new();
1721 int l1 = gen_new_label();
1722
1723 gen_load_gpr(t1, rs);
1724 gen_load_gpr(t2, rt);
1725 tcg_gen_sub_tl(t0, t1, t2);
1726 tcg_gen_xor_tl(t2, t1, t2);
1727 tcg_gen_xor_tl(t1, t0, t1);
1728 tcg_gen_and_tl(t1, t1, t2);
1729 tcg_temp_free(t2);
1730 tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
1731 tcg_temp_free(t1);
1732 /* operands of different sign, first operand and result different sign */
1733 generate_exception(ctx, EXCP_OVERFLOW);
1734 gen_set_label(l1);
1735 gen_store_gpr(t0, rd);
1736 tcg_temp_free(t0);
1737 }
1738 opn = "dsub";
1739 break;
1740 case OPC_DSUBU:
1741 if (rs != 0 && rt != 0) {
1742 tcg_gen_sub_tl(cpu_gpr[rd], cpu_gpr[rs], cpu_gpr[rt]);
1743 } else if (rs == 0 && rt != 0) {
1744 tcg_gen_neg_tl(cpu_gpr[rd], cpu_gpr[rt]);
1745 } else if (rs != 0 && rt == 0) {
1746 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rs]);
1747 } else {
1748 tcg_gen_movi_tl(cpu_gpr[rd], 0);
1749 }
1750 opn = "dsubu";
1751 break;
1752 #endif
1753 case OPC_MUL:
1754 if (likely(rs != 0 && rt != 0)) {
1755 tcg_gen_mul_tl(cpu_gpr[rd], cpu_gpr[rs], cpu_gpr[rt]);
1756 tcg_gen_ext32s_tl(cpu_gpr[rd], cpu_gpr[rd]);
1757 } else {
1758 tcg_gen_movi_tl(cpu_gpr[rd], 0);
1759 }
1760 opn = "mul";
1761 break;
1762 }
1763 (void)opn; /* avoid a compiler warning */
1764 MIPS_DEBUG("%s %s, %s, %s", opn, regnames[rd], regnames[rs], regnames[rt]);
1765 }
1766
1767 /* Conditional move */
1768 static void gen_cond_move (CPUState *env, uint32_t opc, int rd, int rs, int rt)
1769 {
1770 const char *opn = "cond move";
1771 int l1;
1772
1773 if (rd == 0) {
1774 /* If no destination, treat it as a NOP.
1775 For add & sub, we must generate the overflow exception when needed. */
1776 MIPS_DEBUG("NOP");
1777 return;
1778 }
1779
1780 l1 = gen_new_label();
1781 switch (opc) {
1782 case OPC_MOVN:
1783 if (likely(rt != 0))
1784 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr[rt], 0, l1);
1785 else
1786 tcg_gen_br(l1);
1787 opn = "movn";
1788 break;
1789 case OPC_MOVZ:
1790 if (likely(rt != 0))
1791 tcg_gen_brcondi_tl(TCG_COND_NE, cpu_gpr[rt], 0, l1);
1792 opn = "movz";
1793 break;
1794 }
1795 if (rs != 0)
1796 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rs]);
1797 else
1798 tcg_gen_movi_tl(cpu_gpr[rd], 0);
1799 gen_set_label(l1);
1800
1801 (void)opn; /* avoid a compiler warning */
1802 MIPS_DEBUG("%s %s, %s, %s", opn, regnames[rd], regnames[rs], regnames[rt]);
1803 }
1804
1805 /* Logic */
1806 static void gen_logic (CPUState *env, uint32_t opc, int rd, int rs, int rt)
1807 {
1808 const char *opn = "logic";
1809
1810 if (rd == 0) {
1811 /* If no destination, treat it as a NOP. */
1812 MIPS_DEBUG("NOP");
1813 return;
1814 }
1815
1816 switch (opc) {
1817 case OPC_AND:
1818 if (likely(rs != 0 && rt != 0)) {
1819 tcg_gen_and_tl(cpu_gpr[rd], cpu_gpr[rs], cpu_gpr[rt]);
1820 } else {
1821 tcg_gen_movi_tl(cpu_gpr[rd], 0);
1822 }
1823 opn = "and";
1824 break;
1825 case OPC_NOR:
1826 if (rs != 0 && rt != 0) {
1827 tcg_gen_nor_tl(cpu_gpr[rd], cpu_gpr[rs], cpu_gpr[rt]);
1828 } else if (rs == 0 && rt != 0) {
1829 tcg_gen_not_tl(cpu_gpr[rd], cpu_gpr[rt]);
1830 } else if (rs != 0 && rt == 0) {
1831 tcg_gen_not_tl(cpu_gpr[rd], cpu_gpr[rs]);
1832 } else {
1833 tcg_gen_movi_tl(cpu_gpr[rd], ~((target_ulong)0));
1834 }
1835 opn = "nor";
1836 break;
1837 case OPC_OR:
1838 if (likely(rs != 0 && rt != 0)) {
1839 tcg_gen_or_tl(cpu_gpr[rd], cpu_gpr[rs], cpu_gpr[rt]);
1840 } else if (rs == 0 && rt != 0) {
1841 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rt]);
1842 } else if (rs != 0 && rt == 0) {
1843 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rs]);
1844 } else {
1845 tcg_gen_movi_tl(cpu_gpr[rd], 0);
1846 }
1847 opn = "or";
1848 break;
1849 case OPC_XOR:
1850 if (likely(rs != 0 && rt != 0)) {
1851 tcg_gen_xor_tl(cpu_gpr[rd], cpu_gpr[rs], cpu_gpr[rt]);
1852 } else if (rs == 0 && rt != 0) {
1853 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rt]);
1854 } else if (rs != 0 && rt == 0) {
1855 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rs]);
1856 } else {
1857 tcg_gen_movi_tl(cpu_gpr[rd], 0);
1858 }
1859 opn = "xor";
1860 break;
1861 }
1862 (void)opn; /* avoid a compiler warning */
1863 MIPS_DEBUG("%s %s, %s, %s", opn, regnames[rd], regnames[rs], regnames[rt]);
1864 }
1865
1866 /* Set on lower than */
1867 static void gen_slt (CPUState *env, uint32_t opc, int rd, int rs, int rt)
1868 {
1869 const char *opn = "slt";
1870 TCGv t0, t1;
1871
1872 if (rd == 0) {
1873 /* If no destination, treat it as a NOP. */
1874 MIPS_DEBUG("NOP");
1875 return;
1876 }
1877
1878 t0 = tcg_temp_new();
1879 t1 = tcg_temp_new();
1880 gen_load_gpr(t0, rs);
1881 gen_load_gpr(t1, rt);
1882 switch (opc) {
1883 case OPC_SLT:
1884 tcg_gen_setcond_tl(TCG_COND_LT, cpu_gpr[rd], t0, t1);
1885 opn = "slt";
1886 break;
1887 case OPC_SLTU:
1888 tcg_gen_setcond_tl(TCG_COND_LTU, cpu_gpr[rd], t0, t1);
1889 opn = "sltu";
1890 break;
1891 }
1892 (void)opn; /* avoid a compiler warning */
1893 MIPS_DEBUG("%s %s, %s, %s", opn, regnames[rd], regnames[rs], regnames[rt]);
1894 tcg_temp_free(t0);
1895 tcg_temp_free(t1);
1896 }
1897
1898 /* Shifts */
1899 static void gen_shift (CPUState *env, DisasContext *ctx, uint32_t opc,
1900 int rd, int rs, int rt)
1901 {
1902 const char *opn = "shifts";
1903 TCGv t0, t1;
1904
1905 if (rd == 0) {
1906 /* If no destination, treat it as a NOP.
1907 For add & sub, we must generate the overflow exception when needed. */
1908 MIPS_DEBUG("NOP");
1909 return;
1910 }
1911
1912 t0 = tcg_temp_new();
1913 t1 = tcg_temp_new();
1914 gen_load_gpr(t0, rs);
1915 gen_load_gpr(t1, rt);
1916 switch (opc) {
1917 case OPC_SLLV:
1918 tcg_gen_andi_tl(t0, t0, 0x1f);
1919 tcg_gen_shl_tl(t0, t1, t0);
1920 tcg_gen_ext32s_tl(cpu_gpr[rd], t0);
1921 opn = "sllv";
1922 break;
1923 case OPC_SRAV:
1924 tcg_gen_andi_tl(t0, t0, 0x1f);
1925 tcg_gen_sar_tl(cpu_gpr[rd], t1, t0);
1926 opn = "srav";
1927 break;
1928 case OPC_SRLV:
1929 tcg_gen_ext32u_tl(t1, t1);
1930 tcg_gen_andi_tl(t0, t0, 0x1f);
1931 tcg_gen_shr_tl(t0, t1, t0);
1932 tcg_gen_ext32s_tl(cpu_gpr[rd], t0);
1933 opn = "srlv";
1934 break;
1935 case OPC_ROTRV:
1936 {
1937 TCGv_i32 t2 = tcg_temp_new_i32();
1938 TCGv_i32 t3 = tcg_temp_new_i32();
1939
1940 tcg_gen_trunc_tl_i32(t2, t0);
1941 tcg_gen_trunc_tl_i32(t3, t1);
1942 tcg_gen_andi_i32(t2, t2, 0x1f);
1943 tcg_gen_rotr_i32(t2, t3, t2);
1944 tcg_gen_ext_i32_tl(cpu_gpr[rd], t2);
1945 tcg_temp_free_i32(t2);
1946 tcg_temp_free_i32(t3);
1947 opn = "rotrv";
1948 }
1949 break;
1950 #if defined(TARGET_MIPS64)
1951 case OPC_DSLLV:
1952 tcg_gen_andi_tl(t0, t0, 0x3f);
1953 tcg_gen_shl_tl(cpu_gpr[rd], t1, t0);
1954 opn = "dsllv";
1955 break;
1956 case OPC_DSRAV:
1957 tcg_gen_andi_tl(t0, t0, 0x3f);
1958 tcg_gen_sar_tl(cpu_gpr[rd], t1, t0);
1959 opn = "dsrav";
1960 break;
1961 case OPC_DSRLV:
1962 tcg_gen_andi_tl(t0, t0, 0x3f);
1963 tcg_gen_shr_tl(cpu_gpr[rd], t1, t0);
1964 opn = "dsrlv";
1965 break;
1966 case OPC_DROTRV:
1967 tcg_gen_andi_tl(t0, t0, 0x3f);
1968 tcg_gen_rotr_tl(cpu_gpr[rd], t1, t0);
1969 opn = "drotrv";
1970 break;
1971 #endif
1972 }
1973 (void)opn; /* avoid a compiler warning */
1974 MIPS_DEBUG("%s %s, %s, %s", opn, regnames[rd], regnames[rs], regnames[rt]);
1975 tcg_temp_free(t0);
1976 tcg_temp_free(t1);
1977 }
1978
1979 /* Arithmetic on HI/LO registers */
1980 static void gen_HILO (DisasContext *ctx, uint32_t opc, int reg)
1981 {
1982 const char *opn = "hilo";
1983
1984 if (reg == 0 && (opc == OPC_MFHI || opc == OPC_MFLO)) {
1985 /* Treat as NOP. */
1986 MIPS_DEBUG("NOP");
1987 return;
1988 }
1989 switch (opc) {
1990 case OPC_MFHI:
1991 tcg_gen_mov_tl(cpu_gpr[reg], cpu_HI[0]);
1992 opn = "mfhi";
1993 break;
1994 case OPC_MFLO:
1995 tcg_gen_mov_tl(cpu_gpr[reg], cpu_LO[0]);
1996 opn = "mflo";
1997 break;
1998 case OPC_MTHI:
1999 if (reg != 0)
2000 tcg_gen_mov_tl(cpu_HI[0], cpu_gpr[reg]);
2001 else
2002 tcg_gen_movi_tl(cpu_HI[0], 0);
2003 opn = "mthi";
2004 break;
2005 case OPC_MTLO:
2006 if (reg != 0)
2007 tcg_gen_mov_tl(cpu_LO[0], cpu_gpr[reg]);
2008 else
2009 tcg_gen_movi_tl(cpu_LO[0], 0);
2010 opn = "mtlo";
2011 break;
2012 }
2013 (void)opn; /* avoid a compiler warning */
2014 MIPS_DEBUG("%s %s", opn, regnames[reg]);
2015 }
2016
2017 static void gen_muldiv (DisasContext *ctx, uint32_t opc,
2018 int rs, int rt)
2019 {
2020 const char *opn = "mul/div";
2021 TCGv t0, t1;
2022
2023 switch (opc) {
2024 case OPC_DIV:
2025 case OPC_DIVU:
2026 #if defined(TARGET_MIPS64)
2027 case OPC_DDIV:
2028 case OPC_DDIVU:
2029 #endif
2030 t0 = tcg_temp_local_new();
2031 t1 = tcg_temp_local_new();
2032 break;
2033 default:
2034 t0 = tcg_temp_new();
2035 t1 = tcg_temp_new();
2036 break;
2037 }
2038
2039 gen_load_gpr(t0, rs);
2040 gen_load_gpr(t1, rt);
2041 switch (opc) {
2042 case OPC_DIV:
2043 {
2044 int l1 = gen_new_label();
2045 int l2 = gen_new_label();
2046
2047 tcg_gen_ext32s_tl(t0, t0);
2048 tcg_gen_ext32s_tl(t1, t1);
2049 tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
2050 tcg_gen_brcondi_tl(TCG_COND_NE, t0, INT_MIN, l2);
2051 tcg_gen_brcondi_tl(TCG_COND_NE, t1, -1, l2);
2052
2053 tcg_gen_mov_tl(cpu_LO[0], t0);
2054 tcg_gen_movi_tl(cpu_HI[0], 0);
2055 tcg_gen_br(l1);
2056 gen_set_label(l2);
2057 tcg_gen_div_tl(cpu_LO[0], t0, t1);
2058 tcg_gen_rem_tl(cpu_HI[0], t0, t1);
2059 tcg_gen_ext32s_tl(cpu_LO[0], cpu_LO[0]);
2060 tcg_gen_ext32s_tl(cpu_HI[0], cpu_HI[0]);
2061 gen_set_label(l1);
2062 }
2063 opn = "div";
2064 break;
2065 case OPC_DIVU:
2066 {
2067 int l1 = gen_new_label();
2068
2069 tcg_gen_ext32u_tl(t0, t0);
2070 tcg_gen_ext32u_tl(t1, t1);
2071 tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
2072 tcg_gen_divu_tl(cpu_LO[0], t0, t1);
2073 tcg_gen_remu_tl(cpu_HI[0], t0, t1);
2074 tcg_gen_ext32s_tl(cpu_LO[0], cpu_LO[0]);
2075 tcg_gen_ext32s_tl(cpu_HI[0], cpu_HI[0]);
2076 gen_set_label(l1);
2077 }
2078 opn = "divu";
2079 break;
2080 case OPC_MULT:
2081 {
2082 TCGv_i64 t2 = tcg_temp_new_i64();
2083 TCGv_i64 t3 = tcg_temp_new_i64();
2084
2085 tcg_gen_ext_tl_i64(t2, t0);
2086 tcg_gen_ext_tl_i64(t3, t1);
2087 tcg_gen_mul_i64(t2, t2, t3);
2088 tcg_temp_free_i64(t3);
2089 tcg_gen_trunc_i64_tl(t0, t2);
2090 tcg_gen_shri_i64(t2, t2, 32);
2091 tcg_gen_trunc_i64_tl(t1, t2);
2092 tcg_temp_free_i64(t2);
2093 tcg_gen_ext32s_tl(cpu_LO[0], t0);
2094 tcg_gen_ext32s_tl(cpu_HI[0], t1);
2095 }
2096 opn = "mult";
2097 break;
2098 case OPC_MULTU:
2099 {
2100 TCGv_i64 t2 = tcg_temp_new_i64();
2101 TCGv_i64 t3 = tcg_temp_new_i64();
2102
2103 tcg_gen_ext32u_tl(t0, t0);
2104 tcg_gen_ext32u_tl(t1, t1);
2105 tcg_gen_extu_tl_i64(t2, t0);
2106 tcg_gen_extu_tl_i64(t3, t1);
2107 tcg_gen_mul_i64(t2, t2, t3);
2108 tcg_temp_free_i64(t3);
2109 tcg_gen_trunc_i64_tl(t0, t2);
2110 tcg_gen_shri_i64(t2, t2, 32);
2111 tcg_gen_trunc_i64_tl(t1, t2);
2112 tcg_temp_free_i64(t2);
2113 tcg_gen_ext32s_tl(cpu_LO[0], t0);
2114 tcg_gen_ext32s_tl(cpu_HI[0], t1);
2115 }
2116 opn = "multu";
2117 break;
2118 #if defined(TARGET_MIPS64)
2119 case OPC_DDIV:
2120 {
2121 int l1 = gen_new_label();
2122 int l2 = gen_new_label();
2123
2124 tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
2125 tcg_gen_brcondi_tl(TCG_COND_NE, t0, -1LL << 63, l2);
2126 tcg_gen_brcondi_tl(TCG_COND_NE, t1, -1LL, l2);
2127 tcg_gen_mov_tl(cpu_LO[0], t0);
2128 tcg_gen_movi_tl(cpu_HI[0], 0);
2129 tcg_gen_br(l1);
2130 gen_set_label(l2);
2131 tcg_gen_div_i64(cpu_LO[0], t0, t1);
2132 tcg_gen_rem_i64(cpu_HI[0], t0, t1);
2133 gen_set_label(l1);
2134 }
2135 opn = "ddiv";
2136 break;
2137 case OPC_DDIVU:
2138 {
2139 int l1 = gen_new_label();
2140
2141 tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
2142 tcg_gen_divu_i64(cpu_LO[0], t0, t1);
2143 tcg_gen_remu_i64(cpu_HI[0], t0, t1);
2144 gen_set_label(l1);
2145 }
2146 opn = "ddivu";
2147 break;
2148 case OPC_DMULT:
2149 gen_helper_dmult(t0, t1);
2150 opn = "dmult";
2151 break;
2152 case OPC_DMULTU:
2153 gen_helper_dmultu(t0, t1);
2154 opn = "dmultu";
2155 break;
2156 #endif
2157 case OPC_MADD:
2158 {
2159 TCGv_i64 t2 = tcg_temp_new_i64();
2160 TCGv_i64 t3 = tcg_temp_new_i64();
2161
2162 tcg_gen_ext_tl_i64(t2, t0);
2163 tcg_gen_ext_tl_i64(t3, t1);
2164 tcg_gen_mul_i64(t2, t2, t3);
2165 tcg_gen_concat_tl_i64(t3, cpu_LO[0], cpu_HI[0]);
2166 tcg_gen_add_i64(t2, t2, t3);
2167 tcg_temp_free_i64(t3);
2168 tcg_gen_trunc_i64_tl(t0, t2);
2169 tcg_gen_shri_i64(t2, t2, 32);
2170 tcg_gen_trunc_i64_tl(t1, t2);
2171 tcg_temp_free_i64(t2);
2172 tcg_gen_ext32s_tl(cpu_LO[0], t0);
2173 tcg_gen_ext32s_tl(cpu_HI[0], t1);
2174 }
2175 opn = "madd";
2176 break;
2177 case OPC_MADDU:
2178 {
2179 TCGv_i64 t2 = tcg_temp_new_i64();
2180 TCGv_i64 t3 = tcg_temp_new_i64();
2181
2182 tcg_gen_ext32u_tl(t0, t0);
2183 tcg_gen_ext32u_tl(t1, t1);
2184 tcg_gen_extu_tl_i64(t2, t0);
2185 tcg_gen_extu_tl_i64(t3, t1);
2186 tcg_gen_mul_i64(t2, t2, t3);
2187 tcg_gen_concat_tl_i64(t3, cpu_LO[0], cpu_HI[0]);
2188 tcg_gen_add_i64(t2, t2, t3);
2189 tcg_temp_free_i64(t3);
2190 tcg_gen_trunc_i64_tl(t0, t2);
2191 tcg_gen_shri_i64(t2, t2, 32);
2192 tcg_gen_trunc_i64_tl(t1, t2);
2193 tcg_temp_free_i64(t2);
2194 tcg_gen_ext32s_tl(cpu_LO[0], t0);
2195 tcg_gen_ext32s_tl(cpu_HI[0], t1);
2196 }
2197 opn = "maddu";
2198 break;
2199 case OPC_MSUB:
2200 {
2201 TCGv_i64 t2 = tcg_temp_new_i64();
2202 TCGv_i64 t3 = tcg_temp_new_i64();
2203
2204 tcg_gen_ext_tl_i64(t2, t0);
2205 tcg_gen_ext_tl_i64(t3, t1);
2206 tcg_gen_mul_i64(t2, t2, t3);
2207 tcg_gen_concat_tl_i64(t3, cpu_LO[0], cpu_HI[0]);
2208 tcg_gen_sub_i64(t2, t3, t2);
2209 tcg_temp_free_i64(t3);
2210 tcg_gen_trunc_i64_tl(t0, t2);
2211 tcg_gen_shri_i64(t2, t2, 32);
2212 tcg_gen_trunc_i64_tl(t1, t2);
2213 tcg_temp_free_i64(t2);
2214 tcg_gen_ext32s_tl(cpu_LO[0], t0);
2215 tcg_gen_ext32s_tl(cpu_HI[0], t1);
2216 }
2217 opn = "msub";
2218 break;
2219 case OPC_MSUBU:
2220 {
2221 TCGv_i64 t2 = tcg_temp_new_i64();
2222 TCGv_i64 t3 = tcg_temp_new_i64();
2223
2224 tcg_gen_ext32u_tl(t0, t0);
2225 tcg_gen_ext32u_tl(t1, t1);
2226 tcg_gen_extu_tl_i64(t2, t0);
2227 tcg_gen_extu_tl_i64(t3, t1);
2228 tcg_gen_mul_i64(t2, t2, t3);
2229 tcg_gen_concat_tl_i64(t3, cpu_LO[0], cpu_HI[0]);
2230 tcg_gen_sub_i64(t2, t3, t2);
2231 tcg_temp_free_i64(t3);
2232 tcg_gen_trunc_i64_tl(t0, t2);
2233 tcg_gen_shri_i64(t2, t2, 32);
2234 tcg_gen_trunc_i64_tl(t1, t2);
2235 tcg_temp_free_i64(t2);
2236 tcg_gen_ext32s_tl(cpu_LO[0], t0);
2237 tcg_gen_ext32s_tl(cpu_HI[0], t1);
2238 }
2239 opn = "msubu";
2240 break;
2241 default:
2242 MIPS_INVAL(opn);
2243 generate_exception(ctx, EXCP_RI);
2244 goto out;
2245 }
2246 (void)opn; /* avoid a compiler warning */
2247 MIPS_DEBUG("%s %s %s", opn, regnames[rs], regnames[rt]);
2248 out:
2249 tcg_temp_free(t0);
2250 tcg_temp_free(t1);
2251 }
2252
2253 static void gen_mul_vr54xx (DisasContext *ctx, uint32_t opc,
2254 int rd, int rs, int rt)
2255 {
2256 const char *opn = "mul vr54xx";
2257 TCGv t0 = tcg_temp_new();
2258 TCGv t1 = tcg_temp_new();
2259
2260 gen_load_gpr(t0, rs);
2261 gen_load_gpr(t1, rt);
2262
2263 switch (opc) {
2264 case OPC_VR54XX_MULS:
2265 gen_helper_muls(t0, t0, t1);
2266 opn = "muls";
2267 break;
2268 case OPC_VR54XX_MULSU:
2269 gen_helper_mulsu(t0, t0, t1);
2270 opn = "mulsu";
2271 break;
2272 case OPC_VR54XX_MACC:
2273 gen_helper_macc(t0, t0, t1);
2274 opn = "macc";
2275 break;
2276 case OPC_VR54XX_MACCU:
2277 gen_helper_maccu(t0, t0, t1);
2278 opn = "maccu";
2279 break;
2280 case OPC_VR54XX_MSAC:
2281 gen_helper_msac(t0, t0, t1);
2282 opn = "msac";
2283 break;
2284 case OPC_VR54XX_MSACU:
2285 gen_helper_msacu(t0, t0, t1);
2286 opn = "msacu";
2287 break;
2288 case OPC_VR54XX_MULHI:
2289 gen_helper_mulhi(t0, t0, t1);
2290 opn = "mulhi";
2291 break;
2292 case OPC_VR54XX_MULHIU:
2293 gen_helper_mulhiu(t0, t0, t1);
2294 opn = "mulhiu";
2295 break;
2296 case OPC_VR54XX_MULSHI:
2297 gen_helper_mulshi(t0, t0, t1);
2298 opn = "mulshi";
2299 break;
2300 case OPC_VR54XX_MULSHIU:
2301 gen_helper_mulshiu(t0, t0, t1);
2302 opn = "mulshiu";
2303 break;
2304 case OPC_VR54XX_MACCHI:
2305 gen_helper_macchi(t0, t0, t1);
2306 opn = "macchi";
2307 break;
2308 case OPC_VR54XX_MACCHIU:
2309 gen_helper_macchiu(t0, t0, t1);
2310 opn = "macchiu";
2311 break;
2312 case OPC_VR54XX_MSACHI:
2313 gen_helper_msachi(t0, t0, t1);
2314 opn = "msachi";
2315 break;
2316 case OPC_VR54XX_MSACHIU:
2317 gen_helper_msachiu(t0, t0, t1);
2318 opn = "msachiu";
2319 break;
2320 default:
2321 MIPS_INVAL("mul vr54xx");
2322 generate_exception(ctx, EXCP_RI);
2323 goto out;
2324 }
2325 gen_store_gpr(t0, rd);
2326 (void)opn; /* avoid a compiler warning */
2327 MIPS_DEBUG("%s %s, %s, %s", opn, regnames[rd], regnames[rs], regnames[rt]);
2328
2329 out:
2330 tcg_temp_free(t0);
2331 tcg_temp_free(t1);
2332 }
2333
2334 static void gen_cl (DisasContext *ctx, uint32_t opc,
2335 int rd, int rs)
2336 {
2337 const char *opn = "CLx";
2338 TCGv t0;
2339
2340 if (rd == 0) {
2341 /* Treat as NOP. */
2342 MIPS_DEBUG("NOP");
2343 return;
2344 }
2345 t0 = tcg_temp_new();
2346 gen_load_gpr(t0, rs);
2347 switch (opc) {
2348 case OPC_CLO:
2349 gen_helper_clo(cpu_gpr[rd], t0);
2350 opn = "clo";
2351 break;
2352 case OPC_CLZ:
2353 gen_helper_clz(cpu_gpr[rd], t0);
2354 opn = "clz";
2355 break;
2356 #if defined(TARGET_MIPS64)
2357 case OPC_DCLO:
2358 gen_helper_dclo(cpu_gpr[rd], t0);
2359 opn = "dclo";
2360 break;
2361 case OPC_DCLZ:
2362 gen_helper_dclz(cpu_gpr[rd], t0);
2363 opn = "dclz";
2364 break;
2365 #endif
2366 }
2367 (void)opn; /* avoid a compiler warning */
2368 MIPS_DEBUG("%s %s, %s", opn, regnames[rd], regnames[rs]);
2369 tcg_temp_free(t0);
2370 }
2371
2372 /* Godson integer instructions */
2373 static void gen_loongson_integer (DisasContext *ctx, uint32_t opc,
2374 int rd, int rs, int rt)
2375 {
2376 const char *opn = "loongson";
2377 TCGv t0, t1;
2378
2379 if (rd == 0) {
2380 /* Treat as NOP. */
2381 MIPS_DEBUG("NOP");
2382 return;
2383 }
2384
2385 switch (opc) {
2386 case OPC_MULT_G_2E:
2387 case OPC_MULT_G_2F:
2388 case OPC_MULTU_G_2E:
2389 case OPC_MULTU_G_2F:
2390 #if defined(TARGET_MIPS64)
2391 case OPC_DMULT_G_2E:
2392 case OPC_DMULT_G_2F:
2393 case OPC_DMULTU_G_2E:
2394 case OPC_DMULTU_G_2F:
2395 #endif
2396 t0 = tcg_temp_new();
2397 t1 = tcg_temp_new();
2398 break;
2399 default:
2400 t0 = tcg_temp_local_new();
2401 t1 = tcg_temp_local_new();
2402 break;
2403 }
2404
2405 gen_load_gpr(t0, rs);
2406 gen_load_gpr(t1, rt);
2407
2408 switch (opc) {
2409 case OPC_MULT_G_2E:
2410 case OPC_MULT_G_2F:
2411 tcg_gen_mul_tl(cpu_gpr[rd], t0, t1);
2412 tcg_gen_ext32s_tl(cpu_gpr[rd], cpu_gpr[rd]);
2413 opn = "mult.g";
2414 break;
2415 case OPC_MULTU_G_2E:
2416 case OPC_MULTU_G_2F:
2417 tcg_gen_ext32u_tl(t0, t0);
2418 tcg_gen_ext32u_tl(t1, t1);
2419 tcg_gen_mul_tl(cpu_gpr[rd], t0, t1);
2420 tcg_gen_ext32s_tl(cpu_gpr[rd], cpu_gpr[rd]);
2421 opn = "multu.g";
2422 break;
2423 case OPC_DIV_G_2E:
2424 case OPC_DIV_G_2F:
2425 {
2426 int l1 = gen_new_label();
2427 int l2 = gen_new_label();
2428 int l3 = gen_new_label();
2429 tcg_gen_ext32s_tl(t0, t0);
2430 tcg_gen_ext32s_tl(t1, t1);
2431 tcg_gen_brcondi_tl(TCG_COND_NE, t1, 0, l1);
2432 tcg_gen_movi_tl(cpu_gpr[rd], 0);
2433 tcg_gen_br(l3);
2434 gen_set_label(l1);
2435 tcg_gen_brcondi_tl(TCG_COND_NE, t0, INT_MIN, l2);
2436 tcg_gen_brcondi_tl(TCG_COND_NE, t1, -1, l2);
2437 tcg_gen_mov_tl(cpu_gpr[rd], t0);
2438 tcg_gen_br(l3);
2439 gen_set_label(l2);
2440 tcg_gen_div_tl(cpu_gpr[rd], t0, t1);
2441 tcg_gen_ext32s_tl(cpu_gpr[rd], cpu_gpr[rd]);
2442 gen_set_label(l3);
2443 }
2444 opn = "div.g";
2445 break;
2446 case OPC_DIVU_G_2E:
2447 case OPC_DIVU_G_2F:
2448 {
2449 int l1 = gen_new_label();
2450 int l2 = gen_new_label();
2451 tcg_gen_ext32u_tl(t0, t0);
2452 tcg_gen_ext32u_tl(t1, t1);
2453 tcg_gen_brcondi_tl(TCG_COND_NE, t1, 0, l1);
2454 tcg_gen_movi_tl(cpu_gpr[rd], 0);
2455 tcg_gen_br(l2);
2456 gen_set_label(l1);
2457 tcg_gen_divu_tl(cpu_gpr[rd], t0, t1);
2458 tcg_gen_ext32s_tl(cpu_gpr[rd], cpu_gpr[rd]);
2459 gen_set_label(l2);
2460 }
2461 opn = "divu.g";
2462 break;
2463 case OPC_MOD_G_2E:
2464 case OPC_MOD_G_2F:
2465 {
2466 int l1 = gen_new_label();
2467 int l2 = gen_new_label();
2468 int l3 = gen_new_label();
2469 tcg_gen_ext32u_tl(t0, t0);
2470 tcg_gen_ext32u_tl(t1, t1);
2471 tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
2472 tcg_gen_brcondi_tl(TCG_COND_NE, t0, INT_MIN, l2);
2473 tcg_gen_brcondi_tl(TCG_COND_NE, t1, -1, l2);
2474 gen_set_label(l1);
2475 tcg_gen_movi_tl(cpu_gpr[rd], 0);
2476 tcg_gen_br(l3);
2477 gen_set_label(l2);
2478 tcg_gen_rem_tl(cpu_gpr[rd], t0, t1);
2479 tcg_gen_ext32s_tl(cpu_gpr[rd], cpu_gpr[rd]);
2480 gen_set_label(l3);
2481 }
2482 opn = "mod.g";
2483 break;
2484 case OPC_MODU_G_2E:
2485 case OPC_MODU_G_2F:
2486 {
2487 int l1 = gen_new_label();
2488 int l2 = gen_new_label();
2489 tcg_gen_ext32u_tl(t0, t0);
2490 tcg_gen_ext32u_tl(t1, t1);
2491 tcg_gen_brcondi_tl(TCG_COND_NE, t1, 0, l1);
2492 tcg_gen_movi_tl(cpu_gpr[rd], 0);
2493 tcg_gen_br(l2);
2494 gen_set_label(l1);
2495 tcg_gen_remu_tl(cpu_gpr[rd], t0, t1);
2496 tcg_gen_ext32s_tl(cpu_gpr[rd], cpu_gpr[rd]);
2497 gen_set_label(l2);
2498 }
2499 opn = "modu.g";
2500 break;
2501 #if defined(TARGET_MIPS64)
2502 case OPC_DMULT_G_2E:
2503 case OPC_DMULT_G_2F:
2504 tcg_gen_mul_tl(cpu_gpr[rd], t0, t1);
2505 opn = "dmult.g";
2506 break;
2507 case OPC_DMULTU_G_2E:
2508 case OPC_DMULTU_G_2F:
2509 tcg_gen_mul_tl(cpu_gpr[rd], t0, t1);
2510 opn = "dmultu.g";
2511 break;
2512 case OPC_DDIV_G_2E:
2513 case OPC_DDIV_G_2F:
2514 {
2515 int l1 = gen_new_label();
2516 int l2 = gen_new_label();
2517 int l3 = gen_new_label();
2518 tcg_gen_brcondi_tl(TCG_COND_NE, t1, 0, l1);
2519 tcg_gen_movi_tl(cpu_gpr[rd], 0);
2520 tcg_gen_br(l3);
2521 gen_set_label(l1);
2522 tcg_gen_brcondi_tl(TCG_COND_NE, t0, -1LL << 63, l2);
2523 tcg_gen_brcondi_tl(TCG_COND_NE, t1, -1LL, l2);
2524 tcg_gen_mov_tl(cpu_gpr[rd], t0);
2525 tcg_gen_br(l3);
2526 gen_set_label(l2);
2527 tcg_gen_div_tl(cpu_gpr[rd], t0, t1);
2528 gen_set_label(l3);
2529 }
2530 opn = "ddiv.g";
2531 break;
2532 case OPC_DDIVU_G_2E:
2533 case OPC_DDIVU_G_2F:
2534 {
2535 int l1 = gen_new_label();
2536 int l2 = gen_new_label();
2537 tcg_gen_brcondi_tl(TCG_COND_NE, t1, 0, l1);
2538 tcg_gen_movi_tl(cpu_gpr[rd], 0);
2539 tcg_gen_br(l2);
2540 gen_set_label(l1);
2541 tcg_gen_divu_tl(cpu_gpr[rd], t0, t1);
2542 gen_set_label(l2);
2543 }
2544 opn = "ddivu.g";
2545 break;
2546 case OPC_DMOD_G_2E:
2547 case OPC_DMOD_G_2F:
2548 {
2549 int l1 = gen_new_label();
2550 int l2 = gen_new_label();
2551 int l3 = gen_new_label();
2552 tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, l1);
2553 tcg_gen_brcondi_tl(TCG_COND_NE, t0, -1LL << 63, l2);
2554 tcg_gen_brcondi_tl(TCG_COND_NE, t1, -1LL, l2);
2555 gen_set_label(l1);
2556 tcg_gen_movi_tl(cpu_gpr[rd], 0);
2557 tcg_gen_br(l3);
2558 gen_set_label(l2);
2559 tcg_gen_rem_tl(cpu_gpr[rd], t0, t1);
2560 gen_set_label(l3);
2561 }
2562 opn = "dmod.g";
2563 break;
2564 case OPC_DMODU_G_2E:
2565 case OPC_DMODU_G_2F:
2566 {
2567 int l1 = gen_new_label();
2568 int l2 = gen_new_label();
2569 tcg_gen_brcondi_tl(TCG_COND_NE, t1, 0, l1);
2570 tcg_gen_movi_tl(cpu_gpr[rd], 0);
2571 tcg_gen_br(l2);
2572 gen_set_label(l1);
2573 tcg_gen_remu_tl(cpu_gpr[rd], t0, t1);
2574 gen_set_label(l2);
2575 }
2576 opn = "dmodu.g";
2577 break;
2578 #endif
2579 }
2580
2581 (void)opn; /* avoid a compiler warning */
2582 MIPS_DEBUG("%s %s, %s", opn, regnames[rd], regnames[rs]);
2583 tcg_temp_free(t0);
2584 tcg_temp_free(t1);
2585 }
2586
2587 /* Traps */
2588 static void gen_trap (DisasContext *ctx, uint32_t opc,
2589 int rs, int rt, int16_t imm)
2590 {
2591 int cond;
2592 TCGv t0 = tcg_temp_new();
2593 TCGv t1 = tcg_temp_new();
2594
2595 cond = 0;
2596 /* Load needed operands */
2597 switch (opc) {
2598 case OPC_TEQ:
2599 case OPC_TGE:
2600 case OPC_TGEU:
2601 case OPC_TLT:
2602 case OPC_TLTU:
2603 case OPC_TNE:
2604 /* Compare two registers */
2605 if (rs != rt) {
2606 gen_load_gpr(t0, rs);
2607 gen_load_gpr(t1, rt);
2608 cond = 1;
2609 }
2610 break;
2611 case OPC_TEQI:
2612 case OPC_TGEI:
2613 case OPC_TGEIU:
2614 case OPC_TLTI:
2615 case OPC_TLTIU:
2616 case OPC_TNEI:
2617 /* Compare register to immediate */
2618 if (rs != 0 || imm != 0) {
2619 gen_load_gpr(t0, rs);
2620 tcg_gen_movi_tl(t1, (int32_t)imm);
2621 cond = 1;
2622 }
2623 break;
2624 }
2625 if (cond == 0) {
2626 switch (opc) {
2627 case OPC_TEQ: /* rs == rs */
2628 case OPC_TEQI: /* r0 == 0 */
2629 case OPC_TGE: /* rs >= rs */
2630 case OPC_TGEI: /* r0 >= 0 */
2631 case OPC_TGEU: /* rs >= rs unsigned */
2632 case OPC_TGEIU: /* r0 >= 0 unsigned */
2633 /* Always trap */
2634 generate_exception(ctx, EXCP_TRAP);
2635 break;
2636 case OPC_TLT: /* rs < rs */
2637 case OPC_TLTI: /* r0 < 0 */
2638 case OPC_TLTU: /* rs < rs unsigned */
2639 case OPC_TLTIU: /* r0 < 0 unsigned */
2640 case OPC_TNE: /* rs != rs */
2641 case OPC_TNEI: /* r0 != 0 */
2642 /* Never trap: treat as NOP. */
2643 break;
2644 }
2645 } else {
2646 int l1 = gen_new_label();
2647
2648 switch (opc) {
2649 case OPC_TEQ:
2650 case OPC_TEQI:
2651 tcg_gen_brcond_tl(TCG_COND_NE, t0, t1, l1);
2652 break;
2653 case OPC_TGE:
2654 case OPC_TGEI:
2655 tcg_gen_brcond_tl(TCG_COND_LT, t0, t1, l1);
2656 break;
2657 case OPC_TGEU:
2658 case OPC_TGEIU:
2659 tcg_gen_brcond_tl(TCG_COND_LTU, t0, t1, l1);
2660 break;
2661 case OPC_TLT:
2662 case OPC_TLTI:
2663 tcg_gen_brcond_tl(TCG_COND_GE, t0, t1, l1);
2664 break;
2665 case OPC_TLTU:
2666 case OPC_TLTIU:
2667 tcg_gen_brcond_tl(TCG_COND_GEU, t0, t1, l1);
2668 break;
2669 case OPC_TNE:
2670 case OPC_TNEI:
2671 tcg_gen_brcond_tl(TCG_COND_EQ, t0, t1, l1);
2672 break;
2673 }
2674 generate_exception(ctx, EXCP_TRAP);
2675 gen_set_label(l1);
2676 }
2677 tcg_temp_free(t0);
2678 tcg_temp_free(t1);
2679 }
2680
2681 static inline void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
2682 {
2683 TranslationBlock *tb;
2684 tb = ctx->tb;
2685 if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK) &&
2686 likely(!ctx->singlestep_enabled)) {
2687 tcg_gen_goto_tb(n);
2688 gen_save_pc(dest);
2689 tcg_gen_exit_tb((tcg_target_long)tb + n);
2690 } else {
2691 gen_save_pc(dest);
2692 if (ctx->singlestep_enabled) {
2693 save_cpu_state(ctx, 0);
2694 gen_helper_0i(raise_exception, EXCP_DEBUG);
2695 }
2696 tcg_gen_exit_tb(0);
2697 }
2698 }
2699
2700 /* Branches (before delay slot) */
2701 static void gen_compute_branch (DisasContext *ctx, uint32_t opc,
2702 int insn_bytes,
2703 int rs, int rt, int32_t offset)
2704 {
2705 target_ulong btgt = -1;
2706 int blink = 0;
2707 int bcond_compute = 0;
2708 TCGv t0 = tcg_temp_new();
2709 TCGv t1 = tcg_temp_new();
2710
2711 if (ctx->hflags & MIPS_HFLAG_BMASK) {
2712 #ifdef MIPS_DEBUG_DISAS
2713 LOG_DISAS("Branch in delay slot at PC 0x" TARGET_FMT_lx "\n", ctx->pc);
2714 #endif
2715 generate_exception(ctx, EXCP_RI);
2716 goto out;
2717 }
2718
2719 /* Load needed operands */
2720 switch (opc) {
2721 case OPC_BEQ:
2722 case OPC_BEQL:
2723 case OPC_BNE:
2724 case OPC_BNEL:
2725 /* Compare two registers */
2726 if (rs != rt) {
2727 gen_load_gpr(t0, rs);
2728 gen_load_gpr(t1, rt);
2729 bcond_compute = 1;
2730 }
2731 btgt = ctx->pc + insn_bytes + offset;
2732 break;
2733 case OPC_BGEZ:
2734 case OPC_BGEZAL:
2735 case OPC_BGEZALS:
2736 case OPC_BGEZALL:
2737 case OPC_BGEZL:
2738 case OPC_BGTZ:
2739 case OPC_BGTZL:
2740 case OPC_BLEZ:
2741 case OPC_BLEZL:
2742 case OPC_BLTZ:
2743 case OPC_BLTZAL:
2744 case OPC_BLTZALS:
2745 case OPC_BLTZALL:
2746 case OPC_BLTZL:
2747 /* Compare to zero */
2748 if (rs != 0) {
2749 gen_load_gpr(t0, rs);
2750 bcond_compute = 1;
2751 }
2752 btgt = ctx->pc + insn_bytes + offset;
2753 break;
2754 case OPC_J:
2755 case OPC_JAL:
2756 case OPC_JALX:
2757 case OPC_JALS:
2758 case OPC_JALXS:
2759 /* Jump to immediate */
2760 btgt = ((ctx->pc + insn_bytes) & (int32_t)0xF0000000) | (uint32_t)offset;
2761 break;
2762 case OPC_JR:
2763 case OPC_JALR:
2764 case OPC_JALRC:
2765 case OPC_JALRS:
2766 /* Jump to register */
2767 if (offset != 0 && offset != 16) {
2768 /* Hint = 0 is JR/JALR, hint 16 is JR.HB/JALR.HB, the
2769 others are reserved. */
2770 MIPS_INVAL("jump hint");
2771 generate_exception(ctx, EXCP_RI);
2772 goto out;
2773 }
2774 gen_load_gpr(btarget, rs);
2775 break;
2776 default:
2777 MIPS_INVAL("branch/jump");
2778 generate_exception(ctx, EXCP_RI);
2779 goto out;
2780 }
2781 if (bcond_compute == 0) {
2782 /* No condition to be computed */
2783 switch (opc) {
2784 case OPC_BEQ: /* rx == rx */
2785 case OPC_BEQL: /* rx == rx likely */
2786 case OPC_BGEZ: /* 0 >= 0 */
2787 case OPC_BGEZL: /* 0 >= 0 likely */
2788 case OPC_BLEZ: /* 0 <= 0 */
2789 case OPC_BLEZL: /* 0 <= 0 likely */
2790 /* Always take */
2791 ctx->hflags |= MIPS_HFLAG_B;
2792 MIPS_DEBUG("balways");
2793 break;
2794 case OPC_BGEZALS:
2795 case OPC_BGEZAL: /* 0 >= 0 */
2796 case OPC_BGEZALL: /* 0 >= 0 likely */
2797 ctx->hflags |= (opc == OPC_BGEZALS
2798 ? MIPS_HFLAG_BDS16
2799 : MIPS_HFLAG_BDS32);
2800 /* Always take and link */
2801 blink = 31;
2802 ctx->hflags |= MIPS_HFLAG_B;
2803 MIPS_DEBUG("balways and link");
2804 break;
2805 case OPC_BNE: /* rx != rx */
2806 case OPC_BGTZ: /* 0 > 0 */
2807 case OPC_BLTZ: /* 0 < 0 */
2808 /* Treat as NOP. */
2809 MIPS_DEBUG("bnever (NOP)");
2810 goto out;
2811 case OPC_BLTZALS:
2812 case OPC_BLTZAL: /* 0 < 0 */
2813 ctx->hflags |= (opc == OPC_BLTZALS
2814 ? MIPS_HFLAG_BDS16
2815 : MIPS_HFLAG_BDS32);
2816 /* Handle as an unconditional branch to get correct delay
2817 slot checking. */
2818 blink = 31;
2819 btgt = ctx->pc + (opc == OPC_BLTZALS ? 6 : 8);
2820 ctx->hflags |= MIPS_HFLAG_B;
2821 MIPS_DEBUG("bnever and link");
2822 break;
2823 case OPC_BLTZALL: /* 0 < 0 likely */
2824 tcg_gen_movi_tl(cpu_gpr[31], ctx->pc + 8);
2825 /* Skip the instruction in the delay slot */
2826 MIPS_DEBUG("bnever, link and skip");
2827 ctx->pc += 4;
2828 goto out;
2829 case OPC_BNEL: /* rx != rx likely */
2830 case OPC_BGTZL: /* 0 > 0 likely */
2831 case OPC_BLTZL: /* 0 < 0 likely */
2832 /* Skip the instruction in the delay slot */
2833 MIPS_DEBUG("bnever and skip");
2834 ctx->pc += 4;
2835 goto out;
2836 case OPC_J:
2837 ctx->hflags |= MIPS_HFLAG_B;
2838 MIPS_DEBUG("j " TARGET_FMT_lx, btgt);
2839 break;
2840 case OPC_JALXS:
2841 case OPC_JALX:
2842 ctx->hflags |= MIPS_HFLAG_BX;
2843 /* Fallthrough */
2844 case OPC_JALS:
2845 case OPC_JAL:
2846 blink = 31;
2847 ctx->hflags |= MIPS_HFLAG_B;
2848 ctx->hflags |= ((opc == OPC_JALS || opc == OPC_JALXS)
2849 ? MIPS_HFLAG_BDS16
2850 : MIPS_HFLAG_BDS32);
2851 MIPS_DEBUG("jal " TARGET_FMT_lx, btgt);
2852 break;
2853 case OPC_JR:
2854 ctx->hflags |= MIPS_HFLAG_BR;
2855 if (insn_bytes == 4)
2856 ctx->hflags |= MIPS_HFLAG_BDS32;
2857 MIPS_DEBUG("jr %s", regnames[rs]);
2858 break;
2859 case OPC_JALRS:
2860 case OPC_JALR:
2861 case OPC_JALRC:
2862 blink = rt;
2863 ctx->hflags |= MIPS_HFLAG_BR;
2864 ctx->hflags |= (opc == OPC_JALRS
2865 ? MIPS_HFLAG_BDS16
2866 : MIPS_HFLAG_BDS32);
2867 MIPS_DEBUG("jalr %s, %s", regnames[rt], regnames[rs]);
2868 break;
2869 default:
2870 MIPS_INVAL("branch/jump");
2871 generate_exception(ctx, EXCP_RI);
2872 goto out;
2873 }
2874 } else {
2875 switch (opc) {
2876 case OPC_BEQ:
2877 tcg_gen_setcond_tl(TCG_COND_EQ, bcond, t0, t1);
2878 MIPS_DEBUG("beq %s, %s, " TARGET_FMT_lx,
2879 regnames[rs], regnames[rt], btgt);
2880 goto not_likely;
2881 case OPC_BEQL:
2882 tcg_gen_setcond_tl(TCG_COND_EQ, bcond, t0, t1);
2883 MIPS_DEBUG("beql %s, %s, " TARGET_FMT_lx,
2884 regnames[rs], regnames[rt], btgt);
2885 goto likely;
2886 case OPC_BNE:
2887 tcg_gen_setcond_tl(TCG_COND_NE, bcond, t0, t1);
2888 MIPS_DEBUG("bne %s, %s, " TARGET_FMT_lx,
2889 regnames[rs], regnames[rt], btgt);
2890 goto not_likely;
2891 case OPC_BNEL:
2892 tcg_gen_setcond_tl(TCG_COND_NE, bcond, t0, t1);
2893 MIPS_DEBUG("bnel %s, %s, " TARGET_FMT_lx,
2894 regnames[rs], regnames[rt], btgt);
2895 goto likely;
2896 case OPC_BGEZ:
2897 tcg_gen_setcondi_tl(TCG_COND_GE, bcond, t0, 0);
2898 MIPS_DEBUG("bgez %s, " TARGET_FMT_lx, regnames[rs], btgt);
2899 goto not_likely;
2900 case OPC_BGEZL:
2901 tcg_gen_setcondi_tl(TCG_COND_GE, bcond, t0, 0);
2902 MIPS_DEBUG("bgezl %s, " TARGET_FMT_lx, regnames[rs], btgt);
2903 goto likely;
2904 case OPC_BGEZALS:
2905 case OPC_BGEZAL:
2906 ctx->hflags |= (opc == OPC_BGEZALS
2907 ? MIPS_HFLAG_BDS16
2908 : MIPS_HFLAG_BDS32);
2909 tcg_gen_setcondi_tl(TCG_COND_GE, bcond, t0, 0);
2910 MIPS_DEBUG("bgezal %s, " TARGET_FMT_lx, regnames[rs], btgt);
2911 blink = 31;
2912 goto not_likely;
2913 case OPC_BGEZALL:
2914 tcg_gen_setcondi_tl(TCG_COND_GE, bcond, t0, 0);
2915 blink = 31;
2916 MIPS_DEBUG("bgezall %s, " TARGET_FMT_lx, regnames[rs], btgt);
2917 goto likely;
2918 case OPC_BGTZ:
2919 tcg_gen_setcondi_tl(TCG_COND_GT, bcond, t0, 0);
2920 MIPS_DEBUG("bgtz %s, " TARGET_FMT_lx, regnames[rs], btgt);
2921 goto not_likely;
2922 case OPC_BGTZL:
2923 tcg_gen_setcondi_tl(TCG_COND_GT, bcond, t0, 0);
2924 MIPS_DEBUG("bgtzl %s, " TARGET_FMT_lx, regnames[rs], btgt);
2925 goto likely;
2926 case OPC_BLEZ:
2927 tcg_gen_setcondi_tl(TCG_COND_LE, bcond, t0, 0);
2928 MIPS_DEBUG("blez %s, " TARGET_FMT_lx, regnames[rs], btgt);
2929 goto not_likely;
2930 case OPC_BLEZL:
2931 tcg_gen_setcondi_tl(TCG_COND_LE, bcond, t0, 0);
2932 MIPS_DEBUG("blezl %s, " TARGET_FMT_lx, regnames[rs], btgt);
2933 goto likely;
2934 case OPC_BLTZ:
2935 tcg_gen_setcondi_tl(TCG_COND_LT, bcond, t0, 0);
2936 MIPS_DEBUG("bltz %s, " TARGET_FMT_lx, regnames[rs], btgt);
2937 goto not_likely;
2938 case OPC_BLTZL:
2939 tcg_gen_setcondi_tl(TCG_COND_LT, bcond, t0, 0);
2940 MIPS_DEBUG("bltzl %s, " TARGET_FMT_lx, regnames[rs], btgt);
2941 goto likely;
2942 case OPC_BLTZALS:
2943 case OPC_BLTZAL:
2944 ctx->hflags |= (opc == OPC_BLTZALS
2945 ? MIPS_HFLAG_BDS16
2946 : MIPS_HFLAG_BDS32);
2947 tcg_gen_setcondi_tl(TCG_COND_LT, bcond, t0, 0);
2948 blink = 31;
2949 MIPS_DEBUG("bltzal %s, " TARGET_FMT_lx, regnames[rs], btgt);
2950 not_likely:
2951 ctx->hflags |= MIPS_HFLAG_BC;
2952 break;
2953 case OPC_BLTZALL:
2954 tcg_gen_setcondi_tl(TCG_COND_LT, bcond, t0, 0);
2955 blink = 31;
2956 MIPS_DEBUG("bltzall %s, " TARGET_FMT_lx, regnames[rs], btgt);
2957 likely:
2958 ctx->hflags |= MIPS_HFLAG_BL;
2959 break;
2960 default:
2961 MIPS_INVAL("conditional branch/jump");
2962 generate_exception(ctx, EXCP_RI);
2963 goto out;
2964 }
2965 }
2966 MIPS_DEBUG("enter ds: link %d cond %02x target " TARGET_FMT_lx,
2967 blink, ctx->hflags, btgt);
2968
2969 ctx->btarget = btgt;
2970 if (blink > 0) {
2971 int post_delay = insn_bytes;
2972 int lowbit = !!(ctx->hflags & MIPS_HFLAG_M16);
2973
2974 if (opc != OPC_JALRC)
2975 post_delay += ((ctx->hflags & MIPS_HFLAG_BDS16) ? 2 : 4);
2976
2977 tcg_gen_movi_tl(cpu_gpr[blink], ctx->pc + post_delay + lowbit);
2978 }
2979
2980 out:
2981 if (insn_bytes == 2)
2982 ctx->hflags |= MIPS_HFLAG_B16;
2983 tcg_temp_free(t0);
2984 tcg_temp_free(t1);
2985 }
2986
2987 /* special3 bitfield operations */
2988 static void gen_bitops (DisasContext *ctx, uint32_t opc, int rt,
2989 int rs, int lsb, int msb)
2990 {
2991 TCGv t0 = tcg_temp_new();
2992 TCGv t1 = tcg_temp_new();
2993 target_ulong mask;
2994
2995 gen_load_gpr(t1, rs);
2996 switch (opc) {
2997 case OPC_EXT:
2998 if (lsb + msb > 31)
2999 goto fail;
3000 tcg_gen_shri_tl(t0, t1, lsb);
3001 if (msb != 31) {
3002 tcg_gen_andi_tl(t0, t0, (1 << (msb + 1)) - 1);
3003 } else {
3004 tcg_gen_ext32s_tl(t0, t0);
3005 }
3006 break;
3007 #if defined(TARGET_MIPS64)
3008 case OPC_DEXTM:
3009 tcg_gen_shri_tl(t0, t1, lsb);
3010 if (msb != 31) {
3011 tcg_gen_andi_tl(t0, t0, (1ULL << (msb + 1 + 32)) - 1);
3012 }
3013 break;
3014 case OPC_DEXTU:
3015 tcg_gen_shri_tl(t0, t1, lsb + 32);
3016 tcg_gen_andi_tl(t0, t0, (1ULL << (msb + 1)) - 1);
3017 break;
3018 case OPC_DEXT:
3019 tcg_gen_shri_tl(t0, t1, lsb);
3020 tcg_gen_andi_tl(t0, t0, (1ULL << (msb + 1)) - 1);
3021 break;
3022 #endif
3023 case OPC_INS:
3024 if (lsb > msb)
3025 goto fail;
3026 mask = ((msb - lsb + 1 < 32) ? ((1 << (msb - lsb + 1)) - 1) : ~0) << lsb;
3027 gen_load_gpr(t0, rt);
3028 tcg_gen_andi_tl(t0, t0, ~mask);
3029 tcg_gen_shli_tl(t1, t1, lsb);
3030 tcg_gen_andi_tl(t1, t1, mask);
3031 tcg_gen_or_tl(t0, t0, t1);
3032 tcg_gen_ext32s_tl(t0, t0);
3033 break;
3034 #if defined(TARGET_MIPS64)
3035 case OPC_DINSM:
3036 if (lsb > msb)
3037 goto fail;
3038 mask = ((msb - lsb + 1 + 32 < 64) ? ((1ULL << (msb - lsb + 1 + 32)) - 1) : ~0ULL) << lsb;
3039 gen_load_gpr(t0, rt);
3040 tcg_gen_andi_tl(t0, t0, ~mask);
3041 tcg_gen_shli_tl(t1, t1, lsb);
3042 tcg_gen_andi_tl(t1, t1, mask);
3043 tcg_gen_or_tl(t0, t0, t1);
3044 break;
3045 case OPC_DINSU:
3046 if (lsb > msb)
3047 goto fail;
3048 mask = ((1ULL << (msb - lsb + 1)) - 1) << (lsb + 32);
3049 gen_load_gpr(t0, rt);
3050 tcg_gen_andi_tl(t0, t0, ~mask);
3051 tcg_gen_shli_tl(t1, t1, lsb + 32);
3052 tcg_gen_andi_tl(t1, t1, mask);
3053 tcg_gen_or_tl(t0, t0, t1);
3054 break;
3055 case OPC_DINS:
3056 if (lsb > msb)
3057 goto fail;
3058 gen_load_gpr(t0, rt);
3059 mask = ((1ULL << (msb - lsb + 1)) - 1) << lsb;
3060 gen_load_gpr(t0, rt);
3061 tcg_gen_andi_tl(t0, t0, ~mask);
3062 tcg_gen_shli_tl(t1, t1, lsb);
3063 tcg_gen_andi_tl(t1, t1, mask);
3064 tcg_gen_or_tl(t0, t0, t1);
3065 break;
3066 #endif
3067 default:
3068 fail:
3069 MIPS_INVAL("bitops");
3070 generate_exception(ctx, EXCP_RI);
3071 tcg_temp_free(t0);
3072 tcg_temp_free(t1);
3073 return;
3074 }
3075 gen_store_gpr(t0, rt);
3076 tcg_temp_free(t0);
3077 tcg_temp_free(t1);
3078 }
3079
3080 static void gen_bshfl (DisasContext *ctx, uint32_t op2, int rt, int rd)
3081 {
3082 TCGv t0;
3083
3084 if (rd == 0) {
3085 /* If no destination, treat it as a NOP. */
3086 MIPS_DEBUG("NOP");
3087 return;
3088 }
3089
3090 t0 = tcg_temp_new();
3091 gen_load_gpr(t0, rt);
3092 switch (op2) {
3093 case OPC_WSBH:
3094 {
3095 TCGv t1 = tcg_temp_new();
3096
3097 tcg_gen_shri_tl(t1, t0, 8);
3098 tcg_gen_andi_tl(t1, t1, 0x00FF00FF);
3099 tcg_gen_shli_tl(t0, t0, 8);
3100 tcg_gen_andi_tl(t0, t0, ~0x00FF00FF);
3101 tcg_gen_or_tl(t0, t0, t1);
3102 tcg_temp_free(t1);
3103 tcg_gen_ext32s_tl(cpu_gpr[rd], t0);
3104 }
3105 break;
3106 case OPC_SEB:
3107 tcg_gen_ext8s_tl(cpu_gpr[rd], t0);
3108 break;
3109 case OPC_SEH:
3110 tcg_gen_ext16s_tl(cpu_gpr[rd], t0);
3111 break;
3112 #if defined(TARGET_MIPS64)
3113 case OPC_DSBH:
3114 {
3115 TCGv t1 = tcg_temp_new();
3116
3117 tcg_gen_shri_tl(t1, t0, 8);
3118 tcg_gen_andi_tl(t1, t1, 0x00FF00FF00FF00FFULL);
3119 tcg_gen_shli_tl(t0, t0, 8);
3120 tcg_gen_andi_tl(t0, t0, ~0x00FF00FF00FF00FFULL);
3121 tcg_gen_or_tl(cpu_gpr[rd], t0, t1);
3122 tcg_temp_free(t1);
3123 }
3124 break;
3125 case OPC_DSHD:
3126 {
3127 TCGv t1 = tcg_temp_new();
3128
3129 tcg_gen_shri_tl(t1, t0, 16);
3130 tcg_gen_andi_tl(t1, t1, 0x0000FFFF0000FFFFULL);
3131 tcg_gen_shli_tl(t0, t0, 16);
3132 tcg_gen_andi_tl(t0, t0, ~0x0000FFFF0000FFFFULL);
3133 tcg_gen_or_tl(t0, t0, t1);
3134 tcg_gen_shri_tl(t1, t0, 32);
3135 tcg_gen_shli_tl(t0, t0, 32);
3136 tcg_gen_or_tl(cpu_gpr[rd], t0, t1);
3137 tcg_temp_free(t1);
3138 }
3139 break;
3140 #endif
3141 default:
3142 MIPS_INVAL("bsfhl");
3143 generate_exception(ctx, EXCP_RI);
3144 tcg_temp_free(t0);
3145 return;
3146 }
3147 tcg_temp_free(t0);
3148 }
3149
3150 #ifndef CONFIG_USER_ONLY
3151 /* CP0 (MMU and control) */
3152 static inline void gen_mfc0_load32 (TCGv arg, target_ulong off)
3153 {
3154 TCGv_i32 t0 = tcg_temp_new_i32();
3155
3156 tcg_gen_ld_i32(t0, cpu_env, off);
3157 tcg_gen_ext_i32_tl(arg, t0);
3158 tcg_temp_free_i32(t0);
3159 }
3160
3161 static inline void gen_mfc0_load64 (TCGv arg, target_ulong off)
3162 {
3163 tcg_gen_ld_tl(arg, cpu_env, off);
3164 tcg_gen_ext32s_tl(arg, arg);
3165 }
3166
3167 static inline void gen_mtc0_store32 (TCGv arg, target_ulong off)
3168 {
3169 TCGv_i32 t0 = tcg_temp_new_i32();
3170
3171 tcg_gen_trunc_tl_i32(t0, arg);
3172 tcg_gen_st_i32(t0, cpu_env, off);
3173 tcg_temp_free_i32(t0);
3174 }
3175
3176 static inline void gen_mtc0_store64 (TCGv arg, target_ulong off)
3177 {
3178 tcg_gen_ext32s_tl(arg, arg);
3179 tcg_gen_st_tl(arg, cpu_env, off);
3180 }
3181
3182 static void gen_mfc0 (CPUState *env, DisasContext *ctx, TCGv arg, int reg, int sel)
3183 {
3184 const char *rn = "invalid";
3185
3186 if (sel != 0)
3187 check_insn(env, ctx, ISA_MIPS32);
3188
3189 switch (reg) {
3190 case 0:
3191 switch (sel) {
3192 case 0:
3193 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Index));
3194 rn = "Index";
3195 break;
3196 case 1:
3197 check_insn(env, ctx, ASE_MT);
3198 gen_helper_mfc0_mvpcontrol(arg);
3199 rn = "MVPControl";
3200 break;
3201 case 2:
3202 check_insn(env, ctx, ASE_MT);
3203 gen_helper_mfc0_mvpconf0(arg);
3204 rn = "MVPConf0";
3205 break;
3206 case 3:
3207 check_insn(env, ctx, ASE_MT);
3208 gen_helper_mfc0_mvpconf1(arg);
3209 rn = "MVPConf1";
3210 break;
3211 default:
3212 goto die;
3213 }
3214 break;
3215 case 1:
3216 switch (sel) {
3217 case 0:
3218 gen_helper_mfc0_random(arg);
3219 rn = "Random";
3220 break;
3221 case 1:
3222 check_insn(env, ctx, ASE_MT);
3223 gen_mfc0_load32(arg, offsetof(CPUState, CP0_VPEControl));
3224 rn = "VPEControl";
3225 break;
3226 case 2:
3227 check_insn(env, ctx, ASE_MT);
3228 gen_mfc0_load32(arg, offsetof(CPUState, CP0_VPEConf0));
3229 rn = "VPEConf0";
3230 break;
3231 case 3:
3232 check_insn(env, ctx, ASE_MT);
3233 gen_mfc0_load32(arg, offsetof(CPUState, CP0_VPEConf1));
3234 rn = "VPEConf1";
3235 break;
3236 case 4:
3237 check_insn(env, ctx, ASE_MT);
3238 gen_mfc0_load64(arg, offsetof(CPUState, CP0_YQMask));
3239 rn = "YQMask";
3240 break;
3241 case 5:
3242 check_insn(env, ctx, ASE_MT);
3243 gen_mfc0_load64(arg, offsetof(CPUState, CP0_VPESchedule));
3244 rn = "VPESchedule";
3245 break;
3246 case 6:
3247 check_insn(env, ctx, ASE_MT);
3248 gen_mfc0_load64(arg, offsetof(CPUState, CP0_VPEScheFBack));
3249 rn = "VPEScheFBack";
3250 break;
3251 case 7:
3252 check_insn(env, ctx, ASE_MT);
3253 gen_mfc0_load32(arg, offsetof(CPUState, CP0_VPEOpt));
3254 rn = "VPEOpt";
3255 break;
3256 default:
3257 goto die;
3258 }
3259 break;
3260 case 2:
3261 switch (sel) {
3262 case 0:
3263 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_EntryLo0));
3264 tcg_gen_ext32s_tl(arg, arg);
3265 rn = "EntryLo0";
3266 break;
3267 case 1:
3268 check_insn(env, ctx, ASE_MT);
3269 gen_helper_mfc0_tcstatus(arg);
3270 rn = "TCStatus";
3271 break;
3272 case 2:
3273 check_insn(env, ctx, ASE_MT);
3274 gen_helper_mfc0_tcbind(arg);
3275 rn = "TCBind";
3276 break;
3277 case 3:
3278 check_insn(env, ctx, ASE_MT);
3279 gen_helper_mfc0_tcrestart(arg);
3280 rn = "TCRestart";
3281 break;
3282 case 4:
3283 check_insn(env, ctx, ASE_MT);
3284 gen_helper_mfc0_tchalt(arg);
3285 rn = "TCHalt";
3286 break;
3287 case 5:
3288 check_insn(env, ctx, ASE_MT);
3289 gen_helper_mfc0_tccontext(arg);
3290 rn = "TCContext";
3291 break;
3292 case 6:
3293 check_insn(env, ctx, ASE_MT);
3294 gen_helper_mfc0_tcschedule(arg);
3295 rn = "TCSchedule";
3296 break;
3297 case 7:
3298 check_insn(env, ctx, ASE_MT);
3299 gen_helper_mfc0_tcschefback(arg);
3300 rn = "TCScheFBack";
3301 break;
3302 default:
3303 goto die;
3304 }
3305 break;
3306 case 3:
3307 switch (sel) {
3308 case 0:
3309 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_EntryLo1));
3310 tcg_gen_ext32s_tl(arg, arg);
3311 rn = "EntryLo1";
3312 break;
3313 default:
3314 goto die;
3315 }
3316 break;
3317 case 4:
3318 switch (sel) {
3319 case 0:
3320 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_Context));
3321 tcg_gen_ext32s_tl(arg, arg);
3322 rn = "Context";
3323 break;
3324 case 1:
3325 // gen_helper_mfc0_contextconfig(arg); /* SmartMIPS ASE */
3326 rn = "ContextConfig";
3327 // break;
3328 default:
3329 goto die;
3330 }
3331 break;
3332 case 5:
3333 switch (sel) {
3334 case 0:
3335 gen_mfc0_load32(arg, offsetof(CPUState, CP0_PageMask));
3336 rn = "PageMask";
3337 break;
3338 case 1:
3339 check_insn(env, ctx, ISA_MIPS32R2);
3340 gen_mfc0_load32(arg, offsetof(CPUState, CP0_PageGrain));
3341 rn = "PageGrain";
3342 break;
3343 default:
3344 goto die;
3345 }
3346 break;
3347 case 6:
3348 switch (sel) {
3349 case 0:
3350 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Wired));
3351 rn = "Wired";
3352 break;
3353 case 1:
3354 check_insn(env, ctx, ISA_MIPS32R2);
3355 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSConf0));
3356 rn = "SRSConf0";
3357 break;
3358 case 2:
3359 check_insn(env, ctx, ISA_MIPS32R2);
3360 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSConf1));
3361 rn = "SRSConf1";
3362 break;
3363 case 3:
3364 check_insn(env, ctx, ISA_MIPS32R2);
3365 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSConf2));
3366 rn = "SRSConf2";
3367 break;
3368 case 4:
3369 check_insn(env, ctx, ISA_MIPS32R2);
3370 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSConf3));
3371 rn = "SRSConf3";
3372 break;
3373 case 5:
3374 check_insn(env, ctx, ISA_MIPS32R2);
3375 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSConf4));
3376 rn = "SRSConf4";
3377 break;
3378 default:
3379 goto die;
3380 }
3381 break;
3382 case 7:
3383 switch (sel) {
3384 case 0:
3385 check_insn(env, ctx, ISA_MIPS32R2);
3386 gen_mfc0_load32(arg, offsetof(CPUState, CP0_HWREna));
3387 rn = "HWREna";
3388 break;
3389 default:
3390 goto die;
3391 }
3392 break;
3393 case 8:
3394 switch (sel) {
3395 case 0:
3396 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_BadVAddr));
3397 tcg_gen_ext32s_tl(arg, arg);
3398 rn = "BadVAddr";
3399 break;
3400 default:
3401 goto die;
3402 }
3403 break;
3404 case 9:
3405 switch (sel) {
3406 case 0:
3407 /* Mark as an IO operation because we read the time. */
3408 if (use_icount)
3409 gen_io_start();
3410 gen_helper_mfc0_count(arg);
3411 if (use_icount) {
3412 gen_io_end();
3413 }
3414 /* Break the TB to be able to take timer interrupts immediately
3415 after reading count. */
3416 ctx->bstate = BS_STOP;
3417 rn = "Count";
3418 break;
3419 /* 6,7 are implementation dependent */
3420 default:
3421 goto die;
3422 }
3423 break;
3424 case 10:
3425 switch (sel) {
3426 case 0:
3427 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_EntryHi));
3428 tcg_gen_ext32s_tl(arg, arg);
3429 rn = "EntryHi";
3430 break;
3431 default:
3432 goto die;
3433 }
3434 break;
3435 case 11:
3436 switch (sel) {
3437 case 0:
3438 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Compare));
3439 rn = "Compare";
3440 break;
3441 /* 6,7 are implementation dependent */
3442 default:
3443 goto die;
3444 }
3445 break;
3446 case 12:
3447 switch (sel) {
3448 case 0:
3449 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Status));
3450 rn = "Status";
3451 break;
3452 case 1:
3453 check_insn(env, ctx, ISA_MIPS32R2);
3454 gen_mfc0_load32(arg, offsetof(CPUState, CP0_IntCtl));
3455 rn = "IntCtl";
3456 break;
3457 case 2:
3458 check_insn(env, ctx, ISA_MIPS32R2);
3459 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSCtl));
3460 rn = "SRSCtl";
3461 break;
3462 case 3:
3463 check_insn(env, ctx, ISA_MIPS32R2);
3464 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSMap));
3465 rn = "SRSMap";
3466 break;
3467 default:
3468 goto die;
3469 }
3470 break;
3471 case 13:
3472 switch (sel) {
3473 case 0:
3474 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Cause));
3475 rn = "Cause";
3476 break;
3477 default:
3478 goto die;
3479 }
3480 break;
3481 case 14:
3482 switch (sel) {
3483 case 0:
3484 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_EPC));
3485 tcg_gen_ext32s_tl(arg, arg);
3486 rn = "EPC";
3487 break;
3488 default:
3489 goto die;
3490 }
3491 break;
3492 case 15:
3493 switch (sel) {
3494 case 0:
3495 gen_mfc0_load32(arg, offsetof(CPUState, CP0_PRid));
3496 rn = "PRid";
3497 break;
3498 case 1:
3499 check_insn(env, ctx, ISA_MIPS32R2);
3500 gen_mfc0_load32(arg, offsetof(CPUState, CP0_EBase));
3501 rn = "EBase";
3502 break;
3503 default:
3504 goto die;
3505 }
3506 break;
3507 case 16:
3508 switch (sel) {
3509 case 0:
3510 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config0));
3511 rn = "Config";
3512 break;
3513 case 1:
3514 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config1));
3515 rn = "Config1";
3516 break;
3517 case 2:
3518 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config2));
3519 rn = "Config2";
3520 break;
3521 case 3:
3522 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config3));
3523 rn = "Config3";
3524 break;
3525 /* 4,5 are reserved */
3526 /* 6,7 are implementation dependent */
3527 case 6:
3528 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config6));
3529 rn = "Config6";
3530 break;
3531 case 7:
3532 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config7));
3533 rn = "Config7";
3534 break;
3535 default:
3536 goto die;
3537 }
3538 break;
3539 case 17:
3540 switch (sel) {
3541 case 0:
3542 gen_helper_mfc0_lladdr(arg);
3543 rn = "LLAddr";
3544 break;
3545 default:
3546 goto die;
3547 }
3548 break;
3549 case 18:
3550 switch (sel) {
3551 case 0 ... 7:
3552 gen_helper_1i(mfc0_watchlo, arg, sel);
3553 rn = "WatchLo";
3554 break;
3555 default:
3556 goto die;
3557 }
3558 break;
3559 case 19:
3560 switch (sel) {
3561 case 0 ...7:
3562 gen_helper_1i(mfc0_watchhi, arg, sel);
3563 rn = "WatchHi";
3564 break;
3565 default:
3566 goto die;
3567 }
3568 break;
3569 case 20:
3570 switch (sel) {
3571 case 0:
3572 #if defined(TARGET_MIPS64)
3573 check_insn(env, ctx, ISA_MIPS3);
3574 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_XContext));
3575 tcg_gen_ext32s_tl(arg, arg);
3576 rn = "XContext";
3577 break;
3578 #endif
3579 default:
3580 goto die;
3581 }
3582 break;
3583 case 21:
3584 /* Officially reserved, but sel 0 is used for R1x000 framemask */
3585 switch (sel) {
3586 case 0:
3587 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Framemask));
3588 rn = "Framemask";
3589 break;
3590 default:
3591 goto die;
3592 }
3593 break;
3594 case 22:
3595 tcg_gen_movi_tl(arg, 0); /* unimplemented */
3596 rn = "'Diagnostic"; /* implementation dependent */
3597 break;
3598 case 23:
3599 switch (sel) {
3600 case 0:
3601 gen_helper_mfc0_debug(arg); /* EJTAG support */
3602 rn = "Debug";
3603 break;
3604 case 1:
3605 // gen_helper_mfc0_tracecontrol(arg); /* PDtrace support */
3606 rn = "TraceControl";
3607 // break;
3608 case 2:
3609 // gen_helper_mfc0_tracecontrol2(arg); /* PDtrace support */
3610 rn = "TraceControl2";
3611 // break;
3612 case 3:
3613 // gen_helper_mfc0_usertracedata(arg); /* PDtrace support */
3614 rn = "UserTraceData";
3615 // break;
3616 case 4:
3617 // gen_helper_mfc0_tracebpc(arg); /* PDtrace support */
3618 rn = "TraceBPC";
3619 // break;
3620 default:
3621 goto die;
3622 }
3623 break;
3624 case 24:
3625 switch (sel) {
3626 case 0:
3627 /* EJTAG support */
3628 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_DEPC));
3629 tcg_gen_ext32s_tl(arg, arg);
3630 rn = "DEPC";
3631 break;
3632 default:
3633 goto die;
3634 }
3635 break;
3636 case 25:
3637 switch (sel) {
3638 case 0:
3639 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Performance0));
3640 rn = "Performance0";
3641 break;
3642 case 1:
3643 // gen_helper_mfc0_performance1(arg);
3644 rn = "Performance1";
3645 // break;
3646 case 2:
3647 // gen_helper_mfc0_performance2(arg);
3648 rn = "Performance2";
3649 // break;
3650 case 3:
3651 // gen_helper_mfc0_performance3(arg);
3652 rn = "Performance3";
3653 // break;
3654 case 4:
3655 // gen_helper_mfc0_performance4(arg);
3656 rn = "Performance4";
3657 // break;
3658 case 5:
3659 // gen_helper_mfc0_performance5(arg);
3660 rn = "Performance5";
3661 // break;
3662 case 6:
3663 // gen_helper_mfc0_performance6(arg);
3664 rn = "Performance6";
3665 // break;
3666 case 7:
3667 // gen_helper_mfc0_performance7(arg);
3668 rn = "Performance7";
3669 // break;
3670 default:
3671 goto die;
3672 }
3673 break;
3674 case 26:
3675 tcg_gen_movi_tl(arg, 0); /* unimplemented */
3676 rn = "ECC";
3677 break;
3678 case 27:
3679 switch (sel) {
3680 case 0 ... 3:
3681 tcg_gen_movi_tl(arg, 0); /* unimplemented */
3682 rn = "CacheErr";
3683 break;
3684 default:
3685 goto die;
3686 }
3687 break;
3688 case 28:
3689 switch (sel) {
3690 case 0:
3691 case 2:
3692 case 4:
3693 case 6:
3694 gen_mfc0_load32(arg, offsetof(CPUState, CP0_TagLo));
3695 rn = "TagLo";
3696 break;
3697 case 1:
3698 case 3:
3699 case 5:
3700 case 7:
3701 gen_mfc0_load32(arg, offsetof(CPUState, CP0_DataLo));
3702 rn = "DataLo";
3703 break;
3704 default:
3705 goto die;
3706 }
3707 break;
3708 case 29:
3709 switch (sel) {
3710 case 0:
3711 case 2:
3712 case 4:
3713 case 6:
3714 gen_mfc0_load32(arg, offsetof(CPUState, CP0_TagHi));
3715 rn = "TagHi";
3716 break;
3717 case 1:
3718 case 3:
3719 case 5:
3720 case 7:
3721 gen_mfc0_load32(arg, offsetof(CPUState, CP0_DataHi));
3722 rn = "DataHi";
3723 break;
3724 default:
3725 goto die;
3726 }
3727 break;
3728 case 30:
3729 switch (sel) {
3730 case 0:
3731 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_ErrorEPC));
3732 tcg_gen_ext32s_tl(arg, arg);
3733 rn = "ErrorEPC";
3734 break;
3735 default:
3736 goto die;
3737 }
3738 break;
3739 case 31:
3740 switch (sel) {
3741 case 0:
3742 /* EJTAG support */
3743 gen_mfc0_load32(arg, offsetof(CPUState, CP0_DESAVE));
3744 rn = "DESAVE";
3745 break;
3746 default:
3747 goto die;
3748 }
3749 break;
3750 default:
3751 goto die;
3752 }
3753 (void)rn; /* avoid a compiler warning */
3754 LOG_DISAS("mfc0 %s (reg %d sel %d)\n", rn, reg, sel);
3755 return;
3756
3757 die:
3758 LOG_DISAS("mfc0 %s (reg %d sel %d)\n", rn, reg, sel);
3759 generate_exception(ctx, EXCP_RI);
3760 }
3761
3762 static void gen_mtc0 (CPUState *env, DisasContext *ctx, TCGv arg, int reg, int sel)
3763 {
3764 const char *rn = "invalid";
3765
3766 if (sel != 0)
3767 check_insn(env, ctx, ISA_MIPS32);
3768
3769 if (use_icount)
3770 gen_io_start();
3771
3772 switch (reg) {
3773 case 0:
3774 switch (sel) {
3775 case 0:
3776 gen_helper_mtc0_index(arg);
3777 rn = "Index";
3778 break;
3779 case 1:
3780 check_insn(env, ctx, ASE_MT);
3781 gen_helper_mtc0_mvpcontrol(arg);
3782 rn = "MVPControl";
3783 break;
3784 case 2:
3785 check_insn(env, ctx, ASE_MT);
3786 /* ignored */
3787 rn = "MVPConf0";
3788 break;
3789 case 3:
3790 check_insn(env, ctx, ASE_MT);
3791 /* ignored */
3792 rn = "MVPConf1";
3793 break;
3794 default:
3795 goto die;
3796 }
3797 break;
3798 case 1:
3799 switch (sel) {
3800 case 0:
3801 /* ignored */
3802 rn = "Random";
3803 break;
3804 case 1:
3805 check_insn(env, ctx, ASE_MT);
3806 gen_helper_mtc0_vpecontrol(arg);
3807 rn = "VPEControl";
3808 break;
3809 case 2:
3810 check_insn(env, ctx, ASE_MT);
3811 gen_helper_mtc0_vpeconf0(arg);
3812 rn = "VPEConf0";
3813 break;
3814 case 3:
3815 check_insn(env, ctx, ASE_MT);
3816 gen_helper_mtc0_vpeconf1(arg);
3817 rn = "VPEConf1";
3818 break;
3819 case 4:
3820 check_insn(env, ctx, ASE_MT);
3821 gen_helper_mtc0_yqmask(arg);
3822 rn = "YQMask";
3823 break;
3824 case 5:
3825 check_insn(env, ctx, ASE_MT);
3826 gen_mtc0_store64(arg, offsetof(CPUState, CP0_VPESchedule));
3827 rn = "VPESchedule";
3828 break;
3829 case 6:
3830 check_insn(env, ctx, ASE_MT);
3831 gen_mtc0_store64(arg, offsetof(CPUState, CP0_VPEScheFBack));
3832 rn = "VPEScheFBack";
3833 break;
3834 case 7:
3835 check_insn(env, ctx, ASE_MT);
3836 gen_helper_mtc0_vpeopt(arg);
3837 rn = "VPEOpt";
3838 break;
3839 default:
3840 goto die;
3841 }
3842 break;
3843 case 2:
3844 switch (sel) {
3845 case 0:
3846 gen_helper_mtc0_entrylo0(arg);
3847 rn = "EntryLo0";
3848 break;
3849 case 1:
3850 check_insn(env, ctx, ASE_MT);
3851 gen_helper_mtc0_tcstatus(arg);
3852 rn = "TCStatus";
3853 break;
3854 case 2:
3855 check_insn(env, ctx, ASE_MT);
3856 gen_helper_mtc0_tcbind(arg);
3857 rn = "TCBind";
3858 break;
3859 case 3:
3860 check_insn(env, ctx, ASE_MT);
3861 gen_helper_mtc0_tcrestart(arg);
3862 rn = "TCRestart";
3863 break;
3864 case 4:
3865 check_insn(env, ctx, ASE_MT);
3866 gen_helper_mtc0_tchalt(arg);
3867 rn = "TCHalt";
3868 break;
3869 case 5:
3870 check_insn(env, ctx, ASE_MT);
3871 gen_helper_mtc0_tccontext(arg);
3872 rn = "TCContext";
3873 break;
3874 case 6:
3875 check_insn(env, ctx, ASE_MT);
3876 gen_helper_mtc0_tcschedule(arg);
3877 rn = "TCSchedule";
3878 break;
3879 case 7:
3880 check_insn(env, ctx, ASE_MT);
3881 gen_helper_mtc0_tcschefback(arg);
3882 rn = "TCScheFBack";
3883 break;
3884 default:
3885 goto die;
3886 }
3887 break;
3888 case 3:
3889 switch (sel) {
3890 case 0:
3891 gen_helper_mtc0_entrylo1(arg);
3892 rn = "EntryLo1";
3893 break;
3894 default:
3895 goto die;
3896 }
3897 break;
3898 case 4:
3899 switch (sel) {
3900 case 0:
3901 gen_helper_mtc0_context(arg);
3902 rn = "Context";
3903 break;
3904 case 1:
3905 // gen_helper_mtc0_contextconfig(arg); /* SmartMIPS ASE */
3906 rn = "ContextConfig";
3907 // break;
3908 default:
3909 goto die;
3910 }
3911 break;
3912 case 5:
3913 switch (sel) {
3914 case 0:
3915 gen_helper_mtc0_pagemask(arg);
3916 rn = "PageMask";
3917 break;
3918 case 1:
3919 check_insn(env, ctx, ISA_MIPS32R2);
3920 gen_helper_mtc0_pagegrain(arg);
3921 rn = "PageGrain";
3922 break;
3923 default:
3924 goto die;
3925 }
3926 break;
3927 case 6:
3928 switch (sel) {
3929 case 0:
3930 gen_helper_mtc0_wired(arg);
3931 rn = "Wired";
3932 break;
3933 case 1:
3934 check_insn(env, ctx, ISA_MIPS32R2);
3935 gen_helper_mtc0_srsconf0(arg);
3936 rn = "SRSConf0";
3937 break;
3938 case 2:
3939 check_insn(env, ctx, ISA_MIPS32R2);
3940 gen_helper_mtc0_srsconf1(arg);
3941 rn = "SRSConf1";
3942 break;
3943 case 3:
3944 check_insn(env, ctx, ISA_MIPS32R2);
3945 gen_helper_mtc0_srsconf2(arg);
3946 rn = "SRSConf2";
3947 break;
3948 case 4:
3949 check_insn(env, ctx, ISA_MIPS32R2);
3950 gen_helper_mtc0_srsconf3(arg);
3951 rn = "SRSConf3";
3952 break;
3953 case 5:
3954 check_insn(env, ctx, ISA_MIPS32R2);
3955 gen_helper_mtc0_srsconf4(arg);
3956 rn = "SRSConf4";
3957 break;
3958 default:
3959 goto die;
3960 }
3961 break;
3962 case 7:
3963 switch (sel) {
3964 case 0:
3965 check_insn(env, ctx, ISA_MIPS32R2);
3966 gen_helper_mtc0_hwrena(arg);
3967 rn = "HWREna";
3968 break;
3969 default:
3970 goto die;
3971 }
3972 break;
3973 case 8:
3974 /* ignored */
3975 rn = "BadVAddr";
3976 break;
3977 case 9:
3978 switch (sel) {
3979 case 0:
3980 gen_helper_mtc0_count(arg);
3981 rn = "Count";
3982 break;
3983 /* 6,7 are implementation dependent */
3984 default:
3985 goto die;
3986 }
3987 break;
3988 case 10:
3989 switch (sel) {
3990 case 0:
3991 gen_helper_mtc0_entryhi(arg);
3992 rn = "EntryHi";
3993 break;
3994 default:
3995 goto die;
3996 }
3997 break;
3998 case 11:
3999 switch (sel) {
4000 case 0:
4001 gen_helper_mtc0_compare(arg);
4002 rn = "Compare";
4003 break;
4004 /* 6,7 are implementation dependent */
4005 default:
4006 goto die;
4007 }
4008 break;
4009 case 12:
4010 switch (sel) {
4011 case 0:
4012 save_cpu_state(ctx, 1);
4013 gen_helper_mtc0_status(arg);
4014 /* BS_STOP isn't good enough here, hflags may have changed. */
4015 gen_save_pc(ctx->pc + 4);
4016 ctx->bstate = BS_EXCP;
4017 rn = "Status";
4018 break;
4019 case 1:
4020 check_insn(env, ctx, ISA_MIPS32R2);
4021 gen_helper_mtc0_intctl(arg);
4022 /* Stop translation as we may have switched the execution mode */
4023 ctx->bstate = BS_STOP;
4024 rn = "IntCtl";
4025 break;
4026 case 2:
4027 check_insn(env, ctx, ISA_MIPS32R2);
4028 gen_helper_mtc0_srsctl(arg);
4029 /* Stop translation as we may have switched the execution mode */
4030 ctx->bstate = BS_STOP;
4031 rn = "SRSCtl";
4032 break;
4033 case 3:
4034 check_insn(env, ctx, ISA_MIPS32R2);
4035 gen_mtc0_store32(arg, offsetof(CPUState, CP0_SRSMap));
4036 /* Stop translation as we may have switched the execution mode */
4037 ctx->bstate = BS_STOP;
4038 rn = "SRSMap";
4039 break;
4040 default:
4041 goto die;
4042 }
4043 break;
4044 case 13:
4045 switch (sel) {
4046 case 0:
4047 save_cpu_state(ctx, 1);
4048 gen_helper_mtc0_cause(arg);
4049 rn = "Cause";
4050 break;
4051 default:
4052 goto die;
4053 }
4054 break;
4055 case 14:
4056 switch (sel) {
4057 case 0:
4058 gen_mtc0_store64(arg, offsetof(CPUState, CP0_EPC));
4059 rn = "EPC";
4060 break;
4061 default:
4062 goto die;
4063 }
4064 break;
4065 case 15:
4066 switch (sel) {
4067 case 0:
4068 /* ignored */
4069 rn = "PRid";
4070 break;
4071 case 1:
4072 check_insn(env, ctx, ISA_MIPS32R2);
4073 gen_helper_mtc0_ebase(arg);
4074 rn = "EBase";
4075 break;
4076 default:
4077 goto die;
4078 }
4079 break;
4080 case 16:
4081 switch (sel) {
4082 case 0:
4083 gen_helper_mtc0_config0(arg);
4084 rn = "Config";
4085 /* Stop translation as we may have switched the execution mode */
4086 ctx->bstate = BS_STOP;
4087 break;
4088 case 1:
4089 /* ignored, read only */
4090 rn = "Config1";
4091 break;
4092 case 2:
4093 gen_helper_mtc0_config2(arg);
4094 rn = "Config2";
4095 /* Stop translation as we may have switched the execution mode */
4096 ctx->bstate = BS_STOP;
4097 break;
4098 case 3:
4099 /* ignored, read only */
4100 rn = "Config3";
4101 break;
4102 /* 4,5 are reserved */
4103 /* 6,7 are implementation dependent */
4104 case 6:
4105 /* ignored */
4106 rn = "Config6";
4107 break;
4108 case 7:
4109 /* ignored */
4110 rn = "Config7";
4111 break;
4112 default:
4113 rn = "Invalid config selector";
4114 goto die;
4115 }
4116 break;
4117 case 17:
4118 switch (sel) {
4119 case 0:
4120 gen_helper_mtc0_lladdr(arg);
4121 rn = "LLAddr";
4122 break;
4123 default:
4124 goto die;
4125 }
4126 break;
4127 case 18:
4128 switch (sel) {
4129 case 0 ... 7:
4130 gen_helper_1i(mtc0_watchlo, arg, sel);
4131 rn = "WatchLo";
4132 break;
4133 default:
4134 goto die;
4135 }
4136 break;
4137 case 19:
4138 switch (sel) {
4139 case 0 ... 7:
4140 gen_helper_1i(mtc0_watchhi, arg, sel);
4141 rn = "WatchHi";
4142 break;
4143 default:
4144 goto die;
4145 }
4146 break;
4147 case 20:
4148 switch (sel) {
4149 case 0:
4150 #if defined(TARGET_MIPS64)
4151 check_insn(env, ctx, ISA_MIPS3);
4152 gen_helper_mtc0_xcontext(arg);
4153 rn = "XContext";
4154 break;
4155 #endif
4156 default:
4157 goto die;
4158 }
4159 break;
4160 case 21:
4161 /* Officially reserved, but sel 0 is used for R1x000 framemask */
4162 switch (sel) {
4163 case 0:
4164 gen_helper_mtc0_framemask(arg);
4165 rn = "Framemask";
4166 break;
4167 default:
4168 goto die;
4169 }
4170 break;
4171 case 22:
4172 /* ignored */
4173 rn = "Diagnostic"; /* implementation dependent */
4174 break;
4175 case 23:
4176 switch (sel) {
4177 case 0:
4178 gen_helper_mtc0_debug(arg); /* EJTAG support */
4179 /* BS_STOP isn't good enough here, hflags may have changed. */
4180 gen_save_pc(ctx->pc + 4);
4181 ctx->bstate = BS_EXCP;
4182 rn = "Debug";
4183 break;
4184 case 1:
4185 // gen_helper_mtc0_tracecontrol(arg); /* PDtrace support */
4186 rn = "TraceControl";
4187 /* Stop translation as we may have switched the execution mode */
4188 ctx->bstate = BS_STOP;
4189 // break;
4190 case 2:
4191 // gen_helper_mtc0_tracecontrol2(arg); /* PDtrace support */
4192 rn = "TraceControl2";
4193 /* Stop translation as we may have switched the execution mode */
4194 ctx->bstate = BS_STOP;
4195 // break;
4196 case 3:
4197 /* Stop translation as we may have switched the execution mode */
4198 ctx->bstate = BS_STOP;
4199 // gen_helper_mtc0_usertracedata(arg); /* PDtrace support */
4200 rn = "UserTraceData";
4201 /* Stop translation as we may have switched the execution mode */
4202 ctx->bstate = BS_STOP;
4203 // break;
4204 case 4:
4205 // gen_helper_mtc0_tracebpc(arg); /* PDtrace support */
4206 /* Stop translation as we may have switched the execution mode */
4207 ctx->bstate = BS_STOP;
4208 rn = "TraceBPC";
4209 // break;
4210 default:
4211 goto die;
4212 }
4213 break;
4214 case 24:
4215 switch (sel) {
4216 case 0:
4217 /* EJTAG support */
4218 gen_mtc0_store64(arg, offsetof(CPUState, CP0_DEPC));
4219 rn = "DEPC";
4220 break;
4221 default:
4222 goto die;
4223 }
4224 break;
4225 case 25:
4226 switch (sel) {
4227 case 0:
4228 gen_helper_mtc0_performance0(arg);
4229 rn = "Performance0";
4230 break;
4231 case 1:
4232 // gen_helper_mtc0_performance1(arg);
4233 rn = "Performance1";
4234 // break;
4235 case 2:
4236 // gen_helper_mtc0_performance2(arg);
4237 rn = "Performance2";
4238 // break;
4239 case 3:
4240 // gen_helper_mtc0_performance3(arg);
4241 rn = "Performance3";
4242 // break;
4243 case 4:
4244 // gen_helper_mtc0_performance4(arg);
4245 rn = "Performance4";
4246 // break;
4247 case 5:
4248 // gen_helper_mtc0_performance5(arg);
4249 rn = "Performance5";
4250 // break;
4251 case 6:
4252 // gen_helper_mtc0_performance6(arg);
4253 rn = "Performance6";
4254 // break;
4255 case 7:
4256 // gen_helper_mtc0_performance7(arg);
4257 rn = "Performance7";
4258 // break;
4259 default:
4260 goto die;
4261 }
4262 break;
4263 case 26:
4264 /* ignored */
4265 rn = "ECC";
4266 break;
4267 case 27:
4268 switch (sel) {
4269 case 0 ... 3:
4270 /* ignored */
4271 rn = "CacheErr";
4272 break;
4273 default:
4274 goto die;
4275 }
4276 break;
4277 case 28:
4278 switch (sel) {
4279 case 0:
4280 case 2:
4281 case 4:
4282 case 6:
4283 gen_helper_mtc0_taglo(arg);
4284 rn = "TagLo";
4285 break;
4286 case 1:
4287 case 3:
4288 case 5:
4289 case 7:
4290 gen_helper_mtc0_datalo(arg);
4291 rn = "DataLo";
4292 break;
4293 default:
4294 goto die;
4295 }
4296 break;
4297 case 29:
4298 switch (sel) {
4299 case 0:
4300 case 2:
4301 case 4:
4302 case 6:
4303 gen_helper_mtc0_taghi(arg);
4304 rn = "TagHi";
4305 break;
4306 case 1:
4307 case 3:
4308 case 5:
4309 case 7:
4310 gen_helper_mtc0_datahi(arg);
4311 rn = "DataHi";
4312 break;
4313 default:
4314 rn = "invalid sel";
4315 goto die;
4316 }
4317 break;
4318 case 30:
4319 switch (sel) {
4320 case 0:
4321 gen_mtc0_store64(arg, offsetof(CPUState, CP0_ErrorEPC));
4322 rn = "ErrorEPC";
4323 break;
4324 default:
4325 goto die;
4326 }
4327 break;
4328 case 31:
4329 switch (sel) {
4330 case 0:
4331 /* EJTAG support */
4332 gen_mtc0_store32(arg, offsetof(CPUState, CP0_DESAVE));
4333 rn = "DESAVE";
4334 break;
4335 default:
4336 goto die;
4337 }
4338 /* Stop translation as we may have switched the execution mode */
4339 ctx->bstate = BS_STOP;
4340 break;
4341 default:
4342 goto die;
4343 }
4344 (void)rn; /* avoid a compiler warning */
4345 LOG_DISAS("mtc0 %s (reg %d sel %d)\n", rn, reg, sel);
4346 /* For simplicity assume that all writes can cause interrupts. */
4347 if (use_icount) {
4348 gen_io_end();
4349 ctx->bstate = BS_STOP;
4350 }
4351 return;
4352
4353 die:
4354 LOG_DISAS("mtc0 %s (reg %d sel %d)\n", rn, reg, sel);
4355 generate_exception(ctx, EXCP_RI);
4356 }
4357
4358 #if defined(TARGET_MIPS64)
4359 static void gen_dmfc0 (CPUState *env, DisasContext *ctx, TCGv arg, int reg, int sel)
4360 {
4361 const char *rn = "invalid";
4362
4363 if (sel != 0)
4364 check_insn(env, ctx, ISA_MIPS64);
4365
4366 switch (reg) {
4367 case 0:
4368 switch (sel) {
4369 case 0:
4370 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Index));
4371 rn = "Index";
4372 break;
4373 case 1:
4374 check_insn(env, ctx, ASE_MT);
4375 gen_helper_mfc0_mvpcontrol(arg);
4376 rn = "MVPControl";
4377 break;
4378 case 2:
4379 check_insn(env, ctx, ASE_MT);
4380 gen_helper_mfc0_mvpconf0(arg);
4381 rn = "MVPConf0";
4382 break;
4383 case 3:
4384 check_insn(env, ctx, ASE_MT);
4385 gen_helper_mfc0_mvpconf1(arg);
4386 rn = "MVPConf1";
4387 break;
4388 default:
4389 goto die;
4390 }
4391 break;
4392 case 1:
4393 switch (sel) {
4394 case 0:
4395 gen_helper_mfc0_random(arg);
4396 rn = "Random";
4397 break;
4398 case 1:
4399 check_insn(env, ctx, ASE_MT);
4400 gen_mfc0_load32(arg, offsetof(CPUState, CP0_VPEControl));
4401 rn = "VPEControl";
4402 break;
4403 case 2:
4404 check_insn(env, ctx, ASE_MT);
4405 gen_mfc0_load32(arg, offsetof(CPUState, CP0_VPEConf0));
4406 rn = "VPEConf0";
4407 break;
4408 case 3:
4409 check_insn(env, ctx, ASE_MT);
4410 gen_mfc0_load32(arg, offsetof(CPUState, CP0_VPEConf1));
4411 rn = "VPEConf1";
4412 break;
4413 case 4:
4414 check_insn(env, ctx, ASE_MT);
4415 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_YQMask));
4416 rn = "YQMask";
4417 break;
4418 case 5:
4419 check_insn(env, ctx, ASE_MT);
4420 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_VPESchedule));
4421 rn = "VPESchedule";
4422 break;
4423 case 6:
4424 check_insn(env, ctx, ASE_MT);
4425 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_VPEScheFBack));
4426 rn = "VPEScheFBack";
4427 break;
4428 case 7:
4429 check_insn(env, ctx, ASE_MT);
4430 gen_mfc0_load32(arg, offsetof(CPUState, CP0_VPEOpt));
4431 rn = "VPEOpt";
4432 break;
4433 default:
4434 goto die;
4435 }
4436 break;
4437 case 2:
4438 switch (sel) {
4439 case 0:
4440 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_EntryLo0));
4441 rn = "EntryLo0";
4442 break;
4443 case 1:
4444 check_insn(env, ctx, ASE_MT);
4445 gen_helper_mfc0_tcstatus(arg);
4446 rn = "TCStatus";
4447 break;
4448 case 2:
4449 check_insn(env, ctx, ASE_MT);
4450 gen_helper_mfc0_tcbind(arg);
4451 rn = "TCBind";
4452 break;
4453 case 3:
4454 check_insn(env, ctx, ASE_MT);
4455 gen_helper_dmfc0_tcrestart(arg);
4456 rn = "TCRestart";
4457 break;
4458 case 4:
4459 check_insn(env, ctx, ASE_MT);
4460 gen_helper_dmfc0_tchalt(arg);
4461 rn = "TCHalt";
4462 break;
4463 case 5:
4464 check_insn(env, ctx, ASE_MT);
4465 gen_helper_dmfc0_tccontext(arg);
4466 rn = "TCContext";
4467 break;
4468 case 6:
4469 check_insn(env, ctx, ASE_MT);
4470 gen_helper_dmfc0_tcschedule(arg);
4471 rn = "TCSchedule";
4472 break;
4473 case 7:
4474 check_insn(env, ctx, ASE_MT);
4475 gen_helper_dmfc0_tcschefback(arg);
4476 rn = "TCScheFBack";
4477 break;
4478 default:
4479 goto die;
4480 }
4481 break;
4482 case 3:
4483 switch (sel) {
4484 case 0:
4485 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_EntryLo1));
4486 rn = "EntryLo1";
4487 break;
4488 default:
4489 goto die;
4490 }
4491 break;
4492 case 4:
4493 switch (sel) {
4494 case 0:
4495 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_Context));
4496 rn = "Context";
4497 break;
4498 case 1:
4499 // gen_helper_dmfc0_contextconfig(arg); /* SmartMIPS ASE */
4500 rn = "ContextConfig";
4501 // break;
4502 default:
4503 goto die;
4504 }
4505 break;
4506 case 5:
4507 switch (sel) {
4508 case 0:
4509 gen_mfc0_load32(arg, offsetof(CPUState, CP0_PageMask));
4510 rn = "PageMask";
4511 break;
4512 case 1:
4513 check_insn(env, ctx, ISA_MIPS32R2);
4514 gen_mfc0_load32(arg, offsetof(CPUState, CP0_PageGrain));
4515 rn = "PageGrain";
4516 break;
4517 default:
4518 goto die;
4519 }
4520 break;
4521 case 6:
4522 switch (sel) {
4523 case 0:
4524 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Wired));
4525 rn = "Wired";
4526 break;
4527 case 1:
4528 check_insn(env, ctx, ISA_MIPS32R2);
4529 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSConf0));
4530 rn = "SRSConf0";
4531 break;
4532 case 2:
4533 check_insn(env, ctx, ISA_MIPS32R2);
4534 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSConf1));
4535 rn = "SRSConf1";
4536 break;
4537 case 3:
4538 check_insn(env, ctx, ISA_MIPS32R2);
4539 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSConf2));
4540 rn = "SRSConf2";
4541 break;
4542 case 4:
4543 check_insn(env, ctx, ISA_MIPS32R2);
4544 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSConf3));
4545 rn = "SRSConf3";
4546 break;
4547 case 5:
4548 check_insn(env, ctx, ISA_MIPS32R2);
4549 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSConf4));
4550 rn = "SRSConf4";
4551 break;
4552 default:
4553 goto die;
4554 }
4555 break;
4556 case 7:
4557 switch (sel) {
4558 case 0:
4559 check_insn(env, ctx, ISA_MIPS32R2);
4560 gen_mfc0_load32(arg, offsetof(CPUState, CP0_HWREna));
4561 rn = "HWREna";
4562 break;
4563 default:
4564 goto die;
4565 }
4566 break;
4567 case 8:
4568 switch (sel) {
4569 case 0:
4570 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_BadVAddr));
4571 rn = "BadVAddr";
4572 break;
4573 default:
4574 goto die;
4575 }
4576 break;
4577 case 9:
4578 switch (sel) {
4579 case 0:
4580 /* Mark as an IO operation because we read the time. */
4581 if (use_icount)
4582 gen_io_start();
4583 gen_helper_mfc0_count(arg);
4584 if (use_icount) {
4585 gen_io_end();
4586 }
4587 /* Break the TB to be able to take timer interrupts immediately
4588 after reading count. */
4589 ctx->bstate = BS_STOP;
4590 rn = "Count";
4591 break;
4592 /* 6,7 are implementation dependent */
4593 default:
4594 goto die;
4595 }
4596 break;
4597 case 10:
4598 switch (sel) {
4599 case 0:
4600 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_EntryHi));
4601 rn = "EntryHi";
4602 break;
4603 default:
4604 goto die;
4605 }
4606 break;
4607 case 11:
4608 switch (sel) {
4609 case 0:
4610 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Compare));
4611 rn = "Compare";
4612 break;
4613 /* 6,7 are implementation dependent */
4614 default:
4615 goto die;
4616 }
4617 break;
4618 case 12:
4619 switch (sel) {
4620 case 0:
4621 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Status));
4622 rn = "Status";
4623 break;
4624 case 1:
4625 check_insn(env, ctx, ISA_MIPS32R2);
4626 gen_mfc0_load32(arg, offsetof(CPUState, CP0_IntCtl));
4627 rn = "IntCtl";
4628 break;
4629 case 2:
4630 check_insn(env, ctx, ISA_MIPS32R2);
4631 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSCtl));
4632 rn = "SRSCtl";
4633 break;
4634 case 3:
4635 check_insn(env, ctx, ISA_MIPS32R2);
4636 gen_mfc0_load32(arg, offsetof(CPUState, CP0_SRSMap));
4637 rn = "SRSMap";
4638 break;
4639 default:
4640 goto die;
4641 }
4642 break;
4643 case 13:
4644 switch (sel) {
4645 case 0:
4646 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Cause));
4647 rn = "Cause";
4648 break;
4649 default:
4650 goto die;
4651 }
4652 break;
4653 case 14:
4654 switch (sel) {
4655 case 0:
4656 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_EPC));
4657 rn = "EPC";
4658 break;
4659 default:
4660 goto die;
4661 }
4662 break;
4663 case 15:
4664 switch (sel) {
4665 case 0:
4666 gen_mfc0_load32(arg, offsetof(CPUState, CP0_PRid));
4667 rn = "PRid";
4668 break;
4669 case 1:
4670 check_insn(env, ctx, ISA_MIPS32R2);
4671 gen_mfc0_load32(arg, offsetof(CPUState, CP0_EBase));
4672 rn = "EBase";
4673 break;
4674 default:
4675 goto die;
4676 }
4677 break;
4678 case 16:
4679 switch (sel) {
4680 case 0:
4681 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config0));
4682 rn = "Config";
4683 break;
4684 case 1:
4685 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config1));
4686 rn = "Config1";
4687 break;
4688 case 2:
4689 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config2));
4690 rn = "Config2";
4691 break;
4692 case 3:
4693 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config3));
4694 rn = "Config3";
4695 break;
4696 /* 6,7 are implementation dependent */
4697 case 6:
4698 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config6));
4699 rn = "Config6";
4700 break;
4701 case 7:
4702 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Config7));
4703 rn = "Config7";
4704 break;
4705 default:
4706 goto die;
4707 }
4708 break;
4709 case 17:
4710 switch (sel) {
4711 case 0:
4712 gen_helper_dmfc0_lladdr(arg);
4713 rn = "LLAddr";
4714 break;
4715 default:
4716 goto die;
4717 }
4718 break;
4719 case 18:
4720 switch (sel) {
4721 case 0 ... 7:
4722 gen_helper_1i(dmfc0_watchlo, arg, sel);
4723 rn = "WatchLo";
4724 break;
4725 default:
4726 goto die;
4727 }
4728 break;
4729 case 19:
4730 switch (sel) {
4731 case 0 ... 7:
4732 gen_helper_1i(mfc0_watchhi, arg, sel);
4733 rn = "WatchHi";
4734 break;
4735 default:
4736 goto die;
4737 }
4738 break;
4739 case 20:
4740 switch (sel) {
4741 case 0:
4742 check_insn(env, ctx, ISA_MIPS3);
4743 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_XContext));
4744 rn = "XContext";
4745 break;
4746 default:
4747 goto die;
4748 }
4749 break;
4750 case 21:
4751 /* Officially reserved, but sel 0 is used for R1x000 framemask */
4752 switch (sel) {
4753 case 0:
4754 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Framemask));
4755 rn = "Framemask";
4756 break;
4757 default:
4758 goto die;
4759 }
4760 break;
4761 case 22:
4762 tcg_gen_movi_tl(arg, 0); /* unimplemented */
4763 rn = "'Diagnostic"; /* implementation dependent */
4764 break;
4765 case 23:
4766 switch (sel) {
4767 case 0:
4768 gen_helper_mfc0_debug(arg); /* EJTAG support */
4769 rn = "Debug";
4770 break;
4771 case 1:
4772 // gen_helper_dmfc0_tracecontrol(arg); /* PDtrace support */
4773 rn = "TraceControl";
4774 // break;
4775 case 2:
4776 // gen_helper_dmfc0_tracecontrol2(arg); /* PDtrace support */
4777 rn = "TraceControl2";
4778 // break;
4779 case 3:
4780 // gen_helper_dmfc0_usertracedata(arg); /* PDtrace support */
4781 rn = "UserTraceData";
4782 // break;
4783 case 4:
4784 // gen_helper_dmfc0_tracebpc(arg); /* PDtrace support */
4785 rn = "TraceBPC";
4786 // break;
4787 default:
4788 goto die;
4789 }
4790 break;
4791 case 24:
4792 switch (sel) {
4793 case 0:
4794 /* EJTAG support */
4795 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_DEPC));
4796 rn = "DEPC";
4797 break;
4798 default:
4799 goto die;
4800 }
4801 break;
4802 case 25:
4803 switch (sel) {
4804 case 0:
4805 gen_mfc0_load32(arg, offsetof(CPUState, CP0_Performance0));
4806 rn = "Performance0";
4807 break;
4808 case 1:
4809 // gen_helper_dmfc0_performance1(arg);
4810 rn = "Performance1";
4811 // break;
4812 case 2:
4813 // gen_helper_dmfc0_performance2(arg);
4814 rn = "Performance2";
4815 // break;
4816 case 3:
4817 // gen_helper_dmfc0_performance3(arg);
4818 rn = "Performance3";
4819 // break;
4820 case 4:
4821 // gen_helper_dmfc0_performance4(arg);
4822 rn = "Performance4";
4823 // break;
4824 case 5:
4825 // gen_helper_dmfc0_performance5(arg);
4826 rn = "Performance5";
4827 // break;
4828 case 6:
4829 // gen_helper_dmfc0_performance6(arg);
4830 rn = "Performance6";
4831 // break;
4832 case 7:
4833 // gen_helper_dmfc0_performance7(arg);
4834 rn = "Performance7";
4835 // break;
4836 default:
4837 goto die;
4838 }
4839 break;
4840 case 26:
4841 tcg_gen_movi_tl(arg, 0); /* unimplemented */
4842 rn = "ECC";
4843 break;
4844 case 27:
4845 switch (sel) {
4846 /* ignored */
4847 case 0 ... 3:
4848 tcg_gen_movi_tl(arg, 0); /* unimplemented */
4849 rn = "CacheErr";
4850 break;
4851 default:
4852 goto die;
4853 }
4854 break;
4855 case 28:
4856 switch (sel) {
4857 case 0:
4858 case 2:
4859 case 4:
4860 case 6:
4861 gen_mfc0_load32(arg, offsetof(CPUState, CP0_TagLo));
4862 rn = "TagLo";
4863 break;
4864 case 1:
4865 case 3:
4866 case 5:
4867 case 7:
4868 gen_mfc0_load32(arg, offsetof(CPUState, CP0_DataLo));
4869 rn = "DataLo";
4870 break;
4871 default:
4872 goto die;
4873 }
4874 break;
4875 case 29:
4876 switch (sel) {
4877 case 0:
4878 case 2:
4879 case 4:
4880 case 6:
4881 gen_mfc0_load32(arg, offsetof(CPUState, CP0_TagHi));
4882 rn = "TagHi";
4883 break;
4884 case 1:
4885 case 3:
4886 case 5:
4887 case 7:
4888 gen_mfc0_load32(arg, offsetof(CPUState, CP0_DataHi));
4889 rn = "DataHi";
4890 break;
4891 default:
4892 goto die;
4893 }
4894 break;
4895 case 30:
4896 switch (sel) {
4897 case 0:
4898 tcg_gen_ld_tl(arg, cpu_env, offsetof(CPUState, CP0_ErrorEPC));
4899 rn = "ErrorEPC";
4900 break;
4901 default:
4902 goto die;
4903 }
4904 break;
4905 case 31:
4906 switch (sel) {
4907 case 0:
4908 /* EJTAG support */
4909 gen_mfc0_load32(arg, offsetof(CPUState, CP0_DESAVE));
4910 rn = "DESAVE";
4911 break;
4912 default:
4913 goto die;
4914 }
4915 break;
4916 default:
4917 goto die;
4918 }
4919 (void)rn; /* avoid a compiler warning */
4920 LOG_DISAS("dmfc0 %s (reg %d sel %d)\n", rn, reg, sel);
4921 return;
4922
4923 die:
4924 LOG_DISAS("dmfc0 %s (reg %d sel %d)\n", rn, reg, sel);
4925 generate_exception(ctx, EXCP_RI);
4926 }
4927
4928 static void gen_dmtc0 (CPUState *env, DisasContext *ctx, TCGv arg, int reg, int sel)
4929 {
4930 const char *rn = "invalid";
4931
4932 if (sel != 0)
4933 check_insn(env, ctx, ISA_MIPS64);
4934
4935 if (use_icount)
4936 gen_io_start();
4937
4938 switch (reg) {
4939 case 0:
4940 switch (sel) {
4941 case 0:
4942 gen_helper_mtc0_index(arg);
4943 rn = "Index";
4944 break;
4945 case 1:
4946 check_insn(env, ctx, ASE_MT);
4947 gen_helper_mtc0_mvpcontrol(arg);
4948 rn = "MVPControl";
4949 break;
4950 case 2:
4951 check_insn(env, ctx, ASE_MT);
4952 /* ignored */
4953 rn = "MVPConf0";
4954 break;
4955 case 3:
4956 check_insn(env, ctx, ASE_MT);
4957 /* ignored */
4958 rn = "MVPConf1";
4959 break;
4960 default:
4961 goto die;
4962 }
4963 break;
4964 case 1:
4965 switch (sel) {
4966 case 0:
4967 /* ignored */
4968 rn = "Random";
4969 break;
4970 case 1:
4971 check_insn(env, ctx, ASE_MT);
4972 gen_helper_mtc0_vpecontrol(arg);
4973 rn = "VPEControl";
4974 break;
4975 case 2:
4976 check_insn(env, ctx, ASE_MT);
4977 gen_helper_mtc0_vpeconf0(arg);
4978 rn = "VPEConf0";
4979 break;
4980 case 3:
4981 check_insn(env, ctx, ASE_MT);
4982 gen_helper_mtc0_vpeconf1(arg);
4983 rn = "VPEConf1";
4984 break;
4985 case 4:
4986 check_insn(env, ctx, ASE_MT);
4987 gen_helper_mtc0_yqmask(arg);
4988 rn = "YQMask";
4989 break;
4990 case 5:
4991 check_insn(env, ctx, ASE_MT);
4992 tcg_gen_st_tl(arg, cpu_env, offsetof(CPUState, CP0_VPESchedule));
4993 rn = "VPESchedule";
4994 break;
4995 case 6:
4996 check_insn(env, ctx, ASE_MT);
4997 tcg_gen_st_tl(arg, cpu_env, offsetof(CPUState, CP0_VPEScheFBack));
4998 rn = "VPEScheFBack";
4999 break;
5000 case 7:
5001 check_insn(env, ctx, ASE_MT);
5002 gen_helper_mtc0_vpeopt(arg);
5003 rn = "VPEOpt";
5004 break;
5005 default:
5006 goto die;
5007 }
5008 break;
5009 case 2:
5010 switch (sel) {
5011 case 0:
5012 gen_helper_mtc0_entrylo0(arg);
5013 rn = "EntryLo0";
5014 break;
5015 case 1:
5016 check_insn(env, ctx, ASE_MT);
5017 gen_helper_mtc0_tcstatus(arg);
5018 rn = "TCStatus";
5019 break;
5020 case 2:
5021 check_insn(env, ctx, ASE_MT);
5022 gen_helper_mtc0_tcbind(arg);
5023 rn = "TCBind";
5024 break;
5025 case 3:
5026 check_insn(env, ctx, ASE_MT);
5027 gen_helper_mtc0_tcrestart(arg);
5028 rn = "TCRestart";
5029 break;
5030 case 4:
5031 check_insn(env, ctx, ASE_MT);
5032 gen_helper_mtc0_tchalt(arg);
5033 rn = "TCHalt";
5034 break;
5035 case 5:
5036 check_insn(env, ctx, ASE_MT);
5037 gen_helper_mtc0_tccontext(arg);
5038 rn = "TCContext";
5039 break;
5040 case 6:
5041 check_insn(env, ctx, ASE_MT);
5042 gen_helper_mtc0_tcschedule(arg);
5043 rn = "TCSchedule";
5044 break;
5045 case 7:
5046 check_insn(env, ctx, ASE_MT);
5047 gen_helper_mtc0_tcschefback(arg);
5048 rn = "TCScheFBack";
5049 break;
5050 default:
5051 goto die;
5052 }
5053 break;
5054 case 3:
5055 switch (sel) {
5056 case 0:
5057 gen_helper_mtc0_entrylo1(arg);
5058 rn = "EntryLo1";
5059 break;
5060 default:
5061 goto die;
5062 }
5063 break;
5064 case 4:
5065 switch (sel) {
5066 case 0:
5067 gen_helper_mtc0_context(arg);
5068 rn = "Context";
5069 break;
5070 case 1:
5071 // gen_helper_mtc0_contextconfig(arg); /* SmartMIPS ASE */
5072 rn = "ContextConfig";
5073 // break;
5074 default:
5075 goto die;
5076 }
5077 break;
5078 case 5:
5079 switch (sel) {
5080 case 0:
5081 gen_helper_mtc0_pagemask(arg);
5082 rn = "PageMask";
5083 break;
5084 case 1:
5085 check_insn(env, ctx, ISA_MIPS32R2);
5086 gen_helper_mtc0_pagegrain(arg);
5087 rn = "PageGrain";
5088 break;
5089 default:
5090 goto die;
5091 }
5092 break;
5093 case 6:
5094 switch (sel) {
5095 case 0:
5096 gen_helper_mtc0_wired(arg);
5097 rn = "Wired";
5098 break;
5099 case 1:
5100 check_insn(env, ctx, ISA_MIPS32R2);
5101 gen_helper_mtc0_srsconf0(arg);
5102 rn = "SRSConf0";
5103 break;
5104 case 2:
5105 check_insn(env, ctx, ISA_MIPS32R2);
5106 gen_helper_mtc0_srsconf1(arg);
5107 rn = "SRSConf1";
5108 break;
5109 case 3:
5110 check_insn(env, ctx, ISA_MIPS32R2);
5111 gen_helper_mtc0_srsconf2(arg);
5112 rn = "SRSConf2";
5113 break;
5114 case 4:
5115 check_insn(env, ctx, ISA_MIPS32R2);
5116 gen_helper_mtc0_srsconf3(arg);
5117 rn = "SRSConf3";
5118 break;
5119 case 5:
5120 check_insn(env, ctx, ISA_MIPS32R2);
5121 gen_helper_mtc0_srsconf4(arg);
5122 rn = "SRSConf4";
5123 break;
5124 default:
5125 goto die;
5126 }
5127 break;
5128 case 7:
5129 switch (sel) {
5130 case 0:
5131 check_insn(env, ctx, ISA_MIPS32R2);
5132 gen_helper_mtc0_hwrena(arg);
5133 rn = "HWREna";
5134 break;
5135 default:
5136 goto die;
5137 }
5138 break;
5139 case 8:
5140 /* ignored */
5141 rn = "BadVAddr";
5142 break;
5143 case 9:
5144 switch (sel) {
5145 case 0:
5146 gen_helper_mtc0_count(arg);
5147 rn = "Count";
5148 break;
5149 /* 6,7 are implementation dependent */
5150 default:
5151 goto die;
5152 }
5153 /* Stop translation as we may have switched the execution mode */
5154 ctx->bstate = BS_STOP;
5155 break;
5156 case 10:
5157 switch (sel) {
5158 case 0:
5159 gen_helper_mtc0_entryhi(arg);
5160 rn = "EntryHi";
5161 break;
5162 default:
5163 goto die;
5164 }
5165 break;
5166 case 11:
5167 switch (sel) {
5168 case 0:
5169 gen_helper_mtc0_compare(arg);
5170 rn = "Compare";
5171 break;
5172 /* 6,7 are implementation dependent */
5173 default:
5174 goto die;
5175 }
5176 /* Stop translation as we may have switched the execution mode */
5177 ctx->bstate = BS_STOP;
5178 break;
5179 case 12:
5180 switch (sel) {
5181 case 0:
5182 save_cpu_state(ctx, 1);
5183 gen_helper_mtc0_status(arg);
5184 /* BS_STOP isn't good enough here, hflags may have changed. */
5185 gen_save_pc(ctx->pc + 4);
5186 ctx->bstate = BS_EXCP;
5187 rn = "Status";
5188 break;
5189 case 1:
5190 check_insn(env, ctx, ISA_MIPS32R2);
5191 gen_helper_mtc0_intctl(arg);
5192 /* Stop translation as we may have switched the execution mode */
5193 ctx->bstate = BS_STOP;
5194 rn = "IntCtl";
5195 break;
5196 case 2:
5197 check_insn(env, ctx, ISA_MIPS32R2);
5198 gen_helper_mtc0_srsctl(arg);
5199 /* Stop translation as we may have switched the execution mode */
5200 ctx->bstate = BS_STOP;
5201 rn = "SRSCtl";
5202 break;
5203 case 3:
5204 check_insn(env, ctx, ISA_MIPS32R2);
5205 gen_mtc0_store32(arg, offsetof(CPUState, CP0_SRSMap));
5206 /* Stop translation as we may have switched the execution mode */
5207 ctx->bstate = BS_STOP;
5208 rn = "SRSMap";
5209 break;
5210 default:
5211 goto die;
5212 }
5213 break;
5214 case 13:
5215 switch (sel) {
5216 case 0:
5217 save_cpu_state(ctx, 1);
5218 /* Mark as an IO operation because we may trigger a software
5219 interrupt. */
5220 if (use_icount) {
5221 gen_io_start();
5222 }
5223 gen_helper_mtc0_cause(arg);
5224 if (use_icount) {
5225 gen_io_end();
5226 }
5227 /* Stop translation as we may have triggered an intetrupt */
5228 ctx->bstate = BS_STOP;
5229 rn = "Cause";
5230 break;
5231 default:
5232 goto die;
5233 }
5234 break;
5235 case 14:
5236 switch (sel) {
5237 case 0:
5238 tcg_gen_st_tl(arg, cpu_env, offsetof(CPUState, CP0_EPC));
5239 rn = "EPC";
5240 break;
5241 default:
5242 goto die;
5243 }
5244 break;
5245 case 15:
5246 switch (sel) {
5247 case 0:
5248 /* ignored */
5249 rn = "PRid";
5250 break;
5251 case 1:
5252 check_insn(env, ctx, ISA_MIPS32R2);
5253 gen_helper_mtc0_ebase(arg);
5254 rn = "EBase";
5255 break;
5256 default:
5257 goto die;
5258 }
5259 break;
5260 case 16:
5261 switch (sel) {
5262 case 0:
5263 gen_helper_mtc0_config0(arg);
5264 rn = "Config";
5265 /* Stop translation as we may have switched the execution mode */
5266 ctx->bstate = BS_STOP;
5267 break;
5268 case 1:
5269 /* ignored, read only */
5270 rn = "Config1";
5271 break;
5272 case 2:
5273 gen_helper_mtc0_config2(arg);
5274 rn = "Config2";
5275 /* Stop translation as we may have switched the execution mode */
5276 ctx->bstate = BS_STOP;
5277 break;
5278 case 3:
5279 /* ignored */
5280 rn = "Config3";
5281 break;
5282 /* 6,7 are implementation dependent */
5283 default:
5284 rn = "Invalid config selector";
5285 goto die;
5286 }
5287 break;
5288 case 17:
5289 switch (sel) {
5290 case 0:
5291 gen_helper_mtc0_lladdr(arg);
5292 rn = "LLAddr";
5293 break;
5294 default:
5295 goto die;
5296 }
5297 break;
5298 case 18:
5299 switch (sel) {
5300 case 0 ... 7:
5301 gen_helper_1i(mtc0_watchlo, arg, sel);
5302 rn = "WatchLo";
5303 break;
5304 default:
5305 goto die;
5306 }
5307 break;
5308 case 19:
5309 switch (sel) {
5310 case 0 ... 7:
5311 gen_helper_1i(mtc0_watchhi, arg, sel);
5312 rn = "WatchHi";
5313 break;
5314 default:
5315 goto die;
5316 }
5317 break;
5318 case 20:
5319 switch (sel) {
5320 case 0:
5321 check_insn(env, ctx, ISA_MIPS3);
5322 gen_helper_mtc0_xcontext(arg);
5323 rn = "XContext";
5324 break;
5325 default:
5326 goto die;
5327 }
5328 break;
5329 case 21:
5330 /* Officially reserved, but sel 0 is used for R1x000 framemask */
5331 switch (sel) {
5332 case 0:
5333 gen_helper_mtc0_framemask(arg);
5334 rn = "Framemask";
5335 break;
5336 default:
5337 goto die;
5338 }
5339 break;
5340 case 22:
5341 /* ignored */
5342 rn = "Diagnostic"; /* implementation dependent */
5343 break;
5344 case 23:
5345 switch (sel) {
5346 case 0:
5347 gen_helper_mtc0_debug(arg); /* EJTAG support */
5348 /* BS_STOP isn't good enough here, hflags may have changed. */
5349 gen_save_pc(ctx->pc + 4);
5350 ctx->bstate = BS_EXCP;
5351 rn = "Debug";
5352 break;
5353 case 1:
5354 // gen_helper_mtc0_tracecontrol(arg); /* PDtrace support */
5355 /* Stop translation as we may have switched the execution mode */
5356 ctx->bstate = BS_STOP;
5357 rn = "TraceControl";
5358 // break;
5359 case 2:
5360 // gen_helper_mtc0_tracecontrol2(arg); /* PDtrace support */
5361 /* Stop translation as we may have switched the execution mode */
5362 ctx->bstate = BS_STOP;
5363 rn = "TraceControl2";
5364 // break;
5365 case 3:
5366 // gen_helper_mtc0_usertracedata(arg); /* PDtrace support */
5367 /* Stop translation as we may have switched the execution mode */
5368 ctx->bstate = BS_STOP;
5369 rn = "UserTraceData";
5370 // break;
5371 case 4:
5372 // gen_helper_mtc0_tracebpc(arg); /* PDtrace support */
5373 /* Stop translation as we may have switched the execution mode */
5374 ctx->bstate = BS_STOP;
5375 rn = "TraceBPC";
5376 // break;
5377 default:
5378 goto die;
5379 }
5380 break;
5381 case 24:
5382 switch (sel) {
5383 case 0:
5384 /* EJTAG support */
5385 tcg_gen_st_tl(arg, cpu_env, offsetof(CPUState, CP0_DEPC));
5386 rn = "DEPC";
5387 break;
5388 default:
5389 goto die;
5390 }
5391 break;
5392 case 25:
5393 switch (sel) {
5394 case 0:
5395 gen_helper_mtc0_performance0(arg);
5396 rn = "Performance0";
5397 break;
5398 case 1:
5399 // gen_helper_mtc0_performance1(arg);
5400 rn = "Performance1";
5401 // break;
5402 case 2:
5403 // gen_helper_mtc0_performance2(arg);
5404 rn = "Performance2";
5405 // break;
5406 case 3:
5407 // gen_helper_mtc0_performance3(arg);
5408 rn = "Performance3";
5409 // break;
5410 case 4:
5411 // gen_helper_mtc0_performance4(arg);
5412 rn = "Performance4";
5413 // break;
5414 case 5:
5415 // gen_helper_mtc0_performance5(arg);
5416 rn = "Performance5";
5417 // break;
5418 case 6:
5419 // gen_helper_mtc0_performance6(arg);
5420 rn = "Performance6";
5421 // break;
5422 case 7:
5423 // gen_helper_mtc0_performance7(arg);
5424 rn = "Performance7";
5425 // break;
5426 default:
5427 goto die;
5428 }
5429 break;
5430 case 26:
5431 /* ignored */
5432 rn = "ECC";
5433 break;
5434 case 27:
5435 switch (sel) {
5436 case 0 ... 3:
5437 /* ignored */
5438 rn = "CacheErr";
5439 break;
5440 default:
5441 goto die;
5442 }
5443 break;
5444 case 28:
5445 switch (sel) {
5446 case 0:
5447 case 2:
5448 case 4:
5449 case 6:
5450 gen_helper_mtc0_taglo(arg);
5451 rn = "TagLo";
5452 break;
5453 case 1:
5454 case 3:
5455 case 5:
5456 case 7:
5457 gen_helper_mtc0_datalo(arg);
5458 rn = "DataLo";
5459 break;
5460 default:
5461 goto die;
5462 }
5463 break;
5464 case 29:
5465 switch (sel) {
5466 case 0:
5467 case 2:
5468 case 4:
5469 case 6:
5470 gen_helper_mtc0_taghi(arg);
5471 rn = "TagHi";
5472 break;
5473 case 1:
5474 case 3:
5475 case 5:
5476 case 7:
5477 gen_helper_mtc0_datahi(arg);
5478 rn = "DataHi";
5479 break;
5480 default:
5481 rn = "invalid sel";
5482 goto die;
5483 }
5484 break;
5485 case 30:
5486 switch (sel) {
5487 case 0:
5488 tcg_gen_st_tl(arg, cpu_env, offsetof(CPUState, CP0_ErrorEPC));
5489 rn = "ErrorEPC";
5490 break;
5491 default:
5492 goto die;
5493 }
5494 break;
5495 case 31:
5496 switch (sel) {
5497 case 0:
5498 /* EJTAG support */
5499 gen_mtc0_store32(arg, offsetof(CPUState, CP0_DESAVE));
5500 rn = "DESAVE";
5501 break;
5502 default:
5503 goto die;
5504 }
5505 /* Stop translation as we may have switched the execution mode */
5506 ctx->bstate = BS_STOP;
5507 break;
5508 default:
5509 goto die;
5510 }
5511 (void)rn; /* avoid a compiler warning */
5512 LOG_DISAS("dmtc0 %s (reg %d sel %d)\n", rn, reg, sel);
5513 /* For simplicity assume that all writes can cause interrupts. */
5514 if (use_icount) {
5515 gen_io_end();
5516 ctx->bstate = BS_STOP;
5517 }
5518 return;
5519
5520 die:
5521 LOG_DISAS("dmtc0 %s (reg %d sel %d)\n", rn, reg, sel);
5522 generate_exception(ctx, EXCP_RI);
5523 }
5524 #endif /* TARGET_MIPS64 */
5525
5526 static void gen_mftr(CPUState *env, DisasContext *ctx, int rt, int rd,
5527 int u, int sel, int h)
5528 {
5529 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
5530 TCGv t0 = tcg_temp_local_new();
5531
5532 if ((env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP)) == 0 &&
5533 ((env->tcs[other_tc].CP0_TCBind & (0xf << CP0TCBd_CurVPE)) !=
5534 (env->active_tc.CP0_TCBind & (0xf << CP0TCBd_CurVPE))))
5535 tcg_gen_movi_tl(t0, -1);
5536 else if ((env->CP0_VPEControl & (0xff << CP0VPECo_TargTC)) >
5537 (env->mvp->CP0_MVPConf0 & (0xff << CP0MVPC0_PTC)))
5538 tcg_gen_movi_tl(t0, -1);
5539 else if (u == 0) {
5540 switch (rt) {
5541 case 2:
5542 switch (sel) {
5543 case 1:
5544 gen_helper_mftc0_tcstatus(t0);
5545 break;
5546 case 2:
5547 gen_helper_mftc0_tcbind(t0);
5548 break;
5549 case 3:
5550 gen_helper_mftc0_tcrestart(t0);
5551 break;
5552 case 4:
5553 gen_helper_mftc0_tchalt(t0);
5554 break;
5555 case 5:
5556 gen_helper_mftc0_tccontext(t0);
5557 break;
5558 case 6:
5559 gen_helper_mftc0_tcschedule(t0);
5560 break;
5561 case 7:
5562 gen_helper_mftc0_tcschefback(t0);
5563 break;
5564 default:
5565 gen_mfc0(env, ctx, t0, rt, sel);
5566 break;
5567 }
5568 break;
5569 case 10:
5570 switch (sel) {
5571 case 0:
5572 gen_helper_mftc0_entryhi(t0);
5573 break;
5574 default:
5575 gen_mfc0(env, ctx, t0, rt, sel);
5576 break;
5577 }
5578 case 12:
5579 switch (sel) {
5580 case 0:
5581 gen_helper_mftc0_status(t0);
5582 break;
5583 default:
5584 gen_mfc0(env, ctx, t0, rt, sel);
5585 break;
5586 }
5587 case 23:
5588 switch (sel) {
5589 case 0:
5590 gen_helper_mftc0_debug(t0);
5591 break;
5592 default:
5593 gen_mfc0(env, ctx, t0, rt, sel);
5594 break;
5595 }
5596 break;
5597 default:
5598 gen_mfc0(env, ctx, t0, rt, sel);
5599 }
5600 } else switch (sel) {
5601 /* GPR registers. */
5602 case 0:
5603 gen_helper_1i(mftgpr, t0, rt);
5604 break;
5605 /* Auxiliary CPU registers */
5606 case 1:
5607 switch (rt) {
5608 case 0:
5609 gen_helper_1i(mftlo, t0, 0);
5610 break;
5611 case 1:
5612 gen_helper_1i(mfthi, t0, 0);
5613 break;
5614 case 2:
5615 gen_helper_1i(mftacx, t0, 0);
5616 break;
5617 case 4:
5618 gen_helper_1i(mftlo, t0, 1);
5619 break;
5620 case 5:
5621 gen_helper_1i(mfthi, t0, 1);
5622 break;
5623 case 6:
5624 gen_helper_1i(mftacx, t0, 1);
5625 break;
5626 case 8:
5627 gen_helper_1i(mftlo, t0, 2);
5628 break;
5629 case 9:
5630 gen_helper_1i(mfthi, t0, 2);
5631 break;
5632 case 10:
5633 gen_helper_1i(mftacx, t0, 2);
5634 break;
5635 case 12:
5636 gen_helper_1i(mftlo, t0, 3);
5637 break;
5638 case 13:
5639 gen_helper_1i(mfthi, t0, 3);
5640 break;
5641 case 14:
5642 gen_helper_1i(mftacx, t0, 3);
5643 break;
5644 case 16:
5645 gen_helper_mftdsp(t0);
5646 break;
5647 default:
5648 goto die;
5649 }
5650 break;
5651 /* Floating point (COP1). */
5652 case 2:
5653 /* XXX: For now we support only a single FPU context. */
5654 if (h == 0) {
5655 TCGv_i32 fp0 = tcg_temp_new_i32();
5656
5657 gen_load_fpr32(fp0, rt);
5658 tcg_gen_ext_i32_tl(t0, fp0);
5659 tcg_temp_free_i32(fp0);
5660 } else {
5661 TCGv_i32 fp0 = tcg_temp_new_i32();
5662
5663 gen_load_fpr32h(fp0, rt);
5664 tcg_gen_ext_i32_tl(t0, fp0);
5665 tcg_temp_free_i32(fp0);
5666 }
5667 break;
5668 case 3:
5669 /* XXX: For now we support only a single FPU context. */
5670 gen_helper_1i(cfc1, t0, rt);
5671 break;
5672 /* COP2: Not implemented. */
5673 case 4:
5674 case 5:
5675 /* fall through */
5676 default:
5677 goto die;
5678 }
5679 LOG_DISAS("mftr (reg %d u %d sel %d h %d)\n", rt, u, sel, h);
5680 gen_store_gpr(t0, rd);
5681 tcg_temp_free(t0);
5682 return;
5683
5684 die:
5685 tcg_temp_free(t0);
5686 LOG_DISAS("mftr (reg %d u %d sel %d h %d)\n", rt, u, sel, h);
5687 generate_exception(ctx, EXCP_RI);
5688 }
5689
5690 static void gen_mttr(CPUState *env, DisasContext *ctx, int rd, int rt,
5691 int u, int sel, int h)
5692 {
5693 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
5694 TCGv t0 = tcg_temp_local_new();
5695
5696 gen_load_gpr(t0, rt);
5697 if ((env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP)) == 0 &&
5698 ((env->tcs[other_tc].CP0_TCBind & (0xf << CP0TCBd_CurVPE)) !=
5699 (env->active_tc.CP0_TCBind & (0xf << CP0TCBd_CurVPE))))
5700 /* NOP */ ;
5701 else if ((env->CP0_VPEControl & (0xff << CP0VPECo_TargTC)) >
5702 (env->mvp->CP0_MVPConf0 & (0xff << CP0MVPC0_PTC)))
5703 /* NOP */ ;
5704 else if (u == 0) {
5705 switch (rd) {
5706 case 2:
5707 switch (sel) {
5708 case 1:
5709 gen_helper_mttc0_tcstatus(t0);
5710 break;
5711 case 2:
5712 gen_helper_mttc0_tcbind(t0);
5713 break;
5714 case 3:
5715 gen_helper_mttc0_tcrestart(t0);
5716 break;
5717 case 4:
5718 gen_helper_mttc0_tchalt(t0);
5719 break;
5720 case 5:
5721 gen_helper_mttc0_tccontext(t0);
5722 break;
5723 case 6:
5724 gen_helper_mttc0_tcschedule(t0);
5725 break;
5726 case 7:
5727 gen_helper_mttc0_tcschefback(t0);
5728 break;
5729 default:
5730 gen_mtc0(env, ctx, t0, rd, sel);
5731 break;
5732 }
5733 break;
5734 case 10:
5735 switch (sel) {
5736 case 0:
5737 gen_helper_mttc0_entryhi(t0);
5738 break;
5739 default:
5740 gen_mtc0(env, ctx, t0, rd, sel);
5741 break;
5742 }
5743 case 12:
5744 switch (sel) {
5745 case 0:
5746 gen_helper_mttc0_status(t0);
5747 break;
5748 default:
5749 gen_mtc0(env, ctx, t0, rd, sel);
5750 break;
5751 }
5752 case 23:
5753 switch (sel) {
5754 case 0:
5755 gen_helper_mttc0_debug(t0);
5756 break;
5757 default:
5758 gen_mtc0(env, ctx, t0, rd, sel);
5759 break;
5760 }
5761 break;
5762 default:
5763 gen_mtc0(env, ctx, t0, rd, sel);
5764 }
5765 } else switch (sel) {
5766 /* GPR registers. */
5767 case 0:
5768 gen_helper_1i(mttgpr, t0, rd);
5769 break;
5770 /* Auxiliary CPU registers */
5771 case 1:
5772 switch (rd) {
5773 case 0:
5774 gen_helper_1i(mttlo, t0, 0);
5775 break;
5776 case 1:
5777 gen_helper_1i(mtthi, t0, 0);
5778 break;
5779 case 2:
5780 gen_helper_1i(mttacx, t0, 0);
5781 break;
5782 case 4:
5783 gen_helper_1i(mttlo, t0, 1);
5784 break;
5785 case 5:
5786 gen_helper_1i(mtthi, t0, 1);
5787 break;
5788 case 6:
5789 gen_helper_1i(mttacx, t0, 1);
5790 break;
5791 case 8:
5792 gen_helper_1i(mttlo, t0, 2);
5793 break;
5794 case 9:
5795 gen_helper_1i(mtthi, t0, 2);
5796 break;
5797 case 10:
5798 gen_helper_1i(mttacx, t0, 2);
5799 break;
5800 case 12:
5801 gen_helper_1i(mttlo, t0, 3);
5802 break;
5803 case 13:
5804 gen_helper_1i(mtthi, t0, 3);
5805 break;
5806 case 14:
5807 gen_helper_1i(mttacx, t0, 3);
5808 break;
5809 case 16:
5810 gen_helper_mttdsp(t0);
5811 break;
5812 default:
5813 goto die;
5814 }
5815 break;
5816 /* Floating point (COP1). */
5817 case 2:
5818 /* XXX: For now we support only a single FPU context. */
5819 if (h == 0) {
5820 TCGv_i32 fp0 = tcg_temp_new_i32();
5821
5822 tcg_gen_trunc_tl_i32(fp0, t0);
5823 gen_store_fpr32(fp0, rd);
5824 tcg_temp_free_i32(fp0);
5825 } else {
5826 TCGv_i32 fp0 = tcg_temp_new_i32();
5827
5828 tcg_gen_trunc_tl_i32(fp0, t0);
5829 gen_store_fpr32h(fp0, rd);
5830 tcg_temp_free_i32(fp0);
5831 }
5832 break;
5833 case 3:
5834 /* XXX: For now we support only a single FPU context. */
5835 gen_helper_1i(ctc1, t0, rd);
5836 break;
5837 /* COP2: Not implemented. */
5838 case 4:
5839 case 5:
5840 /* fall through */
5841 default:
5842 goto die;
5843 }
5844 LOG_DISAS("mttr (reg %d u %d sel %d h %d)\n", rd, u, sel, h);
5845 tcg_temp_free(t0);
5846 return;
5847
5848 die:
5849 tcg_temp_free(t0);
5850 LOG_DISAS("mttr (reg %d u %d sel %d h %d)\n", rd, u, sel, h);
5851 generate_exception(ctx, EXCP_RI);
5852 }
5853
5854 static void gen_cp0 (CPUState *env, DisasContext *ctx, uint32_t opc, int rt, int rd)
5855 {
5856 const char *opn = "ldst";
5857
5858 switch (opc) {
5859 case OPC_MFC0:
5860 if (rt == 0) {
5861 /* Treat as NOP. */
5862 return;
5863 }
5864 gen_mfc0(env, ctx, cpu_gpr[rt], rd, ctx->opcode & 0x7);
5865 opn = "mfc0";
5866 break;
5867 case OPC_MTC0:
5868 {
5869 TCGv t0 = tcg_temp_new();
5870
5871 gen_load_gpr(t0, rt);
5872 gen_mtc0(env, ctx, t0, rd, ctx->opcode & 0x7);
5873 tcg_temp_free(t0);
5874 }
5875 opn = "mtc0";
5876 break;
5877 #if defined(TARGET_MIPS64)
5878 case OPC_DMFC0:
5879 check_insn(env, ctx, ISA_MIPS3);
5880 if (rt == 0) {
5881 /* Treat as NOP. */
5882 return;
5883 }
5884 gen_dmfc0(env, ctx, cpu_gpr[rt], rd, ctx->opcode & 0x7);
5885 opn = "dmfc0";
5886 break;
5887 case OPC_DMTC0:
5888 check_insn(env, ctx, ISA_MIPS3);
5889 {
5890 TCGv t0 = tcg_temp_new();
5891
5892 gen_load_gpr(t0, rt);
5893 gen_dmtc0(env, ctx, t0, rd, ctx->opcode & 0x7);
5894 tcg_temp_free(t0);
5895 }
5896 opn = "dmtc0";
5897 break;
5898 #endif
5899 case OPC_MFTR:
5900 check_insn(env, ctx, ASE_MT);
5901 if (rd == 0) {
5902 /* Treat as NOP. */
5903 return;
5904 }
5905 gen_mftr(env, ctx, rt, rd, (ctx->opcode >> 5) & 1,
5906 ctx->opcode & 0x7, (ctx->opcode >> 4) & 1);
5907 opn = "mftr";
5908 break;
5909 case OPC_MTTR:
5910 check_insn(env, ctx, ASE_MT);
5911 gen_mttr(env, ctx, rd, rt, (ctx->opcode >> 5) & 1,
5912 ctx->opcode & 0x7, (ctx->opcode >> 4) & 1);
5913 opn = "mttr";
5914 break;
5915 case OPC_TLBWI:
5916 opn = "tlbwi";
5917 if (!env->tlb->helper_tlbwi)
5918 goto die;
5919 gen_helper_tlbwi();
5920 break;
5921 case OPC_TLBWR:
5922 opn = "tlbwr";
5923 if (!env->tlb->helper_tlbwr)
5924 goto die;
5925 gen_helper_tlbwr();
5926 break;
5927 case OPC_TLBP:
5928 opn = "tlbp";
5929 if (!env->tlb->helper_tlbp)
5930 goto die;
5931 gen_helper_tlbp();
5932 break;
5933 case OPC_TLBR:
5934 opn = "tlbr";
5935 if (!env->tlb->helper_tlbr)
5936 goto die;
5937 gen_helper_tlbr();
5938 break;
5939 case OPC_ERET:
5940 opn = "eret";
5941 check_insn(env, ctx, ISA_MIPS2);
5942 gen_helper_eret();
5943 ctx->bstate = BS_EXCP;
5944 break;
5945 case OPC_DERET:
5946 opn = "deret";
5947 check_insn(env, ctx, ISA_MIPS32);
5948 if (!(ctx->hflags & MIPS_HFLAG_DM)) {
5949 MIPS_INVAL(opn);
5950 generate_exception(ctx, EXCP_RI);
5951 } else {
5952 gen_helper_deret();
5953 ctx->bstate = BS_EXCP;
5954 }
5955 break;
5956 case OPC_WAIT:
5957 opn = "wait";
5958 check_insn(env, ctx, ISA_MIPS3 | ISA_MIPS32);
5959 /* If we get an exception, we want to restart at next instruction */
5960 ctx->pc += 4;
5961 save_cpu_state(ctx, 1);
5962 ctx->pc -= 4;
5963 gen_helper_wait();
5964 ctx->bstate = BS_EXCP;
5965 break;
5966 default:
5967 die:
5968 MIPS_INVAL(opn);
5969 generate_exception(ctx, EXCP_RI);
5970 return;
5971 }
5972 (void)opn; /* avoid a compiler warning */
5973 MIPS_DEBUG("%s %s %d", opn, regnames[rt], rd);
5974 }
5975 #endif /* !CONFIG_USER_ONLY */
5976
5977 /* CP1 Branches (before delay slot) */
5978 static void gen_compute_branch1 (CPUState *env, DisasContext *ctx, uint32_t op,
5979 int32_t cc, int32_t offset)
5980 {
5981 target_ulong btarget;
5982 const char *opn = "cp1 cond branch";
5983 TCGv_i32 t0 = tcg_temp_new_i32();
5984
5985 if (cc != 0)
5986 check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
5987
5988 btarget = ctx->pc + 4 + offset;
5989
5990 switch (op) {
5991 case OPC_BC1F:
5992 tcg_gen_shri_i32(t0, fpu_fcr31, get_fp_bit(cc));
5993 tcg_gen_not_i32(t0, t0);
5994 tcg_gen_andi_i32(t0, t0, 1);
5995 tcg_gen_extu_i32_tl(bcond, t0);
5996 opn = "bc1f";
5997 goto not_likely;
5998 case OPC_BC1FL:
5999 tcg_gen_shri_i32(t0, fpu_fcr31, get_fp_bit(cc));
6000 tcg_gen_not_i32(t0, t0);
6001 tcg_gen_andi_i32(t0, t0, 1);
6002 tcg_gen_extu_i32_tl(bcond, t0);
6003 opn = "bc1fl";
6004 goto likely;
6005 case OPC_BC1T:
6006 tcg_gen_shri_i32(t0, fpu_fcr31, get_fp_bit(cc));
6007 tcg_gen_andi_i32(t0, t0, 1);
6008 tcg_gen_extu_i32_tl(bcond, t0);
6009 opn = "bc1t";
6010 goto not_likely;
6011 case OPC_BC1TL:
6012 tcg_gen_shri_i32(t0, fpu_fcr31, get_fp_bit(cc));
6013 tcg_gen_andi_i32(t0, t0, 1);
6014 tcg_gen_extu_i32_tl(bcond, t0);
6015 opn = "bc1tl";
6016 likely:
6017 ctx->hflags |= MIPS_HFLAG_BL;
6018 break;
6019 case OPC_BC1FANY2:
6020 {
6021 TCGv_i32 t1 = tcg_temp_new_i32();
6022 tcg_gen_shri_i32(t0, fpu_fcr31, get_fp_bit(cc));
6023 tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+1));
6024 tcg_gen_nor_i32(t0, t0, t1);
6025 tcg_temp_free_i32(t1);
6026 tcg_gen_andi_i32(t0, t0, 1);
6027 tcg_gen_extu_i32_tl(bcond, t0);
6028 }
6029 opn = "bc1any2f";
6030 goto not_likely;
6031 case OPC_BC1TANY2:
6032 {
6033 TCGv_i32 t1 = tcg_temp_new_i32();
6034 tcg_gen_shri_i32(t0, fpu_fcr31, get_fp_bit(cc));
6035 tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+1));
6036 tcg_gen_or_i32(t0, t0, t1);
6037 tcg_temp_free_i32(t1);
6038 tcg_gen_andi_i32(t0, t0, 1);
6039 tcg_gen_extu_i32_tl(bcond, t0);
6040 }
6041 opn = "bc1any2t";
6042 goto not_likely;
6043 case OPC_BC1FANY4:
6044 {
6045 TCGv_i32 t1 = tcg_temp_new_i32();
6046 tcg_gen_shri_i32(t0, fpu_fcr31, get_fp_bit(cc));
6047 tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+1));
6048 tcg_gen_or_i32(t0, t0, t1);
6049 tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+2));
6050 tcg_gen_or_i32(t0, t0, t1);
6051 tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+3));
6052 tcg_gen_nor_i32(t0, t0, t1);
6053 tcg_temp_free_i32(t1);
6054 tcg_gen_andi_i32(t0, t0, 1);
6055 tcg_gen_extu_i32_tl(bcond, t0);
6056 }
6057 opn = "bc1any4f";
6058 goto not_likely;
6059 case OPC_BC1TANY4:
6060 {
6061 TCGv_i32 t1 = tcg_temp_new_i32();
6062 tcg_gen_shri_i32(t0, fpu_fcr31, get_fp_bit(cc));
6063 tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+1));
6064 tcg_gen_or_i32(t0, t0, t1);
6065 tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+2));
6066 tcg_gen_or_i32(t0, t0, t1);
6067 tcg_gen_shri_i32(t1, fpu_fcr31, get_fp_bit(cc+3));
6068 tcg_gen_or_i32(t0, t0, t1);
6069 tcg_temp_free_i32(t1);
6070 tcg_gen_andi_i32(t0, t0, 1);
6071 tcg_gen_extu_i32_tl(bcond, t0);
6072 }
6073 opn = "bc1any4t";
6074 not_likely:
6075 ctx->hflags |= MIPS_HFLAG_BC;
6076 break;
6077 default:
6078 MIPS_INVAL(opn);
6079 generate_exception (ctx, EXCP_RI);
6080 goto out;
6081 }
6082 (void)opn; /* avoid a compiler warning */
6083 MIPS_DEBUG("%s: cond %02x target " TARGET_FMT_lx, opn,
6084 ctx->hflags, btarget);
6085 ctx->btarget = btarget;
6086
6087 out:
6088 tcg_temp_free_i32(t0);
6089 }
6090
6091 /* Coprocessor 1 (FPU) */
6092
6093 #define FOP(func, fmt) (((fmt) << 21) | (func))
6094
6095 enum fopcode {
6096 OPC_ADD_S = FOP(0, FMT_S),
6097 OPC_SUB_S = FOP(1, FMT_S),
6098 OPC_MUL_S = FOP(2, FMT_S),
6099 OPC_DIV_S = FOP(3, FMT_S),
6100 OPC_SQRT_S = FOP(4, FMT_S),
6101 OPC_ABS_S = FOP(5, FMT_S),
6102 OPC_MOV_S = FOP(6, FMT_S),
6103 OPC_NEG_S = FOP(7, FMT_S),
6104 OPC_ROUND_L_S = FOP(8, FMT_S),
6105 OPC_TRUNC_L_S = FOP(9, FMT_S),
6106 OPC_CEIL_L_S = FOP(10, FMT_S),
6107 OPC_FLOOR_L_S = FOP(11, FMT_S),
6108 OPC_ROUND_W_S = FOP(12, FMT_S),
6109 OPC_TRUNC_W_S = FOP(13, FMT_S),
6110 OPC_CEIL_W_S = FOP(14, FMT_S),
6111 OPC_FLOOR_W_S = FOP(15, FMT_S),
6112 OPC_MOVCF_S = FOP(17, FMT_S),
6113 OPC_MOVZ_S = FOP(18, FMT_S),
6114 OPC_MOVN_S = FOP(19, FMT_S),
6115 OPC_RECIP_S = FOP(21, FMT_S),
6116 OPC_RSQRT_S = FOP(22, FMT_S),
6117 OPC_RECIP2_S = FOP(28, FMT_S),
6118 OPC_RECIP1_S = FOP(29, FMT_S),
6119 OPC_RSQRT1_S = FOP(30, FMT_S),
6120 OPC_RSQRT2_S = FOP(31, FMT_S),
6121 OPC_CVT_D_S = FOP(33, FMT_S),
6122 OPC_CVT_W_S = FOP(36, FMT_S),
6123 OPC_CVT_L_S = FOP(37, FMT_S),
6124 OPC_CVT_PS_S = FOP(38, FMT_S),
6125 OPC_CMP_F_S = FOP (48, FMT_S),
6126 OPC_CMP_UN_S = FOP (49, FMT_S),
6127 OPC_CMP_EQ_S = FOP (50, FMT_S),
6128 OPC_CMP_UEQ_S = FOP (51, FMT_S),
6129 OPC_CMP_OLT_S = FOP (52, FMT_S),
6130 OPC_CMP_ULT_S = FOP (53, FMT_S),
6131 OPC_CMP_OLE_S = FOP (54, FMT_S),
6132 OPC_CMP_ULE_S = FOP (55, FMT_S),
6133 OPC_CMP_SF_S = FOP (56, FMT_S),
6134 OPC_CMP_NGLE_S = FOP (57, FMT_S),
6135 OPC_CMP_SEQ_S = FOP (58, FMT_S),
6136 OPC_CMP_NGL_S = FOP (59, FMT_S),
6137 OPC_CMP_LT_S = FOP (60, FMT_S),
6138 OPC_CMP_NGE_S = FOP (61, FMT_S),
6139 OPC_CMP_LE_S = FOP (62, FMT_S),
6140 OPC_CMP_NGT_S = FOP (63, FMT_S),
6141
6142 OPC_ADD_D = FOP(0, FMT_D),
6143 OPC_SUB_D = FOP(1, FMT_D),
6144 OPC_MUL_D = FOP(2, FMT_D),
6145 OPC_DIV_D = FOP(3, FMT_D),
6146 OPC_SQRT_D = FOP(4, FMT_D),
6147 OPC_ABS_D = FOP(5, FMT_D),
6148 OPC_MOV_D = FOP(6, FMT_D),
6149 OPC_NEG_D = FOP(7, FMT_D),
6150 OPC_ROUND_L_D = FOP(8, FMT_D),
6151 OPC_TRUNC_L_D = FOP(9, FMT_D),
6152 OPC_CEIL_L_D = FOP(10, FMT_D),
6153 OPC_FLOOR_L_D = FOP(11, FMT_D),
6154 OPC_ROUND_W_D = FOP(12, FMT_D),
6155 OPC_TRUNC_W_D = FOP(13, FMT_D),
6156 OPC_CEIL_W_D = FOP(14, FMT_D),
6157 OPC_FLOOR_W_D = FOP(15, FMT_D),
6158 OPC_MOVCF_D = FOP(17, FMT_D),
6159 OPC_MOVZ_D = FOP(18, FMT_D),
6160 OPC_MOVN_D = FOP(19, FMT_D),
6161 OPC_RECIP_D = FOP(21, FMT_D),
6162 OPC_RSQRT_D = FOP(22, FMT_D),
6163 OPC_RECIP2_D = FOP(28, FMT_D),
6164 OPC_RECIP1_D = FOP(29, FMT_D),
6165 OPC_RSQRT1_D = FOP(30, FMT_D),
6166 OPC_RSQRT2_D = FOP(31, FMT_D),
6167 OPC_CVT_S_D = FOP(32, FMT_D),
6168 OPC_CVT_W_D = FOP(36, FMT_D),
6169 OPC_CVT_L_D = FOP(37, FMT_D),
6170 OPC_CMP_F_D = FOP (48, FMT_D),
6171 OPC_CMP_UN_D = FOP (49, FMT_D),
6172 OPC_CMP_EQ_D = FOP (50, FMT_D),
6173 OPC_CMP_UEQ_D = FOP (51, FMT_D),
6174 OPC_CMP_OLT_D = FOP (52, FMT_D),
6175 OPC_CMP_ULT_D = FOP (53, FMT_D),
6176 OPC_CMP_OLE_D = FOP (54, FMT_D),
6177 OPC_CMP_ULE_D = FOP (55, FMT_D),
6178 OPC_CMP_SF_D = FOP (56, FMT_D),
6179 OPC_CMP_NGLE_D = FOP (57, FMT_D),
6180 OPC_CMP_SEQ_D = FOP (58, FMT_D),
6181 OPC_CMP_NGL_D = FOP (59, FMT_D),
6182 OPC_CMP_LT_D = FOP (60, FMT_D),
6183 OPC_CMP_NGE_D = FOP (61, FMT_D),
6184 OPC_CMP_LE_D = FOP (62, FMT_D),
6185 OPC_CMP_NGT_D = FOP (63, FMT_D),
6186
6187 OPC_CVT_S_W = FOP(32, FMT_W),
6188 OPC_CVT_D_W = FOP(33, FMT_W),
6189 OPC_CVT_S_L = FOP(32, FMT_L),
6190 OPC_CVT_D_L = FOP(33, FMT_L),
6191 OPC_CVT_PS_PW = FOP(38, FMT_W),
6192
6193 OPC_ADD_PS = FOP(0, FMT_PS),
6194 OPC_SUB_PS = FOP(1, FMT_PS),
6195 OPC_MUL_PS = FOP(2, FMT_PS),
6196 OPC_DIV_PS = FOP(3, FMT_PS),
6197 OPC_ABS_PS = FOP(5, FMT_PS),
6198 OPC_MOV_PS = FOP(6, FMT_PS),
6199 OPC_NEG_PS = FOP(7, FMT_PS),
6200 OPC_MOVCF_PS = FOP(17, FMT_PS),
6201 OPC_MOVZ_PS = FOP(18, FMT_PS),
6202 OPC_MOVN_PS = FOP(19, FMT_PS),
6203 OPC_ADDR_PS = FOP(24, FMT_PS),
6204 OPC_MULR_PS = FOP(26, FMT_PS),
6205 OPC_RECIP2_PS = FOP(28, FMT_PS),
6206 OPC_RECIP1_PS = FOP(29, FMT_PS),
6207 OPC_RSQRT1_PS = FOP(30, FMT_PS),
6208 OPC_RSQRT2_PS = FOP(31, FMT_PS),
6209
6210 OPC_CVT_S_PU = FOP(32, FMT_PS),
6211 OPC_CVT_PW_PS = FOP(36, FMT_PS),
6212 OPC_CVT_S_PL = FOP(40, FMT_PS),
6213 OPC_PLL_PS = FOP(44, FMT_PS),
6214 OPC_PLU_PS = FOP(45, FMT_PS),
6215 OPC_PUL_PS = FOP(46, FMT_PS),
6216 OPC_PUU_PS = FOP(47, FMT_PS),
6217 OPC_CMP_F_PS = FOP (48, FMT_PS),
6218 OPC_CMP_UN_PS = FOP (49, FMT_PS),
6219 OPC_CMP_EQ_PS = FOP (50, FMT_PS),
6220 OPC_CMP_UEQ_PS = FOP (51, FMT_PS),
6221 OPC_CMP_OLT_PS = FOP (52, FMT_PS),
6222 OPC_CMP_ULT_PS = FOP (53, FMT_PS),
6223 OPC_CMP_OLE_PS = FOP (54, FMT_PS),
6224 OPC_CMP_ULE_PS = FOP (55, FMT_PS),
6225 OPC_CMP_SF_PS = FOP (56, FMT_PS),
6226 OPC_CMP_NGLE_PS = FOP (57, FMT_PS),
6227 OPC_CMP_SEQ_PS = FOP (58, FMT_PS),
6228 OPC_CMP_NGL_PS = FOP (59, FMT_PS),
6229 OPC_CMP_LT_PS = FOP (60, FMT_PS),
6230 OPC_CMP_NGE_PS = FOP (61, FMT_PS),
6231 OPC_CMP_LE_PS = FOP (62, FMT_PS),
6232 OPC_CMP_NGT_PS = FOP (63, FMT_PS),
6233 };
6234
6235 static void gen_cp1 (DisasContext *ctx, uint32_t opc, int rt, int fs)
6236 {
6237 const char *opn = "cp1 move";
6238 TCGv t0 = tcg_temp_new();
6239
6240 switch (opc) {
6241 case OPC_MFC1:
6242 {
6243 TCGv_i32 fp0 = tcg_temp_new_i32();
6244
6245 gen_load_fpr32(fp0, fs);
6246 tcg_gen_ext_i32_tl(t0, fp0);
6247 tcg_temp_free_i32(fp0);
6248 }
6249 gen_store_gpr(t0, rt);
6250 opn = "mfc1";
6251 break;
6252 case OPC_MTC1:
6253 gen_load_gpr(t0, rt);
6254 {
6255 TCGv_i32 fp0 = tcg_temp_new_i32();
6256
6257 tcg_gen_trunc_tl_i32(fp0, t0);
6258 gen_store_fpr32(fp0, fs);
6259 tcg_temp_free_i32(fp0);
6260 }
6261 opn = "mtc1";
6262 break;
6263 case OPC_CFC1:
6264 gen_helper_1i(cfc1, t0, fs);
6265 gen_store_gpr(t0, rt);
6266 opn = "cfc1";
6267 break;
6268 case OPC_CTC1:
6269 gen_load_gpr(t0, rt);
6270 gen_helper_1i(ctc1, t0, fs);
6271 opn = "ctc1";
6272 break;
6273 #if defined(TARGET_MIPS64)
6274 case OPC_DMFC1:
6275 gen_load_fpr64(ctx, t0, fs);
6276 gen_store_gpr(t0, rt);
6277 opn = "dmfc1";
6278 break;
6279 case OPC_DMTC1:
6280 gen_load_gpr(t0, rt);
6281 gen_store_fpr64(ctx, t0, fs);
6282 opn = "dmtc1";
6283 break;
6284 #endif
6285 case OPC_MFHC1:
6286 {
6287 TCGv_i32 fp0 = tcg_temp_new_i32();
6288
6289 gen_load_fpr32h(fp0, fs);
6290 tcg_gen_ext_i32_tl(t0, fp0);
6291 tcg_temp_free_i32(fp0);
6292 }
6293 gen_store_gpr(t0, rt);
6294 opn = "mfhc1";
6295 break;
6296 case OPC_MTHC1:
6297 gen_load_gpr(t0, rt);
6298 {
6299 TCGv_i32 fp0 = tcg_temp_new_i32();
6300
6301 tcg_gen_trunc_tl_i32(fp0, t0);
6302 gen_store_fpr32h(fp0, fs);
6303 tcg_temp_free_i32(fp0);
6304 }
6305 opn = "mthc1";
6306 break;
6307 default:
6308 MIPS_INVAL(opn);
6309 generate_exception (ctx, EXCP_RI);
6310 goto out;
6311 }
6312 (void)opn; /* avoid a compiler warning */
6313 MIPS_DEBUG("%s %s %s", opn, regnames[rt], fregnames[fs]);
6314
6315 out:
6316 tcg_temp_free(t0);
6317 }
6318
6319 static void gen_movci (DisasContext *ctx, int rd, int rs, int cc, int tf)
6320 {
6321 int l1;
6322 TCGCond cond;
6323 TCGv_i32 t0;
6324
6325 if (rd == 0) {
6326 /* Treat as NOP. */
6327 return;
6328 }
6329
6330 if (tf)
6331 cond = TCG_COND_EQ;
6332 else
6333 cond = TCG_COND_NE;
6334
6335 l1 = gen_new_label();
6336 t0 = tcg_temp_new_i32();
6337 tcg_gen_andi_i32(t0, fpu_fcr31, 1 << get_fp_bit(cc));
6338 tcg_gen_brcondi_i32(cond, t0, 0, l1);
6339 tcg_temp_free_i32(t0);
6340 if (rs == 0) {
6341 tcg_gen_movi_tl(cpu_gpr[rd], 0);
6342 } else {
6343 tcg_gen_mov_tl(cpu_gpr[rd], cpu_gpr[rs]);
6344 }
6345 gen_set_label(l1);
6346 }
6347
6348 static inline void gen_movcf_s (int fs, int fd, int cc, int tf)
6349 {
6350 int cond;
6351 TCGv_i32 t0 = tcg_temp_new_i32();
6352 int l1 = gen_new_label();
6353
6354 if (tf)
6355 cond = TCG_COND_EQ;
6356 else
6357 cond = TCG_COND_NE;
6358
6359 tcg_gen_andi_i32(t0, fpu_fcr31, 1 << get_fp_bit(cc));
6360 tcg_gen_brcondi_i32(cond, t0, 0, l1);
6361 gen_load_fpr32(t0, fs);
6362 gen_store_fpr32(t0, fd);
6363 gen_set_label(l1);
6364 tcg_temp_free_i32(t0);
6365 }
6366
6367 static inline void gen_movcf_d (DisasContext *ctx, int fs, int fd, int cc, int tf)
6368 {
6369 int cond;
6370 TCGv_i32 t0 = tcg_temp_new_i32();
6371 TCGv_i64 fp0;
6372 int l1 = gen_new_label();
6373
6374 if (tf)
6375 cond = TCG_COND_EQ;
6376 else
6377 cond = TCG_COND_NE;
6378
6379 tcg_gen_andi_i32(t0, fpu_fcr31, 1 << get_fp_bit(cc));
6380 tcg_gen_brcondi_i32(cond, t0, 0, l1);
6381 tcg_temp_free_i32(t0);
6382 fp0 = tcg_temp_new_i64();
6383 gen_load_fpr64(ctx, fp0, fs);
6384 gen_store_fpr64(ctx, fp0, fd);
6385 tcg_temp_free_i64(fp0);
6386 gen_set_label(l1);
6387 }
6388
6389 static inline void gen_movcf_ps (int fs, int fd, int cc, int tf)
6390 {
6391 int cond;
6392 TCGv_i32 t0 = tcg_temp_new_i32();
6393 int l1 = gen_new_label();
6394 int l2 = gen_new_label();
6395
6396 if (tf)
6397 cond = TCG_COND_EQ;
6398 else
6399 cond = TCG_COND_NE;
6400
6401 tcg_gen_andi_i32(t0, fpu_fcr31, 1 << get_fp_bit(cc));
6402 tcg_gen_brcondi_i32(cond, t0, 0, l1);
6403 gen_load_fpr32(t0, fs);
6404 gen_store_fpr32(t0, fd);
6405 gen_set_label(l1);
6406
6407 tcg_gen_andi_i32(t0, fpu_fcr31, 1 << get_fp_bit(cc+1));
6408 tcg_gen_brcondi_i32(cond, t0, 0, l2);
6409 gen_load_fpr32h(t0, fs);
6410 gen_store_fpr32h(t0, fd);
6411 tcg_temp_free_i32(t0);
6412 gen_set_label(l2);
6413 }
6414
6415
6416 static void gen_farith (DisasContext *ctx, enum fopcode op1,
6417 int ft, int fs, int fd, int cc)
6418 {
6419 const char *opn = "farith";
6420 const char *condnames[] = {
6421 "c.f",
6422 "c.un",
6423 "c.eq",
6424 "c.ueq",
6425 "c.olt",
6426 "c.ult",
6427 "c.ole",
6428 "c.ule",
6429 "c.sf",
6430 "c.ngle",
6431 "c.seq",
6432 "c.ngl",
6433 "c.lt",
6434 "c.nge",
6435 "c.le",
6436 "c.ngt",
6437 };
6438 const char *condnames_abs[] = {
6439 "cabs.f",
6440 "cabs.un",
6441 "cabs.eq",
6442 "cabs.ueq",
6443 "cabs.olt",
6444 "cabs.ult",
6445 "cabs.ole",
6446 "cabs.ule",
6447 "cabs.sf",
6448 "cabs.ngle",
6449 "cabs.seq",
6450 "cabs.ngl",
6451 "cabs.lt",
6452 "cabs.nge",
6453 "cabs.le",
6454 "cabs.ngt",
6455 };
6456 enum { BINOP, CMPOP, OTHEROP } optype = OTHEROP;
6457 uint32_t func = ctx->opcode & 0x3f;
6458
6459 switch (op1) {
6460 case OPC_ADD_S:
6461 {
6462 TCGv_i32 fp0 = tcg_temp_new_i32();
6463 TCGv_i32 fp1 = tcg_temp_new_i32();
6464
6465 gen_load_fpr32(fp0, fs);
6466 gen_load_fpr32(fp1, ft);
6467 gen_helper_float_add_s(fp0, fp0, fp1);
6468 tcg_temp_free_i32(fp1);
6469 gen_store_fpr32(fp0, fd);
6470 tcg_temp_free_i32(fp0);
6471 }
6472 opn = "add.s";
6473 optype = BINOP;
6474 break;
6475 case OPC_SUB_S:
6476 {
6477 TCGv_i32 fp0 = tcg_temp_new_i32();
6478 TCGv_i32 fp1 = tcg_temp_new_i32();
6479
6480 gen_load_fpr32(fp0, fs);
6481 gen_load_fpr32(fp1, ft);
6482 gen_helper_float_sub_s(fp0, fp0, fp1);
6483 tcg_temp_free_i32(fp1);
6484 gen_store_fpr32(fp0, fd);
6485 tcg_temp_free_i32(fp0);
6486 }
6487 opn = "sub.s";
6488 optype = BINOP;
6489 break;
6490 case OPC_MUL_S:
6491 {
6492 TCGv_i32 fp0 = tcg_temp_new_i32();
6493 TCGv_i32 fp1 = tcg_temp_new_i32();
6494
6495 gen_load_fpr32(fp0, fs);
6496 gen_load_fpr32(fp1, ft);
6497 gen_helper_float_mul_s(fp0, fp0, fp1);
6498 tcg_temp_free_i32(fp1);
6499 gen_store_fpr32(fp0, fd);
6500 tcg_temp_free_i32(fp0);
6501 }
6502 opn = "mul.s";
6503 optype = BINOP;
6504 break;
6505 case OPC_DIV_S:
6506 {
6507 TCGv_i32 fp0 = tcg_temp_new_i32();
6508 TCGv_i32 fp1 = tcg_temp_new_i32();
6509
6510 gen_load_fpr32(fp0, fs);
6511 gen_load_fpr32(fp1, ft);
6512 gen_helper_float_div_s(fp0, fp0, fp1);
6513 tcg_temp_free_i32(fp1);
6514 gen_store_fpr32(fp0, fd);
6515 tcg_temp_free_i32(fp0);
6516 }
6517 opn = "div.s";
6518 optype = BINOP;
6519 break;
6520 case OPC_SQRT_S:
6521 {
6522 TCGv_i32 fp0 = tcg_temp_new_i32();
6523
6524 gen_load_fpr32(fp0, fs);
6525 gen_helper_float_sqrt_s(fp0, fp0);
6526 gen_store_fpr32(fp0, fd);
6527 tcg_temp_free_i32(fp0);
6528 }
6529 opn = "sqrt.s";
6530 break;
6531 case OPC_ABS_S:
6532 {
6533 TCGv_i32 fp0 = tcg_temp_new_i32();
6534
6535 gen_load_fpr32(fp0, fs);
6536 gen_helper_float_abs_s(fp0, fp0);
6537 gen_store_fpr32(fp0, fd);
6538 tcg_temp_free_i32(fp0);
6539 }
6540 opn = "abs.s";
6541 break;
6542 case OPC_MOV_S:
6543 {
6544 TCGv_i32 fp0 = tcg_temp_new_i32();
6545
6546 gen_load_fpr32(fp0, fs);
6547 gen_store_fpr32(fp0, fd);
6548 tcg_temp_free_i32(fp0);
6549 }
6550 opn = "mov.s";
6551 break;
6552 case OPC_NEG_S:
6553 {
6554 TCGv_i32 fp0 = tcg_temp_new_i32();
6555
6556 gen_load_fpr32(fp0, fs);
6557 gen_helper_float_chs_s(fp0, fp0);
6558 gen_store_fpr32(fp0, fd);
6559 tcg_temp_free_i32(fp0);
6560 }
6561 opn = "neg.s";
6562 break;
6563 case OPC_ROUND_L_S:
6564 check_cp1_64bitmode(ctx);
6565 {
6566 TCGv_i32 fp32 = tcg_temp_new_i32();
6567 TCGv_i64 fp64 = tcg_temp_new_i64();
6568
6569 gen_load_fpr32(fp32, fs);
6570 gen_helper_float_roundl_s(fp64, fp32);
6571 tcg_temp_free_i32(fp32);
6572 gen_store_fpr64(ctx, fp64, fd);
6573 tcg_temp_free_i64(fp64);
6574 }
6575 opn = "round.l.s";
6576 break;
6577 case OPC_TRUNC_L_S:
6578 check_cp1_64bitmode(ctx);
6579 {
6580 TCGv_i32 fp32 = tcg_temp_new_i32();
6581 TCGv_i64 fp64 = tcg_temp_new_i64();
6582
6583 gen_load_fpr32(fp32, fs);
6584 gen_helper_float_truncl_s(fp64, fp32);
6585 tcg_temp_free_i32(fp32);
6586 gen_store_fpr64(ctx, fp64, fd);
6587 tcg_temp_free_i64(fp64);
6588 }
6589 opn = "trunc.l.s";
6590 break;
6591 case OPC_CEIL_L_S:
6592 check_cp1_64bitmode(ctx);
6593 {
6594 TCGv_i32 fp32 = tcg_temp_new_i32();
6595 TCGv_i64 fp64 = tcg_temp_new_i64();
6596
6597 gen_load_fpr32(fp32, fs);
6598 gen_helper_float_ceill_s(fp64, fp32);
6599 tcg_temp_free_i32(fp32);
6600 gen_store_fpr64(ctx, fp64, fd);
6601 tcg_temp_free_i64(fp64);
6602 }
6603 opn = "ceil.l.s";
6604 break;
6605 case OPC_FLOOR_L_S:
6606 check_cp1_64bitmode(ctx);
6607 {
6608 TCGv_i32 fp32 = tcg_temp_new_i32();
6609 TCGv_i64 fp64 = tcg_temp_new_i64();
6610
6611 gen_load_fpr32(fp32, fs);
6612 gen_helper_float_floorl_s(fp64, fp32);
6613 tcg_temp_free_i32(fp32);
6614 gen_store_fpr64(ctx, fp64, fd);
6615 tcg_temp_free_i64(fp64);
6616 }
6617 opn = "floor.l.s";
6618 break;
6619 case OPC_ROUND_W_S:
6620 {
6621 TCGv_i32 fp0 = tcg_temp_new_i32();
6622
6623 gen_load_fpr32(fp0, fs);
6624 gen_helper_float_roundw_s(fp0, fp0);
6625 gen_store_fpr32(fp0, fd);
6626 tcg_temp_free_i32(fp0);
6627 }
6628 opn = "round.w.s";
6629 break;
6630 case OPC_TRUNC_W_S:
6631 {
6632 TCGv_i32 fp0 = tcg_temp_new_i32();
6633
6634 gen_load_fpr32(fp0, fs);
6635 gen_helper_float_truncw_s(fp0, fp0);
6636 gen_store_fpr32(fp0, fd);
6637 tcg_temp_free_i32(fp0);
6638 }
6639 opn = "trunc.w.s";
6640 break;
6641 case OPC_CEIL_W_S:
6642 {
6643 TCGv_i32 fp0 = tcg_temp_new_i32();
6644
6645 gen_load_fpr32(fp0, fs);
6646 gen_helper_float_ceilw_s(fp0, fp0);
6647 gen_store_fpr32(fp0, fd);
6648 tcg_temp_free_i32(fp0);
6649 }
6650 opn = "ceil.w.s";
6651 break;
6652 case OPC_FLOOR_W_S:
6653 {
6654 TCGv_i32 fp0 = tcg_temp_new_i32();
6655
6656 gen_load_fpr32(fp0, fs);
6657 gen_helper_float_floorw_s(fp0, fp0);
6658 gen_store_fpr32(fp0, fd);
6659 tcg_temp_free_i32(fp0);
6660 }
6661 opn = "floor.w.s";
6662 break;
6663 case OPC_MOVCF_S:
6664 gen_movcf_s(fs, fd, (ft >> 2) & 0x7, ft & 0x1);
6665 opn = "movcf.s";
6666 break;
6667 case OPC_MOVZ_S:
6668 {
6669 int l1 = gen_new_label();
6670 TCGv_i32 fp0;
6671
6672 if (ft != 0) {
6673 tcg_gen_brcondi_tl(TCG_COND_NE, cpu_gpr[ft], 0, l1);
6674 }
6675 fp0 = tcg_temp_new_i32();
6676 gen_load_fpr32(fp0, fs);
6677 gen_store_fpr32(fp0, fd);
6678 tcg_temp_free_i32(fp0);
6679 gen_set_label(l1);
6680 }
6681 opn = "movz.s";
6682 break;
6683 case OPC_MOVN_S:
6684 {
6685 int l1 = gen_new_label();
6686 TCGv_i32 fp0;
6687
6688 if (ft != 0) {
6689 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr[ft], 0, l1);
6690 fp0 = tcg_temp_new_i32();
6691 gen_load_fpr32(fp0, fs);
6692 gen_store_fpr32(fp0, fd);
6693 tcg_temp_free_i32(fp0);
6694 gen_set_label(l1);
6695 }
6696 }
6697 opn = "movn.s";
6698 break;
6699 case OPC_RECIP_S:
6700 check_cop1x(ctx);
6701 {
6702 TCGv_i32 fp0 = tcg_temp_new_i32();
6703
6704 gen_load_fpr32(fp0, fs);
6705 gen_helper_float_recip_s(fp0, fp0);
6706 gen_store_fpr32(fp0, fd);
6707 tcg_temp_free_i32(fp0);
6708 }
6709 opn = "recip.s";
6710 break;
6711 case OPC_RSQRT_S:
6712 check_cop1x(ctx);
6713 {
6714 TCGv_i32 fp0 = tcg_temp_new_i32();
6715
6716 gen_load_fpr32(fp0, fs);
6717 gen_helper_float_rsqrt_s(fp0, fp0);
6718 gen_store_fpr32(fp0, fd);
6719 tcg_temp_free_i32(fp0);
6720 }
6721 opn = "rsqrt.s";
6722 break;
6723 case OPC_RECIP2_S:
6724 check_cp1_64bitmode(ctx);
6725 {
6726 TCGv_i32 fp0 = tcg_temp_new_i32();
6727 TCGv_i32 fp1 = tcg_temp_new_i32();
6728
6729 gen_load_fpr32(fp0, fs);
6730 gen_load_fpr32(fp1, fd);
6731 gen_helper_float_recip2_s(fp0, fp0, fp1);
6732 tcg_temp_free_i32(fp1);
6733 gen_store_fpr32(fp0, fd);
6734 tcg_temp_free_i32(fp0);
6735 }
6736 opn = "recip2.s";
6737 break;
6738 case OPC_RECIP1_S:
6739 check_cp1_64bitmode(ctx);
6740 {
6741 TCGv_i32 fp0 = tcg_temp_new_i32();
6742
6743 gen_load_fpr32(fp0, fs);
6744 gen_helper_float_recip1_s(fp0, fp0);
6745 gen_store_fpr32(fp0, fd);
6746 tcg_temp_free_i32(fp0);
6747 }
6748 opn = "recip1.s";
6749 break;
6750 case OPC_RSQRT1_S:
6751 check_cp1_64bitmode(ctx);
6752 {
6753 TCGv_i32 fp0 = tcg_temp_new_i32();
6754
6755 gen_load_fpr32(fp0, fs);
6756 gen_helper_float_rsqrt1_s(fp0, fp0);
6757 gen_store_fpr32(fp0, fd);
6758 tcg_temp_free_i32(fp0);
6759 }
6760 opn = "rsqrt1.s";
6761 break;
6762 case OPC_RSQRT2_S:
6763 check_cp1_64bitmode(ctx);
6764 {
6765 TCGv_i32 fp0 = tcg_temp_new_i32();
6766 TCGv_i32 fp1 = tcg_temp_new_i32();
6767
6768 gen_load_fpr32(fp0, fs);
6769 gen_load_fpr32(fp1, ft);
6770 gen_helper_float_rsqrt2_s(fp0, fp0, fp1);
6771 tcg_temp_free_i32(fp1);
6772 gen_store_fpr32(fp0, fd);
6773 tcg_temp_free_i32(fp0);
6774 }
6775 opn = "rsqrt2.s";
6776 break;
6777 case OPC_CVT_D_S:
6778 check_cp1_registers(ctx, fd);
6779 {
6780 TCGv_i32 fp32 = tcg_temp_new_i32();
6781 TCGv_i64 fp64 = tcg_temp_new_i64();
6782
6783 gen_load_fpr32(fp32, fs);
6784 gen_helper_float_cvtd_s(fp64, fp32);
6785 tcg_temp_free_i32(fp32);
6786 gen_store_fpr64(ctx, fp64, fd);
6787 tcg_temp_free_i64(fp64);
6788 }
6789 opn = "cvt.d.s";
6790 break;
6791 case OPC_CVT_W_S:
6792 {
6793 TCGv_i32 fp0 = tcg_temp_new_i32();
6794
6795 gen_load_fpr32(fp0, fs);
6796 gen_helper_float_cvtw_s(fp0, fp0);
6797 gen_store_fpr32(fp0, fd);
6798 tcg_temp_free_i32(fp0);
6799 }
6800 opn = "cvt.w.s";
6801 break;
6802 case OPC_CVT_L_S:
6803 check_cp1_64bitmode(ctx);
6804 {
6805 TCGv_i32 fp32 = tcg_temp_new_i32();
6806 TCGv_i64 fp64 = tcg_temp_new_i64();
6807
6808 gen_load_fpr32(fp32, fs);
6809 gen_helper_float_cvtl_s(fp64, fp32);
6810 tcg_temp_free_i32(fp32);
6811 gen_store_fpr64(ctx, fp64, fd);
6812 tcg_temp_free_i64(fp64);
6813 }
6814 opn = "cvt.l.s";
6815 break;
6816 case OPC_CVT_PS_S:
6817 check_cp1_64bitmode(ctx);
6818 {
6819 TCGv_i64 fp64 = tcg_temp_new_i64();
6820 TCGv_i32 fp32_0 = tcg_temp_new_i32();
6821 TCGv_i32 fp32_1 = tcg_temp_new_i32();
6822
6823 gen_load_fpr32(fp32_0, fs);
6824 gen_load_fpr32(fp32_1, ft);
6825 tcg_gen_concat_i32_i64(fp64, fp32_0, fp32_1);
6826 tcg_temp_free_i32(fp32_1);
6827 tcg_temp_free_i32(fp32_0);
6828 gen_store_fpr64(ctx, fp64, fd);
6829 tcg_temp_free_i64(fp64);
6830 }
6831 opn = "cvt.ps.s";
6832 break;
6833 case OPC_CMP_F_S:
6834 case OPC_CMP_UN_S:
6835 case OPC_CMP_EQ_S:
6836 case OPC_CMP_UEQ_S:
6837 case OPC_CMP_OLT_S:
6838 case OPC_CMP_ULT_S:
6839 case OPC_CMP_OLE_S:
6840 case OPC_CMP_ULE_S:
6841 case OPC_CMP_SF_S:
6842 case OPC_CMP_NGLE_S:
6843 case OPC_CMP_SEQ_S:
6844 case OPC_CMP_NGL_S:
6845 case OPC_CMP_LT_S:
6846 case OPC_CMP_NGE_S:
6847 case OPC_CMP_LE_S:
6848 case OPC_CMP_NGT_S:
6849 if (ctx->opcode & (1 << 6)) {
6850 gen_cmpabs_s(ctx, func-48, ft, fs, cc);
6851 opn = condnames_abs[func-48];
6852 } else {
6853 gen_cmp_s(ctx, func-48, ft, fs, cc);
6854 opn = condnames[func-48];
6855 }
6856 break;
6857 case OPC_ADD_D:
6858 check_cp1_registers(ctx, fs | ft | fd);
6859 {
6860 TCGv_i64 fp0 = tcg_temp_new_i64();
6861 TCGv_i64 fp1 = tcg_temp_new_i64();
6862
6863 gen_load_fpr64(ctx, fp0, fs);
6864 gen_load_fpr64(ctx, fp1, ft);
6865 gen_helper_float_add_d(fp0, fp0, fp1);
6866 tcg_temp_free_i64(fp1);
6867 gen_store_fpr64(ctx, fp0, fd);
6868 tcg_temp_free_i64(fp0);
6869 }
6870 opn = "add.d";
6871 optype = BINOP;
6872 break;
6873 case OPC_SUB_D:
6874 check_cp1_registers(ctx, fs | ft | fd);
6875 {
6876 TCGv_i64 fp0 = tcg_temp_new_i64();
6877 TCGv_i64 fp1 = tcg_temp_new_i64();
6878
6879 gen_load_fpr64(ctx, fp0, fs);
6880 gen_load_fpr64(ctx, fp1, ft);
6881 gen_helper_float_sub_d(fp0, fp0, fp1);
6882 tcg_temp_free_i64(fp1);
6883 gen_store_fpr64(ctx, fp0, fd);
6884 tcg_temp_free_i64(fp0);
6885 }
6886 opn = "sub.d";
6887 optype = BINOP;
6888 break;
6889 case OPC_MUL_D:
6890 check_cp1_registers(ctx, fs | ft | fd);
6891 {
6892 TCGv_i64 fp0 = tcg_temp_new_i64();
6893 TCGv_i64 fp1 = tcg_temp_new_i64();
6894
6895 gen_load_fpr64(ctx, fp0, fs);
6896 gen_load_fpr64(ctx, fp1, ft);
6897 gen_helper_float_mul_d(fp0, fp0, fp1);
6898 tcg_temp_free_i64(fp1);
6899 gen_store_fpr64(ctx, fp0, fd);
6900 tcg_temp_free_i64(fp0);
6901 }
6902 opn = "mul.d";
6903 optype = BINOP;
6904 break;
6905 case OPC_DIV_D:
6906 check_cp1_registers(ctx, fs | ft | fd);
6907 {
6908 TCGv_i64 fp0 = tcg_temp_new_i64();
6909 TCGv_i64 fp1 = tcg_temp_new_i64();
6910
6911 gen_load_fpr64(ctx, fp0, fs);
6912 gen_load_fpr64(ctx, fp1, ft);
6913 gen_helper_float_div_d(fp0, fp0, fp1);
6914 tcg_temp_free_i64(fp1);
6915 gen_store_fpr64(ctx, fp0, fd);
6916 tcg_temp_free_i64(fp0);
6917 }
6918 opn = "div.d";
6919 optype = BINOP;
6920 break;
6921 case OPC_SQRT_D:
6922 check_cp1_registers(ctx, fs | fd);
6923 {
6924 TCGv_i64 fp0 = tcg_temp_new_i64();
6925
6926 gen_load_fpr64(ctx, fp0, fs);
6927 gen_helper_float_sqrt_d(fp0, fp0);
6928 gen_store_fpr64(ctx, fp0, fd);
6929 tcg_temp_free_i64(fp0);
6930 }
6931 opn = "sqrt.d";
6932 break;
6933 case OPC_ABS_D:
6934 check_cp1_registers(ctx, fs | fd);
6935 {
6936 TCGv_i64 fp0 = tcg_temp_new_i64();
6937
6938 gen_load_fpr64(ctx, fp0, fs);
6939 gen_helper_float_abs_d(fp0, fp0);
6940 gen_store_fpr64(ctx, fp0, fd);
6941 tcg_temp_free_i64(fp0);
6942 }
6943 opn = "abs.d";
6944 break;
6945 case OPC_MOV_D:
6946 check_cp1_registers(ctx, fs | fd);
6947 {
6948 TCGv_i64 fp0 = tcg_temp_new_i64();
6949
6950 gen_load_fpr64(ctx, fp0, fs);
6951 gen_store_fpr64(ctx, fp0, fd);
6952 tcg_temp_free_i64(fp0);
6953 }
6954 opn = "mov.d";
6955 break;
6956 case OPC_NEG_D:
6957 check_cp1_registers(ctx, fs | fd);
6958 {
6959 TCGv_i64 fp0 = tcg_temp_new_i64();
6960
6961 gen_load_fpr64(ctx, fp0, fs);
6962 gen_helper_float_chs_d(fp0, fp0);
6963 gen_store_fpr64(ctx, fp0, fd);
6964 tcg_temp_free_i64(fp0);
6965 }
6966 opn = "neg.d";
6967 break;
6968 case OPC_ROUND_L_D:
6969 check_cp1_64bitmode(ctx);
6970 {
6971 TCGv_i64 fp0 = tcg_temp_new_i64();
6972
6973 gen_load_fpr64(ctx, fp0, fs);
6974 gen_helper_float_roundl_d(fp0, fp0);
6975 gen_store_fpr64(ctx, fp0, fd);
6976 tcg_temp_free_i64(fp0);
6977 }
6978 opn = "round.l.d";
6979 break;
6980 case OPC_TRUNC_L_D:
6981 check_cp1_64bitmode(ctx);
6982 {
6983 TCGv_i64 fp0 = tcg_temp_new_i64();
6984
6985 gen_load_fpr64(ctx, fp0, fs);
6986 gen_helper_float_truncl_d(fp0, fp0);
6987 gen_store_fpr64(ctx, fp0, fd);
6988 tcg_temp_free_i64(fp0);
6989 }
6990 opn = "trunc.l.d";
6991 break;
6992 case OPC_CEIL_L_D:
6993 check_cp1_64bitmode(ctx);
6994 {
6995 TCGv_i64 fp0 = tcg_temp_new_i64();
6996
6997 gen_load_fpr64(ctx, fp0, fs);
6998 gen_helper_float_ceill_d(fp0, fp0);
6999 gen_store_fpr64(ctx, fp0, fd);
7000 tcg_temp_free_i64(fp0);
7001 }
7002 opn = "ceil.l.d";
7003 break;
7004 case OPC_FLOOR_L_D:
7005 check_cp1_64bitmode(ctx);
7006 {
7007 TCGv_i64 fp0 = tcg_temp_new_i64();
7008
7009 gen_load_fpr64(ctx, fp0, fs);
7010 gen_helper_float_floorl_d(fp0, fp0);
7011 gen_store_fpr64(ctx, fp0, fd);
7012 tcg_temp_free_i64(fp0);
7013 }
7014 opn = "floor.l.d";
7015 break;
7016 case OPC_ROUND_W_D:
7017 check_cp1_registers(ctx, fs);
7018 {
7019 TCGv_i32 fp32 = tcg_temp_new_i32();
7020 TCGv_i64 fp64 = tcg_temp_new_i64();
7021
7022 gen_load_fpr64(ctx, fp64, fs);
7023 gen_helper_float_roundw_d(fp32, fp64);
7024 tcg_temp_free_i64(fp64);
7025 gen_store_fpr32(fp32, fd);
7026 tcg_temp_free_i32(fp32);
7027 }
7028 opn = "round.w.d";
7029 break;
7030 case OPC_TRUNC_W_D:
7031 check_cp1_registers(ctx, fs);
7032 {
7033 TCGv_i32 fp32 = tcg_temp_new_i32();
7034 TCGv_i64 fp64 = tcg_temp_new_i64();
7035
7036 gen_load_fpr64(ctx, fp64, fs);
7037 gen_helper_float_truncw_d(fp32, fp64);
7038 tcg_temp_free_i64(fp64);
7039 gen_store_fpr32(fp32, fd);
7040 tcg_temp_free_i32(fp32);
7041 }
7042 opn = "trunc.w.d";
7043 break;
7044 case OPC_CEIL_W_D:
7045 check_cp1_registers(ctx, fs);
7046 {
7047 TCGv_i32 fp32 = tcg_temp_new_i32();
7048 TCGv_i64 fp64 = tcg_temp_new_i64();
7049
7050 gen_load_fpr64(ctx, fp64, fs);
7051 gen_helper_float_ceilw_d(fp32, fp64);
7052 tcg_temp_free_i64(fp64);
7053 gen_store_fpr32(fp32, fd);
7054 tcg_temp_free_i32(fp32);
7055 }
7056 opn = "ceil.w.d";
7057 break;
7058 case OPC_FLOOR_W_D:
7059 check_cp1_registers(ctx, fs);
7060 {
7061 TCGv_i32 fp32 = tcg_temp_new_i32();
7062 TCGv_i64 fp64 = tcg_temp_new_i64();
7063
7064 gen_load_fpr64(ctx, fp64, fs);
7065 gen_helper_float_floorw_d(fp32, fp64);
7066 tcg_temp_free_i64(fp64);
7067 gen_store_fpr32(fp32, fd);
7068 tcg_temp_free_i32(fp32);
7069 }
7070 opn = "floor.w.d";
7071 break;
7072 case OPC_MOVCF_D:
7073 gen_movcf_d(ctx, fs, fd, (ft >> 2) & 0x7, ft & 0x1);
7074 opn = "movcf.d";
7075 break;
7076 case OPC_MOVZ_D:
7077 {
7078 int l1 = gen_new_label();
7079 TCGv_i64 fp0;
7080
7081 if (ft != 0) {
7082 tcg_gen_brcondi_tl(TCG_COND_NE, cpu_gpr[ft], 0, l1);
7083 }
7084 fp0 = tcg_temp_new_i64();
7085 gen_load_fpr64(ctx, fp0, fs);
7086 gen_store_fpr64(ctx, fp0, fd);
7087 tcg_temp_free_i64(fp0);
7088 gen_set_label(l1);
7089 }
7090 opn = "movz.d";
7091 break;
7092 case OPC_MOVN_D:
7093 {
7094 int l1 = gen_new_label();
7095 TCGv_i64 fp0;
7096
7097 if (ft != 0) {
7098 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr[ft], 0, l1);
7099 fp0 = tcg_temp_new_i64();
7100 gen_load_fpr64(ctx, fp0, fs);
7101 gen_store_fpr64(ctx, fp0, fd);
7102 tcg_temp_free_i64(fp0);
7103 gen_set_label(l1);
7104 }
7105 }
7106 opn = "movn.d";
7107 break;
7108 case OPC_RECIP_D:
7109 check_cp1_64bitmode(ctx);
7110 {
7111 TCGv_i64 fp0 = tcg_temp_new_i64();
7112
7113 gen_load_fpr64(ctx, fp0, fs);
7114 gen_helper_float_recip_d(fp0, fp0);
7115 gen_store_fpr64(ctx, fp0, fd);
7116 tcg_temp_free_i64(fp0);
7117 }
7118 opn = "recip.d";
7119 break;
7120 case OPC_RSQRT_D:
7121 check_cp1_64bitmode(ctx);
7122 {
7123 TCGv_i64 fp0 = tcg_temp_new_i64();
7124
7125 gen_load_fpr64(ctx, fp0, fs);
7126 gen_helper_float_rsqrt_d(fp0, fp0);
7127 gen_store_fpr64(ctx, fp0, fd);
7128 tcg_temp_free_i64(fp0);
7129 }
7130 opn = "rsqrt.d";
7131 break;
7132 case OPC_RECIP2_D:
7133 check_cp1_64bitmode(ctx);
7134 {
7135 TCGv_i64 fp0 = tcg_temp_new_i64();
7136 TCGv_i64 fp1 = tcg_temp_new_i64();
7137
7138 gen_load_fpr64(ctx, fp0, fs);
7139 gen_load_fpr64(ctx, fp1, ft);
7140 gen_helper_float_recip2_d(fp0, fp0, fp1);
7141 tcg_temp_free_i64(fp1);
7142 gen_store_fpr64(ctx, fp0, fd);
7143 tcg_temp_free_i64(fp0);
7144 }
7145 opn = "recip2.d";
7146 break;
7147 case OPC_RECIP1_D:
7148 check_cp1_64bitmode(ctx);
7149 {
7150 TCGv_i64 fp0 = tcg_temp_new_i64();
7151
7152 gen_load_fpr64(ctx, fp0, fs);
7153 gen_helper_float_recip1_d(fp0, fp0);
7154 gen_store_fpr64(ctx, fp0, fd);
7155 tcg_temp_free_i64(fp0);
7156 }
7157 opn = "recip1.d";
7158 break;
7159 case OPC_RSQRT1_D:
7160 check_cp1_64bitmode(ctx);
7161 {
7162 TCGv_i64 fp0 = tcg_temp_new_i64();
7163
7164 gen_load_fpr64(ctx, fp0, fs);
7165 gen_helper_float_rsqrt1_d(fp0, fp0);
7166 gen_store_fpr64(ctx, fp0, fd);
7167 tcg_temp_free_i64(fp0);
7168 }
7169 opn = "rsqrt1.d";
7170 break;
7171 case OPC_RSQRT2_D:
7172 check_cp1_64bitmode(ctx);
7173 {
7174 TCGv_i64 fp0 = tcg_temp_new_i64();
7175 TCGv_i64 fp1 = tcg_temp_new_i64();
7176
7177 gen_load_fpr64(ctx, fp0, fs);
7178 gen_load_fpr64(ctx, fp1, ft);
7179 gen_helper_float_rsqrt2_d(fp0, fp0, fp1);
7180 tcg_temp_free_i64(fp1);
7181 gen_store_fpr64(ctx, fp0, fd);
7182 tcg_temp_free_i64(fp0);
7183 }
7184 opn = "rsqrt2.d";
7185 break;
7186 case OPC_CMP_F_D:
7187 case OPC_CMP_UN_D:
7188 case OPC_CMP_EQ_D:
7189 case OPC_CMP_UEQ_D:
7190 case OPC_CMP_OLT_D:
7191 case OPC_CMP_ULT_D:
7192 case OPC_CMP_OLE_D:
7193 case OPC_CMP_ULE_D:
7194 case OPC_CMP_SF_D:
7195 case OPC_CMP_NGLE_D:
7196 case OPC_CMP_SEQ_D:
7197 case OPC_CMP_NGL_D:
7198 case OPC_CMP_LT_D:
7199 case OPC_CMP_NGE_D:
7200 case OPC_CMP_LE_D:
7201 case OPC_CMP_NGT_D:
7202 if (ctx->opcode & (1 << 6)) {
7203 gen_cmpabs_d(ctx, func-48, ft, fs, cc);
7204 opn = condnames_abs[func-48];
7205 } else {
7206 gen_cmp_d(ctx, func-48, ft, fs, cc);
7207 opn = condnames[func-48];
7208 }
7209 break;
7210 case OPC_CVT_S_D:
7211 check_cp1_registers(ctx, fs);
7212 {
7213 TCGv_i32 fp32 = tcg_temp_new_i32();
7214 TCGv_i64 fp64 = tcg_temp_new_i64();
7215
7216 gen_load_fpr64(ctx, fp64, fs);
7217 gen_helper_float_cvts_d(fp32, fp64);
7218 tcg_temp_free_i64(fp64);
7219 gen_store_fpr32(fp32, fd);
7220 tcg_temp_free_i32(fp32);
7221 }
7222 opn = "cvt.s.d";
7223 break;
7224 case OPC_CVT_W_D:
7225 check_cp1_registers(ctx, fs);
7226 {
7227 TCGv_i32 fp32 = tcg_temp_new_i32();
7228 TCGv_i64 fp64 = tcg_temp_new_i64();
7229
7230 gen_load_fpr64(ctx, fp64, fs);
7231 gen_helper_float_cvtw_d(fp32, fp64);
7232 tcg_temp_free_i64(fp64);
7233 gen_store_fpr32(fp32, fd);
7234 tcg_temp_free_i32(fp32);
7235 }
7236 opn = "cvt.w.d";
7237 break;
7238 case OPC_CVT_L_D:
7239 check_cp1_64bitmode(ctx);
7240 {
7241 TCGv_i64 fp0 = tcg_temp_new_i64();
7242
7243 gen_load_fpr64(ctx, fp0, fs);
7244 gen_helper_float_cvtl_d(fp0, fp0);
7245 gen_store_fpr64(ctx, fp0, fd);
7246 tcg_temp_free_i64(fp0);
7247 }
7248 opn = "cvt.l.d";
7249 break;
7250 case OPC_CVT_S_W:
7251 {
7252 TCGv_i32 fp0 = tcg_temp_new_i32();
7253
7254 gen_load_fpr32(fp0, fs);
7255 gen_helper_float_cvts_w(fp0, fp0);
7256 gen_store_fpr32(fp0, fd);
7257 tcg_temp_free_i32(fp0);
7258 }
7259 opn = "cvt.s.w";
7260 break;
7261 case OPC_CVT_D_W:
7262 check_cp1_registers(ctx, fd);
7263 {
7264 TCGv_i32 fp32 = tcg_temp_new_i32();
7265 TCGv_i64 fp64 = tcg_temp_new_i64();
7266
7267 gen_load_fpr32(fp32, fs);
7268 gen_helper_float_cvtd_w(fp64, fp32);
7269 tcg_temp_free_i32(fp32);
7270 gen_store_fpr64(ctx, fp64, fd);
7271 tcg_temp_free_i64(fp64);
7272 }
7273 opn = "cvt.d.w";
7274 break;
7275 case OPC_CVT_S_L:
7276 check_cp1_64bitmode(ctx);
7277 {
7278 TCGv_i32 fp32 = tcg_temp_new_i32();
7279 TCGv_i64 fp64 = tcg_temp_new_i64();
7280
7281 gen_load_fpr64(ctx, fp64, fs);
7282 gen_helper_float_cvts_l(fp32, fp64);
7283 tcg_temp_free_i64(fp64);
7284 gen_store_fpr32(fp32, fd);
7285 tcg_temp_free_i32(fp32);
7286 }
7287 opn = "cvt.s.l";
7288 break;
7289 case OPC_CVT_D_L:
7290 check_cp1_64bitmode(ctx);
7291 {
7292 TCGv_i64 fp0 = tcg_temp_new_i64();
7293
7294 gen_load_fpr64(ctx, fp0, fs);
7295 gen_helper_float_cvtd_l(fp0, fp0);
7296 gen_store_fpr64(ctx, fp0, fd);
7297 tcg_temp_free_i64(fp0);
7298 }
7299 opn = "cvt.d.l";
7300 break;
7301 case OPC_CVT_PS_PW:
7302 check_cp1_64bitmode(ctx);
7303 {
7304 TCGv_i64 fp0 = tcg_temp_new_i64();
7305
7306 gen_load_fpr64(ctx, fp0, fs);
7307 gen_helper_float_cvtps_pw(fp0, fp0);
7308 gen_store_fpr64(ctx, fp0, fd);
7309 tcg_temp_free_i64(fp0);
7310 }
7311 opn = "cvt.ps.pw";
7312 break;
7313 case OPC_ADD_PS:
7314 check_cp1_64bitmode(ctx);
7315 {
7316 TCGv_i64 fp0 = tcg_temp_new_i64();
7317 TCGv_i64 fp1 = tcg_temp_new_i64();
7318
7319 gen_load_fpr64(ctx, fp0, fs);
7320 gen_load_fpr64(ctx, fp1, ft);
7321 gen_helper_float_add_ps(fp0, fp0, fp1);
7322 tcg_temp_free_i64(fp1);
7323 gen_store_fpr64(ctx, fp0, fd);
7324 tcg_temp_free_i64(fp0);
7325 }
7326 opn = "add.ps";
7327 break;
7328 case OPC_SUB_PS:
7329 check_cp1_64bitmode(ctx);
7330 {
7331 TCGv_i64 fp0 = tcg_temp_new_i64();
7332 TCGv_i64 fp1 = tcg_temp_new_i64();
7333
7334 gen_load_fpr64(ctx, fp0, fs);
7335 gen_load_fpr64(ctx, fp1, ft);
7336 gen_helper_float_sub_ps(fp0, fp0, fp1);
7337 tcg_temp_free_i64(fp1);
7338 gen_store_fpr64(ctx, fp0, fd);
7339 tcg_temp_free_i64(fp0);
7340 }
7341 opn = "sub.ps";
7342 break;
7343 case OPC_MUL_PS:
7344 check_cp1_64bitmode(ctx);
7345 {
7346 TCGv_i64 fp0 = tcg_temp_new_i64();
7347 TCGv_i64 fp1 = tcg_temp_new_i64();
7348
7349 gen_load_fpr64(ctx, fp0, fs);
7350 gen_load_fpr64(ctx, fp1, ft);
7351 gen_helper_float_mul_ps(fp0, fp0, fp1);
7352 tcg_temp_free_i64(fp1);
7353 gen_store_fpr64(ctx, fp0, fd);
7354 tcg_temp_free_i64(fp0);
7355 }
7356 opn = "mul.ps";
7357 break;
7358 case OPC_ABS_PS:
7359 check_cp1_64bitmode(ctx);
7360 {
7361 TCGv_i64 fp0 = tcg_temp_new_i64();
7362
7363 gen_load_fpr64(ctx, fp0, fs);
7364 gen_helper_float_abs_ps(fp0, fp0);
7365 gen_store_fpr64(ctx, fp0, fd);
7366 tcg_temp_free_i64(fp0);
7367 }
7368 opn = "abs.ps";
7369 break;
7370 case OPC_MOV_PS:
7371 check_cp1_64bitmode(ctx);
7372 {
7373 TCGv_i64 fp0 = tcg_temp_new_i64();
7374
7375 gen_load_fpr64(ctx, fp0, fs);
7376 gen_store_fpr64(ctx, fp0, fd);
7377 tcg_temp_free_i64(fp0);
7378 }
7379 opn = "mov.ps";
7380 break;
7381 case OPC_NEG_PS:
7382 check_cp1_64bitmode(ctx);
7383 {
7384 TCGv_i64 fp0 = tcg_temp_new_i64();
7385
7386 gen_load_fpr64(ctx, fp0, fs);
7387 gen_helper_float_chs_ps(fp0, fp0);
7388 gen_store_fpr64(ctx, fp0, fd);
7389 tcg_temp_free_i64(fp0);
7390 }
7391 opn = "neg.ps";
7392 break;
7393 case OPC_MOVCF_PS:
7394 check_cp1_64bitmode(ctx);
7395 gen_movcf_ps(fs, fd, (ft >> 2) & 0x7, ft & 0x1);
7396 opn = "movcf.ps";
7397 break;
7398 case OPC_MOVZ_PS:
7399 check_cp1_64bitmode(ctx);
7400 {
7401 int l1 = gen_new_label();
7402 TCGv_i64 fp0;
7403
7404 if (ft != 0)
7405 tcg_gen_brcondi_tl(TCG_COND_NE, cpu_gpr[ft], 0, l1);
7406 fp0 = tcg_temp_new_i64();
7407 gen_load_fpr64(ctx, fp0, fs);
7408 gen_store_fpr64(ctx, fp0, fd);
7409 tcg_temp_free_i64(fp0);
7410 gen_set_label(l1);
7411 }
7412 opn = "movz.ps";
7413 break;
7414 case OPC_MOVN_PS:
7415 check_cp1_64bitmode(ctx);
7416 {
7417 int l1 = gen_new_label();
7418 TCGv_i64 fp0;
7419
7420 if (ft != 0) {
7421 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr[ft], 0, l1);
7422 fp0 = tcg_temp_new_i64();
7423 gen_load_fpr64(ctx, fp0, fs);
7424 gen_store_fpr64(ctx, fp0, fd);
7425 tcg_temp_free_i64(fp0);
7426 gen_set_label(l1);
7427 }
7428 }
7429 opn = "movn.ps";
7430 break;
7431 case OPC_ADDR_PS:
7432 check_cp1_64bitmode(ctx);
7433 {
7434 TCGv_i64 fp0 = tcg_temp_new_i64();
7435 TCGv_i64 fp1 = tcg_temp_new_i64();
7436
7437 gen_load_fpr64(ctx, fp0, ft);
7438 gen_load_fpr64(ctx, fp1, fs);
7439 gen_helper_float_addr_ps(fp0, fp0, fp1);
7440 tcg_temp_free_i64(fp1);
7441 gen_store_fpr64(ctx, fp0, fd);
7442 tcg_temp_free_i64(fp0);
7443 }
7444 opn = "addr.ps";
7445 break;
7446 case OPC_MULR_PS:
7447 check_cp1_64bitmode(ctx);
7448 {
7449 TCGv_i64 fp0 = tcg_temp_new_i64();
7450 TCGv_i64 fp1 = tcg_temp_new_i64();
7451
7452 gen_load_fpr64(ctx, fp0, ft);
7453 gen_load_fpr64(ctx, fp1, fs);
7454 gen_helper_float_mulr_ps(fp0, fp0, fp1);
7455 tcg_temp_free_i64(fp1);
7456 gen_store_fpr64(ctx, fp0, fd);
7457 tcg_temp_free_i64(fp0);
7458 }
7459 opn = "mulr.ps";
7460 break;
7461 case OPC_RECIP2_PS:
7462 check_cp1_64bitmode(ctx);
7463 {
7464 TCGv_i64 fp0 = tcg_temp_new_i64();
7465 TCGv_i64 fp1 = tcg_temp_new_i64();
7466
7467 gen_load_fpr64(ctx, fp0, fs);
7468 gen_load_fpr64(ctx, fp1, fd);
7469 gen_helper_float_recip2_ps(fp0, fp0, fp1);
7470 tcg_temp_free_i64(fp1);
7471 gen_store_fpr64(ctx, fp0, fd);
7472 tcg_temp_free_i64(fp0);
7473 }
7474 opn = "recip2.ps";
7475 break;
7476 case OPC_RECIP1_PS:
7477 check_cp1_64bitmode(ctx);
7478 {
7479 TCGv_i64 fp0 = tcg_temp_new_i64();
7480
7481 gen_load_fpr64(ctx, fp0, fs);
7482 gen_helper_float_recip1_ps(fp0, fp0);
7483 gen_store_fpr64(ctx, fp0, fd);
7484 tcg_temp_free_i64(fp0);
7485 }
7486 opn = "recip1.ps";
7487 break;
7488 case OPC_RSQRT1_PS:
7489 check_cp1_64bitmode(ctx);
7490 {
7491 TCGv_i64 fp0 = tcg_temp_new_i64();
7492
7493 gen_load_fpr64(ctx, fp0, fs);
7494 gen_helper_float_rsqrt1_ps(fp0, fp0);
7495 gen_store_fpr64(ctx, fp0, fd);
7496 tcg_temp_free_i64(fp0);
7497 }
7498 opn = "rsqrt1.ps";
7499 break;
7500 case OPC_RSQRT2_PS:
7501 check_cp1_64bitmode(ctx);
7502 {
7503 TCGv_i64 fp0 = tcg_temp_new_i64();
7504 TCGv_i64 fp1 = tcg_temp_new_i64();
7505
7506 gen_load_fpr64(ctx, fp0, fs);
7507 gen_load_fpr64(ctx, fp1, ft);
7508 gen_helper_float_rsqrt2_ps(fp0, fp0, fp1);
7509 tcg_temp_free_i64(fp1);
7510 gen_store_fpr64(ctx, fp0, fd);
7511 tcg_temp_free_i64(fp0);
7512 }
7513 opn = "rsqrt2.ps";
7514 break;
7515 case OPC_CVT_S_PU:
7516 check_cp1_64bitmode(ctx);
7517 {
7518 TCGv_i32 fp0 = tcg_temp_new_i32();
7519
7520 gen_load_fpr32h(fp0, fs);
7521 gen_helper_float_cvts_pu(fp0, fp0);
7522 gen_store_fpr32(fp0, fd);
7523 tcg_temp_free_i32(fp0);
7524 }
7525 opn = "cvt.s.pu";
7526 break;
7527 case OPC_CVT_PW_PS:
7528 check_cp1_64bitmode(ctx);
7529 {
7530 TCGv_i64 fp0 = tcg_temp_new_i64();
7531
7532 gen_load_fpr64(ctx, fp0, fs);
7533 gen_helper_float_cvtpw_ps(fp0, fp0);
7534 gen_store_fpr64(ctx, fp0, fd);
7535 tcg_temp_free_i64(fp0);
7536 }
7537 opn = "cvt.pw.ps";
7538 break;
7539 case OPC_CVT_S_PL:
7540 check_cp1_64bitmode(ctx);
7541 {
7542 TCGv_i32 fp0 = tcg_temp_new_i32();
7543
7544 gen_load_fpr32(fp0, fs);
7545 gen_helper_float_cvts_pl(fp0, fp0);
7546 gen_store_fpr32(fp0, fd);
7547 tcg_temp_free_i32(fp0);
7548 }
7549 opn = "cvt.s.pl";
7550 break;
7551 case OPC_PLL_PS:
7552 check_cp1_64bitmode(ctx);
7553 {
7554 TCGv_i32 fp0 = tcg_temp_new_i32();
7555 TCGv_i32 fp1 = tcg_temp_new_i32();
7556
7557 gen_load_fpr32(fp0, fs);
7558 gen_load_fpr32(fp1, ft);
7559 gen_store_fpr32h(fp0, fd);
7560 gen_store_fpr32(fp1, fd);
7561 tcg_temp_free_i32(fp0);
7562 tcg_temp_free_i32(fp1);
7563 }
7564 opn = "pll.ps";
7565 break;
7566 case OPC_PLU_PS:
7567 check_cp1_64bitmode(ctx);
7568 {
7569 TCGv_i32 fp0 = tcg_temp_new_i32();
7570 TCGv_i32 fp1 = tcg_temp_new_i32();
7571
7572 gen_load_fpr32(fp0, fs);
7573 gen_load_fpr32h(fp1, ft);
7574 gen_store_fpr32(fp1, fd);
7575 gen_store_fpr32h(fp0, fd);
7576 tcg_temp_free_i32(fp0);
7577 tcg_temp_free_i32(fp1);
7578 }
7579 opn = "plu.ps";
7580 break;
7581 case OPC_PUL_PS:
7582 check_cp1_64bitmode(ctx);
7583 {
7584 TCGv_i32 fp0 = tcg_temp_new_i32();
7585 TCGv_i32 fp1 = tcg_temp_new_i32();
7586
7587 gen_load_fpr32h(fp0, fs);
7588 gen_load_fpr32(fp1, ft);
7589 gen_store_fpr32(fp1, fd);
7590 gen_store_fpr32h(fp0, fd);
7591 tcg_temp_free_i32(fp0);
7592 tcg_temp_free_i32(fp1);
7593 }
7594 opn = "pul.ps";
7595 break;
7596 case OPC_PUU_PS:
7597 check_cp1_64bitmode(ctx);
7598 {
7599 TCGv_i32 fp0 = tcg_temp_new_i32();
7600 TCGv_i32 fp1 = tcg_temp_new_i32();
7601
7602 gen_load_fpr32h(fp0, fs);
7603 gen_load_fpr32h(fp1, ft);
7604 gen_store_fpr32(fp1, fd);
7605 gen_store_fpr32h(fp0, fd);
7606 tcg_temp_free_i32(fp0);
7607 tcg_temp_free_i32(fp1);
7608 }
7609 opn = "puu.ps";
7610 break;
7611 case OPC_CMP_F_PS:
7612 case OPC_CMP_UN_PS:
7613 case OPC_CMP_EQ_PS:
7614 case OPC_CMP_UEQ_PS:
7615 case OPC_CMP_OLT_PS:
7616 case OPC_CMP_ULT_PS:
7617 case OPC_CMP_OLE_PS:
7618 case OPC_CMP_ULE_PS:
7619 case OPC_CMP_SF_PS:
7620 case OPC_CMP_NGLE_PS:
7621 case OPC_CMP_SEQ_PS:
7622 case OPC_CMP_NGL_PS:
7623 case OPC_CMP_LT_PS:
7624 case OPC_CMP_NGE_PS:
7625 case OPC_CMP_LE_PS:
7626 case OPC_CMP_NGT_PS:
7627 if (ctx->opcode & (1 << 6)) {
7628 gen_cmpabs_ps(ctx, func-48, ft, fs, cc);
7629 opn = condnames_abs[func-48];
7630 } else {
7631 gen_cmp_ps(ctx, func-48, ft, fs, cc);
7632 opn = condnames[func-48];
7633 }
7634 break;
7635 default:
7636 MIPS_INVAL(opn);
7637 generate_exception (ctx, EXCP_RI);
7638 return;
7639 }
7640 (void)opn; /* avoid a compiler warning */
7641 switch (optype) {
7642 case BINOP:
7643 MIPS_DEBUG("%s %s, %s, %s", opn, fregnames[fd], fregnames[fs], fregnames[ft]);
7644 break;
7645 case CMPOP:
7646 MIPS_DEBUG("%s %s,%s", opn, fregnames[fs], fregnames[ft]);
7647 break;
7648 default:
7649 MIPS_DEBUG("%s %s,%s", opn, fregnames[fd], fregnames[fs]);
7650 break;
7651 }
7652 }
7653
7654 /* Coprocessor 3 (FPU) */
7655 static void gen_flt3_ldst (DisasContext *ctx, uint32_t opc,
7656 int fd, int fs, int base, int index)
7657 {
7658 const char *opn = "extended float load/store";
7659 int store = 0;
7660 TCGv t0 = tcg_temp_new();
7661
7662 if (base == 0) {
7663 gen_load_gpr(t0, index);
7664 } else if (index == 0) {
7665 gen_load_gpr(t0, base);
7666 } else {
7667 gen_load_gpr(t0, index);
7668 gen_op_addr_add(ctx, t0, cpu_gpr[base], t0);
7669 }
7670 /* Don't do NOP if destination is zero: we must perform the actual
7671 memory access. */
7672 save_cpu_state(ctx, 0);
7673 switch (opc) {
7674 case OPC_LWXC1:
7675 check_cop1x(ctx);
7676 {
7677 TCGv_i32 fp0 = tcg_temp_new_i32();
7678
7679 tcg_gen_qemu_ld32s(t0, t0, ctx->mem_idx);
7680 tcg_gen_trunc_tl_i32(fp0, t0);
7681 gen_store_fpr32(fp0, fd);
7682 tcg_temp_free_i32(fp0);
7683 }
7684 opn = "lwxc1";
7685 break;
7686 case OPC_LDXC1:
7687 check_cop1x(ctx);
7688 check_cp1_registers(ctx, fd);
7689 {
7690 TCGv_i64 fp0 = tcg_temp_new_i64();
7691
7692 tcg_gen_qemu_ld64(fp0, t0, ctx->mem_idx);
7693 gen_store_fpr64(ctx, fp0, fd);
7694 tcg_temp_free_i64(fp0);
7695 }
7696 opn = "ldxc1";
7697 break;
7698 case OPC_LUXC1:
7699 check_cp1_64bitmode(ctx);
7700 tcg_gen_andi_tl(t0, t0, ~0x7);
7701 {
7702 TCGv_i64 fp0 = tcg_temp_new_i64();
7703
7704 tcg_gen_qemu_ld64(fp0, t0, ctx->mem_idx);
7705 gen_store_fpr64(ctx, fp0, fd);
7706 tcg_temp_free_i64(fp0);
7707 }
7708 opn = "luxc1";
7709 break;
7710 case OPC_SWXC1:
7711 check_cop1x(ctx);
7712 {
7713 TCGv_i32 fp0 = tcg_temp_new_i32();
7714 TCGv t1 = tcg_temp_new();
7715
7716 gen_load_fpr32(fp0, fs);
7717 tcg_gen_extu_i32_tl(t1, fp0);
7718 tcg_gen_qemu_st32(t1, t0, ctx->mem_idx);
7719 tcg_temp_free_i32(fp0);
7720 tcg_temp_free(t1);
7721 }
7722 opn = "swxc1";
7723 store = 1;
7724 break;
7725 case OPC_SDXC1:
7726 check_cop1x(ctx);
7727 check_cp1_registers(ctx, fs);
7728 {
7729 TCGv_i64 fp0 = tcg_temp_new_i64();
7730
7731 gen_load_fpr64(ctx, fp0, fs);
7732 tcg_gen_qemu_st64(fp0, t0, ctx->mem_idx);
7733 tcg_temp_free_i64(fp0);
7734 }
7735 opn = "sdxc1";
7736 store = 1;
7737 break;
7738 case OPC_SUXC1:
7739 check_cp1_64bitmode(ctx);
7740 tcg_gen_andi_tl(t0, t0, ~0x7);
7741 {
7742 TCGv_i64 fp0 = tcg_temp_new_i64();
7743
7744 gen_load_fpr64(ctx, fp0, fs);
7745 tcg_gen_qemu_st64(fp0, t0, ctx->mem_idx);
7746 tcg_temp_free_i64(fp0);
7747 }
7748 opn = "suxc1";
7749 store = 1;
7750 break;
7751 }
7752 tcg_temp_free(t0);
7753 (void)opn; (void)store; /* avoid compiler warnings */
7754 MIPS_DEBUG("%s %s, %s(%s)", opn, fregnames[store ? fs : fd],
7755 regnames[index], regnames[base]);
7756 }
7757
7758 static void gen_flt3_arith (DisasContext *ctx, uint32_t opc,
7759 int fd, int fr, int fs, int ft)
7760 {
7761 const char *opn = "flt3_arith";
7762
7763 switch (opc) {
7764 case OPC_ALNV_PS:
7765 check_cp1_64bitmode(ctx);
7766 {
7767 TCGv t0 = tcg_temp_local_new();
7768 TCGv_i32 fp = tcg_temp_new_i32();
7769 TCGv_i32 fph = tcg_temp_new_i32();
7770 int l1 = gen_new_label();
7771 int l2 = gen_new_label();
7772
7773 gen_load_gpr(t0, fr);
7774 tcg_gen_andi_tl(t0, t0, 0x7);
7775
7776 tcg_gen_brcondi_tl(TCG_COND_NE, t0, 0, l1);
7777 gen_load_fpr32(fp, fs);
7778 gen_load_fpr32h(fph, fs);
7779 gen_store_fpr32(fp, fd);
7780 gen_store_fpr32h(fph, fd);
7781 tcg_gen_br(l2);
7782 gen_set_label(l1);
7783 tcg_gen_brcondi_tl(TCG_COND_NE, t0, 4, l2);
7784 tcg_temp_free(t0);
7785 #ifdef TARGET_WORDS_BIGENDIAN
7786 gen_load_fpr32(fp, fs);
7787 gen_load_fpr32h(fph, ft);
7788 gen_store_fpr32h(fp, fd);
7789 gen_store_fpr32(fph, fd);
7790 #else
7791 gen_load_fpr32h(fph, fs);
7792 gen_load_fpr32(fp, ft);
7793 gen_store_fpr32(fph, fd);
7794 gen_store_fpr32h(fp, fd);
7795 #endif
7796 gen_set_label(l2);
7797 tcg_temp_free_i32(fp);
7798 tcg_temp_free_i32(fph);
7799 }
7800 opn = "alnv.ps";
7801 break;
7802 case OPC_MADD_S:
7803 check_cop1x(ctx);
7804 {
7805 TCGv_i32 fp0 = tcg_temp_new_i32();
7806 TCGv_i32 fp1 = tcg_temp_new_i32();
7807 TCGv_i32 fp2 = tcg_temp_new_i32();
7808
7809 gen_load_fpr32(fp0, fs);
7810 gen_load_fpr32(fp1, ft);
7811 gen_load_fpr32(fp2, fr);
7812 gen_helper_float_muladd_s(fp2, fp0, fp1, fp2);
7813 tcg_temp_free_i32(fp0);
7814 tcg_temp_free_i32(fp1);
7815 gen_store_fpr32(fp2, fd);
7816 tcg_temp_free_i32(fp2);
7817 }
7818 opn = "madd.s";
7819 break;
7820 case OPC_MADD_D:
7821 check_cop1x(ctx);
7822 check_cp1_registers(ctx, fd | fs | ft | fr);
7823 {
7824 TCGv_i64 fp0 = tcg_temp_new_i64();
7825 TCGv_i64 fp1 = tcg_temp_new_i64();
7826 TCGv_i64 fp2 = tcg_temp_new_i64();
7827
7828 gen_load_fpr64(ctx, fp0, fs);
7829 gen_load_fpr64(ctx, fp1, ft);
7830 gen_load_fpr64(ctx, fp2, fr);
7831 gen_helper_float_muladd_d(fp2, fp0, fp1, fp2);
7832 tcg_temp_free_i64(fp0);
7833 tcg_temp_free_i64(fp1);
7834 gen_store_fpr64(ctx, fp2, fd);
7835 tcg_temp_free_i64(fp2);
7836 }
7837 opn = "madd.d";
7838 break;
7839 case OPC_MADD_PS:
7840 check_cp1_64bitmode(ctx);
7841 {
7842 TCGv_i64 fp0 = tcg_temp_new_i64();
7843 TCGv_i64 fp1 = tcg_temp_new_i64();
7844 TCGv_i64 fp2 = tcg_temp_new_i64();
7845
7846 gen_load_fpr64(ctx, fp0, fs);
7847 gen_load_fpr64(ctx, fp1, ft);
7848 gen_load_fpr64(ctx, fp2, fr);
7849 gen_helper_float_muladd_ps(fp2, fp0, fp1, fp2);
7850 tcg_temp_free_i64(fp0);
7851 tcg_temp_free_i64(fp1);
7852 gen_store_fpr64(ctx, fp2, fd);
7853 tcg_temp_free_i64(fp2);
7854 }
7855 opn = "madd.ps";
7856 break;
7857 case OPC_MSUB_S:
7858 check_cop1x(ctx);
7859 {
7860 TCGv_i32 fp0 = tcg_temp_new_i32();
7861 TCGv_i32 fp1 = tcg_temp_new_i32();
7862 TCGv_i32 fp2 = tcg_temp_new_i32();
7863
7864 gen_load_fpr32(fp0, fs);
7865 gen_load_fpr32(fp1, ft);
7866 gen_load_fpr32(fp2, fr);
7867 gen_helper_float_mulsub_s(fp2, fp0, fp1, fp2);
7868 tcg_temp_free_i32(fp0);
7869 tcg_temp_free_i32(fp1);
7870 gen_store_fpr32(fp2, fd);
7871 tcg_temp_free_i32(fp2);
7872 }
7873 opn = "msub.s";
7874 break;
7875 case OPC_MSUB_D:
7876 check_cop1x(ctx);
7877 check_cp1_registers(ctx, fd | fs | ft | fr);
7878 {
7879 TCGv_i64 fp0 = tcg_temp_new_i64();
7880 TCGv_i64 fp1 = tcg_temp_new_i64();
7881 TCGv_i64 fp2 = tcg_temp_new_i64();
7882
7883 gen_load_fpr64(ctx, fp0, fs);
7884 gen_load_fpr64(ctx, fp1, ft);
7885 gen_load_fpr64(ctx, fp2, fr);
7886 gen_helper_float_mulsub_d(fp2, fp0, fp1, fp2);
7887 tcg_temp_free_i64(fp0);
7888 tcg_temp_free_i64(fp1);
7889 gen_store_fpr64(ctx, fp2, fd);
7890 tcg_temp_free_i64(fp2);
7891 }
7892 opn = "msub.d";
7893 break;
7894 case OPC_MSUB_PS:
7895 check_cp1_64bitmode(ctx);
7896 {
7897 TCGv_i64 fp0 = tcg_temp_new_i64();
7898 TCGv_i64 fp1 = tcg_temp_new_i64();
7899 TCGv_i64 fp2 = tcg_temp_new_i64();
7900
7901 gen_load_fpr64(ctx, fp0, fs);
7902 gen_load_fpr64(ctx, fp1, ft);
7903 gen_load_fpr64(ctx, fp2, fr);
7904 gen_helper_float_mulsub_ps(fp2, fp0, fp1, fp2);
7905 tcg_temp_free_i64(fp0);
7906 tcg_temp_free_i64(fp1);
7907 gen_store_fpr64(ctx, fp2, fd);
7908 tcg_temp_free_i64(fp2);
7909 }
7910 opn = "msub.ps";
7911 break;
7912 case OPC_NMADD_S:
7913 check_cop1x(ctx);
7914 {
7915 TCGv_i32 fp0 = tcg_temp_new_i32();
7916 TCGv_i32 fp1 = tcg_temp_new_i32();
7917 TCGv_i32 fp2 = tcg_temp_new_i32();
7918
7919 gen_load_fpr32(fp0, fs);
7920 gen_load_fpr32(fp1, ft);
7921 gen_load_fpr32(fp2, fr);
7922 gen_helper_float_nmuladd_s(fp2, fp0, fp1, fp2);
7923 tcg_temp_free_i32(fp0);
7924 tcg_temp_free_i32(fp1);
7925 gen_store_fpr32(fp2, fd);
7926 tcg_temp_free_i32(fp2);
7927 }
7928 opn = "nmadd.s";
7929 break;
7930 case OPC_NMADD_D:
7931 check_cop1x(ctx);
7932 check_cp1_registers(ctx, fd | fs | ft | fr);
7933 {
7934 TCGv_i64 fp0 = tcg_temp_new_i64();
7935 TCGv_i64 fp1 = tcg_temp_new_i64();
7936 TCGv_i64 fp2 = tcg_temp_new_i64();
7937
7938 gen_load_fpr64(ctx, fp0, fs);
7939 gen_load_fpr64(ctx, fp1, ft);
7940 gen_load_fpr64(ctx, fp2, fr);
7941 gen_helper_float_nmuladd_d(fp2, fp0, fp1, fp2);
7942 tcg_temp_free_i64(fp0);
7943 tcg_temp_free_i64(fp1);
7944 gen_store_fpr64(ctx, fp2, fd);
7945 tcg_temp_free_i64(fp2);
7946 }
7947 opn = "nmadd.d";
7948 break;
7949 case OPC_NMADD_PS:
7950 check_cp1_64bitmode(ctx);
7951 {
7952 TCGv_i64 fp0 = tcg_temp_new_i64();
7953 TCGv_i64 fp1 = tcg_temp_new_i64();
7954 TCGv_i64 fp2 = tcg_temp_new_i64();
7955
7956 gen_load_fpr64(ctx, fp0, fs);
7957 gen_load_fpr64(ctx, fp1, ft);
7958 gen_load_fpr64(ctx, fp2, fr);
7959 gen_helper_float_nmuladd_ps(fp2, fp0, fp1, fp2);
7960 tcg_temp_free_i64(fp0);
7961 tcg_temp_free_i64(fp1);
7962 gen_store_fpr64(ctx, fp2, fd);
7963 tcg_temp_free_i64(fp2);
7964 }
7965 opn = "nmadd.ps";
7966 break;
7967 case OPC_NMSUB_S:
7968 check_cop1x(ctx);
7969 {
7970 TCGv_i32 fp0 = tcg_temp_new_i32();
7971 TCGv_i32 fp1 = tcg_temp_new_i32();
7972 TCGv_i32 fp2 = tcg_temp_new_i32();
7973
7974 gen_load_fpr32(fp0, fs);
7975 gen_load_fpr32(fp1, ft);
7976 gen_load_fpr32(fp2, fr);
7977 gen_helper_float_nmulsub_s(fp2, fp0, fp1, fp2);
7978 tcg_temp_free_i32(fp0);
7979 tcg_temp_free_i32(fp1);
7980 gen_store_fpr32(fp2, fd);
7981 tcg_temp_free_i32(fp2);
7982 }
7983 opn = "nmsub.s";
7984 break;
7985 case OPC_NMSUB_D:
7986 check_cop1x(ctx);
7987 check_cp1_registers(ctx, fd | fs | ft | fr);
7988 {
7989 TCGv_i64 fp0 = tcg_temp_new_i64();
7990 TCGv_i64 fp1 = tcg_temp_new_i64();
7991 TCGv_i64 fp2 = tcg_temp_new_i64();
7992
7993 gen_load_fpr64(ctx, fp0, fs);
7994 gen_load_fpr64(ctx, fp1, ft);
7995 gen_load_fpr64(ctx, fp2, fr);
7996 gen_helper_float_nmulsub_d(fp2, fp0, fp1, fp2);
7997 tcg_temp_free_i64(fp0);
7998 tcg_temp_free_i64(fp1);
7999 gen_store_fpr64(ctx, fp2, fd);
8000 tcg_temp_free_i64(fp2);
8001 }
8002 opn = "nmsub.d";
8003 break;
8004 case OPC_NMSUB_PS:
8005 check_cp1_64bitmode(ctx);
8006 {
8007 TCGv_i64 fp0 = tcg_temp_new_i64();
8008 TCGv_i64 fp1 = tcg_temp_new_i64();
8009 TCGv_i64 fp2 = tcg_temp_new_i64();
8010
8011 gen_load_fpr64(ctx, fp0, fs);
8012 gen_load_fpr64(ctx, fp1, ft);
8013 gen_load_fpr64(ctx, fp2, fr);
8014 gen_helper_float_nmulsub_ps(fp2, fp0, fp1, fp2);
8015 tcg_temp_free_i64(fp0);
8016 tcg_temp_free_i64(fp1);
8017 gen_store_fpr64(ctx, fp2, fd);
8018 tcg_temp_free_i64(fp2);
8019 }
8020 opn = "nmsub.ps";
8021 break;
8022 default:
8023 MIPS_INVAL(opn);
8024 generate_exception (ctx, EXCP_RI);
8025 return;
8026 }
8027 (void)opn; /* avoid a compiler warning */
8028 MIPS_DEBUG("%s %s, %s, %s, %s", opn, fregnames[fd], fregnames[fr],
8029 fregnames[fs], fregnames[ft]);
8030 }
8031
8032 static void
8033 gen_rdhwr (CPUState *env, DisasContext *ctx, int rt, int rd)
8034 {
8035 TCGv t0;
8036
8037 check_insn(env, ctx, ISA_MIPS32R2);
8038 t0 = tcg_temp_new();
8039
8040 switch (rd) {
8041 case 0:
8042 save_cpu_state(ctx, 1);
8043 gen_helper_rdhwr_cpunum(t0);
8044 gen_store_gpr(t0, rt);
8045 break;
8046 case 1:
8047 save_cpu_state(ctx, 1);
8048 gen_helper_rdhwr_synci_step(t0);
8049 gen_store_gpr(t0, rt);
8050 break;
8051 case 2:
8052 save_cpu_state(ctx, 1);
8053 gen_helper_rdhwr_cc(t0);
8054 gen_store_gpr(t0, rt);
8055 break;
8056 case 3:
8057 save_cpu_state(ctx, 1);
8058 gen_helper_rdhwr_ccres(t0);
8059 gen_store_gpr(t0, rt);
8060 break;
8061 case 29:
8062 #if defined(CONFIG_USER_ONLY)
8063 tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, tls_value));
8064 gen_store_gpr(t0, rt);
8065 break;
8066 #else
8067 /* XXX: Some CPUs implement this in hardware.
8068 Not supported yet. */
8069 #endif
8070 default: /* Invalid */
8071 MIPS_INVAL("rdhwr");
8072 generate_exception(ctx, EXCP_RI);
8073 break;
8074 }
8075 tcg_temp_free(t0);
8076 }
8077
8078 static void handle_delay_slot (CPUState *env, DisasContext *ctx,
8079 int insn_bytes)
8080 {
8081 if (ctx->hflags & MIPS_HFLAG_BMASK) {
8082 int proc_hflags = ctx->hflags & MIPS_HFLAG_BMASK;
8083 /* Branches completion */
8084 ctx->hflags &= ~MIPS_HFLAG_BMASK;
8085 ctx->bstate = BS_BRANCH;
8086 save_cpu_state(ctx, 0);
8087 /* FIXME: Need to clear can_do_io. */
8088 switch (proc_hflags & MIPS_HFLAG_BMASK_BASE) {
8089 case MIPS_HFLAG_B:
8090 /* unconditional branch */
8091 MIPS_DEBUG("unconditional branch");
8092 if (proc_hflags & MIPS_HFLAG_BX) {
8093 tcg_gen_xori_i32(hflags, hflags, MIPS_HFLAG_M16);
8094 }
8095 gen_goto_tb(ctx, 0, ctx->btarget);
8096 break;
8097 case MIPS_HFLAG_BL:
8098 /* blikely taken case */
8099 MIPS_DEBUG("blikely branch taken");
8100 gen_goto_tb(ctx, 0, ctx->btarget);
8101 break;
8102 case MIPS_HFLAG_BC:
8103 /* Conditional branch */
8104 MIPS_DEBUG("conditional branch");
8105 {
8106 int l1 = gen_new_label();
8107
8108 tcg_gen_brcondi_tl(TCG_COND_NE, bcond, 0, l1);
8109 gen_goto_tb(ctx, 1, ctx->pc + insn_bytes);
8110 gen_set_label(l1);
8111 gen_goto_tb(ctx, 0, ctx->btarget);
8112 }
8113 break;
8114 case MIPS_HFLAG_BR:
8115 /* unconditional branch to register */
8116 MIPS_DEBUG("branch to register");
8117 if (env->insn_flags & (ASE_MIPS16 | ASE_MICROMIPS)) {
8118 TCGv t0 = tcg_temp_new();
8119 TCGv_i32 t1 = tcg_temp_new_i32();
8120
8121 tcg_gen_andi_tl(t0, btarget, 0x1);
8122 tcg_gen_trunc_tl_i32(t1, t0);
8123 tcg_temp_free(t0);
8124 tcg_gen_andi_i32(hflags, hflags, ~(uint32_t)MIPS_HFLAG_M16);
8125 tcg_gen_shli_i32(t1, t1, MIPS_HFLAG_M16_SHIFT);
8126 tcg_gen_or_i32(hflags, hflags, t1);
8127 tcg_temp_free_i32(t1);
8128
8129 tcg_gen_andi_tl(cpu_PC, btarget, ~(target_ulong)0x1);
8130 } else {
8131 tcg_gen_mov_tl(cpu_PC, btarget);
8132 }
8133 if (ctx->singlestep_enabled) {
8134 save_cpu_state(ctx, 0);
8135 gen_helper_0i(raise_exception, EXCP_DEBUG);
8136 }
8137 tcg_gen_exit_tb(0);
8138 break;
8139 default:
8140 MIPS_DEBUG("unknown branch");
8141 break;
8142 }
8143 }
8144 }
8145
8146 /* ISA extensions (ASEs) */
8147 /* MIPS16 extension to MIPS32 */
8148
8149 /* MIPS16 major opcodes */
8150 enum {
8151 M16_OPC_ADDIUSP = 0x00,
8152 M16_OPC_ADDIUPC = 0x01,
8153 M16_OPC_B = 0x02,
8154 M16_OPC_JAL = 0x03,
8155 M16_OPC_BEQZ = 0x04,
8156 M16_OPC_BNEQZ = 0x05,
8157 M16_OPC_SHIFT = 0x06,
8158 M16_OPC_LD = 0x07,
8159 M16_OPC_RRIA = 0x08,
8160 M16_OPC_ADDIU8 = 0x09,
8161 M16_OPC_SLTI = 0x0a,
8162 M16_OPC_SLTIU = 0x0b,
8163 M16_OPC_I8 = 0x0c,
8164 M16_OPC_LI = 0x0d,
8165 M16_OPC_CMPI = 0x0e,
8166 M16_OPC_SD = 0x0f,
8167 M16_OPC_LB = 0x10,
8168 M16_OPC_LH = 0x11,
8169 M16_OPC_LWSP = 0x12,
8170 M16_OPC_LW = 0x13,
8171 M16_OPC_LBU = 0x14,
8172 M16_OPC_LHU = 0x15,
8173 M16_OPC_LWPC = 0x16,
8174 M16_OPC_LWU = 0x17,
8175 M16_OPC_SB = 0x18,
8176 M16_OPC_SH = 0x19,
8177 M16_OPC_SWSP = 0x1a,
8178 M16_OPC_SW = 0x1b,
8179 M16_OPC_RRR = 0x1c,
8180 M16_OPC_RR = 0x1d,
8181 M16_OPC_EXTEND = 0x1e,
8182 M16_OPC_I64 = 0x1f
8183 };
8184
8185 /* I8 funct field */
8186 enum {
8187 I8_BTEQZ = 0x0,
8188 I8_BTNEZ = 0x1,
8189 I8_SWRASP = 0x2,
8190 I8_ADJSP = 0x3,
8191 I8_SVRS = 0x4,
8192 I8_MOV32R = 0x5,
8193 I8_MOVR32 = 0x7
8194 };
8195
8196 /* RRR f field */
8197 enum {
8198 RRR_DADDU = 0x0,
8199 RRR_ADDU = 0x1,
8200 RRR_DSUBU = 0x2,
8201 RRR_SUBU = 0x3
8202 };
8203
8204 /* RR funct field */
8205 enum {
8206 RR_JR = 0x00,
8207 RR_SDBBP = 0x01,
8208 RR_SLT = 0x02,
8209 RR_SLTU = 0x03,
8210 RR_SLLV = 0x04,
8211 RR_BREAK = 0x05,
8212 RR_SRLV = 0x06,
8213 RR_SRAV = 0x07,
8214 RR_DSRL = 0x08,
8215 RR_CMP = 0x0a,
8216 RR_NEG = 0x0b,
8217 RR_AND = 0x0c,
8218 RR_OR = 0x0d,
8219 RR_XOR = 0x0e,
8220 RR_NOT = 0x0f,
8221 RR_MFHI = 0x10,
8222 RR_CNVT = 0x11,
8223 RR_MFLO = 0x12,
8224 RR_DSRA = 0x13,
8225 RR_DSLLV = 0x14,
8226 RR_DSRLV = 0x16,
8227 RR_DSRAV = 0x17,
8228 RR_MULT = 0x18,
8229 RR_MULTU = 0x19,
8230 RR_DIV = 0x1a,
8231 RR_DIVU = 0x1b,
8232 RR_DMULT = 0x1c,
8233 RR_DMULTU = 0x1d,
8234 RR_DDIV = 0x1e,
8235 RR_DDIVU = 0x1f
8236 };
8237
8238 /* I64 funct field */
8239 enum {
8240 I64_LDSP = 0x0,
8241 I64_SDSP = 0x1,
8242 I64_SDRASP = 0x2,
8243 I64_DADJSP = 0x3,
8244 I64_LDPC = 0x4,
8245 I64_DADDIU5 = 0x5,
8246 I64_DADDIUPC = 0x6,
8247 I64_DADDIUSP = 0x7
8248 };
8249
8250 /* RR ry field for CNVT */
8251 enum {
8252 RR_RY_CNVT_ZEB = 0x0,
8253 RR_RY_CNVT_ZEH = 0x1,
8254 RR_RY_CNVT_ZEW = 0x2,
8255 RR_RY_CNVT_SEB = 0x4,
8256 RR_RY_CNVT_SEH = 0x5,
8257 RR_RY_CNVT_SEW = 0x6,
8258 };
8259
8260 static int xlat (int r)
8261 {
8262 static int map[] = { 16, 17, 2, 3, 4, 5, 6, 7 };
8263
8264 return map[r];
8265 }
8266
8267 static void gen_mips16_save (DisasContext *ctx,
8268 int xsregs, int aregs,
8269 int do_ra, int do_s0, int do_s1,
8270 int framesize)
8271 {
8272 TCGv t0 = tcg_temp_new();
8273 TCGv t1 = tcg_temp_new();
8274 int args, astatic;
8275
8276 switch (aregs) {
8277 case 0:
8278 case 1:
8279 case 2:
8280 case 3:
8281 case 11:
8282 args = 0;
8283 break;
8284 case 4:
8285 case 5:
8286 case 6:
8287 case 7:
8288 args = 1;
8289 break;
8290 case 8:
8291 case 9:
8292 case 10:
8293 args = 2;
8294 break;
8295 case 12:
8296 case 13:
8297 args = 3;
8298 break;
8299 case 14:
8300 args = 4;
8301 break;
8302 default:
8303 generate_exception(ctx, EXCP_RI);
8304 return;
8305 }
8306
8307 switch (args) {
8308 case 4:
8309 gen_base_offset_addr(ctx, t0, 29, 12);
8310 gen_load_gpr(t1, 7);
8311 op_st_sw(t1, t0, ctx);
8312 /* Fall through */
8313 case 3:
8314 gen_base_offset_addr(ctx, t0, 29, 8);
8315 gen_load_gpr(t1, 6);
8316 op_st_sw(t1, t0, ctx);
8317 /* Fall through */
8318 case 2:
8319 gen_base_offset_addr(ctx, t0, 29, 4);
8320 gen_load_gpr(t1, 5);
8321 op_st_sw(t1, t0, ctx);
8322 /* Fall through */
8323 case 1:
8324 gen_base_offset_addr(ctx, t0, 29, 0);
8325 gen_load_gpr(t1, 4);
8326 op_st_sw(t1, t0, ctx);
8327 }
8328
8329 gen_load_gpr(t0, 29);
8330
8331 #define DECR_AND_STORE(reg) do { \
8332 tcg_gen_subi_tl(t0, t0, 4); \
8333 gen_load_gpr(t1, reg); \
8334 op_st_sw(t1, t0, ctx); \
8335 } while (0)
8336
8337 if (do_ra) {
8338 DECR_AND_STORE(31);
8339 }
8340
8341 switch (xsregs) {
8342 case 7:
8343 DECR_AND_STORE(30);
8344 /* Fall through */
8345 case 6:
8346 DECR_AND_STORE(23);
8347 /* Fall through */
8348 case 5:
8349 DECR_AND_STORE(22);
8350 /* Fall through */
8351 case 4:
8352 DECR_AND_STORE(21);
8353 /* Fall through */
8354 case 3:
8355 DECR_AND_STORE(20);
8356 /* Fall through */
8357 case 2:
8358 DECR_AND_STORE(19);
8359 /* Fall through */
8360 case 1:
8361 DECR_AND_STORE(18);
8362 }
8363
8364 if (do_s1) {
8365 DECR_AND_STORE(17);
8366 }
8367 if (do_s0) {
8368 DECR_AND_STORE(16);
8369 }
8370
8371 switch (aregs) {
8372 case 0:
8373 case 4:
8374 case 8:
8375 case 12:
8376 case 14:
8377 astatic = 0;
8378 break;
8379 case 1:
8380 case 5:
8381 case 9:
8382 case 13:
8383 astatic = 1;
8384 break;
8385 case 2:
8386 case 6:
8387 case 10:
8388 astatic = 2;
8389 break;
8390 case 3:
8391 case 7:
8392 astatic = 3;
8393 break;
8394 case 11:
8395 astatic = 4;
8396 break;
8397 default:
8398 generate_exception(ctx, EXCP_RI);
8399 return;
8400 }
8401
8402 if (astatic > 0) {
8403 DECR_AND_STORE(7);
8404 if (astatic > 1) {
8405 DECR_AND_STORE(6);
8406 if (astatic > 2) {
8407 DECR_AND_STORE(5);
8408 if (astatic > 3) {
8409 DECR_AND_STORE(4);
8410 }
8411 }
8412 }
8413 }
8414 #undef DECR_AND_STORE
8415
8416 tcg_gen_subi_tl(cpu_gpr[29], cpu_gpr[29], framesize);
8417 tcg_temp_free(t0);
8418 tcg_temp_free(t1);
8419 }
8420
8421 static void gen_mips16_restore (DisasContext *ctx,
8422 int xsregs, int aregs,
8423 int do_ra, int do_s0, int do_s1,
8424 int framesize)
8425 {
8426 int astatic;
8427 TCGv t0 = tcg_temp_new();
8428 TCGv t1 = tcg_temp_new();
8429
8430 tcg_gen_addi_tl(t0, cpu_gpr[29], framesize);
8431
8432 #define DECR_AND_LOAD(reg) do { \
8433 tcg_gen_subi_tl(t0, t0, 4); \
8434 op_ld_lw(t1, t0, ctx); \
8435 gen_store_gpr(t1, reg); \
8436 } while (0)
8437
8438 if (do_ra) {
8439 DECR_AND_LOAD(31);
8440 }
8441
8442 switch (xsregs) {
8443 case 7:
8444 DECR_AND_LOAD(30);
8445 /* Fall through */
8446 case 6:
8447 DECR_AND_LOAD(23);
8448 /* Fall through */
8449 case 5:
8450 DECR_AND_LOAD(22);
8451 /* Fall through */
8452 case 4:
8453 DECR_AND_LOAD(21);
8454 /* Fall through */
8455 case 3:
8456 DECR_AND_LOAD(20);
8457 /* Fall through */
8458 case 2:
8459 DECR_AND_LOAD(19);
8460 /* Fall through */
8461 case 1:
8462 DECR_AND_LOAD(18);
8463 }
8464
8465 if (do_s1) {
8466 DECR_AND_LOAD(17);
8467 }
8468 if (do_s0) {
8469 DECR_AND_LOAD(16);
8470 }
8471
8472 switch (aregs) {
8473 case 0:
8474 case 4:
8475 case 8:
8476 case 12:
8477 case 14:
8478 astatic = 0;
8479 break;
8480 case 1:
8481 case 5:
8482 case 9:
8483 case 13:
8484 astatic = 1;
8485 break;
8486 case 2:
8487 case 6:
8488 case 10:
8489 astatic = 2;
8490 break;
8491 case 3:
8492 case 7:
8493 astatic = 3;
8494 break;
8495 case 11:
8496 astatic = 4;
8497 break;
8498 default:
8499 generate_exception(ctx, EXCP_RI);
8500 return;
8501 }
8502
8503 if (astatic > 0) {
8504 DECR_AND_LOAD(7);
8505 if (astatic > 1) {
8506 DECR_AND_LOAD(6);
8507 if (astatic > 2) {
8508 DECR_AND_LOAD(5);
8509 if (astatic > 3) {
8510 DECR_AND_LOAD(4);
8511 }
8512 }
8513 }
8514 }
8515 #undef DECR_AND_LOAD
8516
8517 tcg_gen_addi_tl(cpu_gpr[29], cpu_gpr[29], framesize);
8518 tcg_temp_free(t0);
8519 tcg_temp_free(t1);
8520 }
8521
8522 static void gen_addiupc (DisasContext *ctx, int rx, int imm,
8523 int is_64_bit, int extended)
8524 {
8525 TCGv t0;
8526
8527 if (extended && (ctx->hflags & MIPS_HFLAG_BMASK)) {
8528 generate_exception(ctx, EXCP_RI);
8529 return;
8530 }
8531
8532 t0 = tcg_temp_new();
8533
8534 tcg_gen_movi_tl(t0, pc_relative_pc(ctx));
8535 tcg_gen_addi_tl(cpu_gpr[rx], t0, imm);
8536 if (!is_64_bit) {
8537 tcg_gen_ext32s_tl(cpu_gpr[rx], cpu_gpr[rx]);
8538 }
8539
8540 tcg_temp_free(t0);
8541 }
8542
8543 #if defined(TARGET_MIPS64)
8544 static void decode_i64_mips16 (CPUState *env, DisasContext *ctx,
8545 int ry, int funct, int16_t offset,
8546 int extended)
8547 {
8548 switch (funct) {
8549 case I64_LDSP:
8550 check_mips_64(ctx);
8551 offset = extended ? offset : offset << 3;
8552 gen_ld(env, ctx, OPC_LD, ry, 29, offset);
8553 break;
8554 case I64_SDSP:
8555 check_mips_64(ctx);
8556 offset = extended ? offset : offset << 3;
8557 gen_st(ctx, OPC_SD, ry, 29, offset);
8558 break;
8559 case I64_SDRASP:
8560 check_mips_64(ctx);
8561 offset = extended ? offset : (ctx->opcode & 0xff) << 3;
8562 gen_st(ctx, OPC_SD, 31, 29, offset);
8563 break;
8564 case I64_DADJSP:
8565 check_mips_64(ctx);
8566 offset = extended ? offset : ((int8_t)ctx->opcode) << 3;
8567 gen_arith_imm(env, ctx, OPC_DADDIU, 29, 29, offset);
8568 break;
8569 case I64_LDPC:
8570 if (extended && (ctx->hflags & MIPS_HFLAG_BMASK)) {
8571 generate_exception(ctx, EXCP_RI);
8572 } else {
8573 offset = extended ? offset : offset << 3;
8574 gen_ld(env, ctx, OPC_LDPC, ry, 0, offset);
8575 }
8576 break;
8577 case I64_DADDIU5:
8578 check_mips_64(ctx);
8579 offset = extended ? offset : ((int8_t)(offset << 3)) >> 3;
8580 gen_arith_imm(env, ctx, OPC_DADDIU, ry, ry, offset);
8581 break;
8582 case I64_DADDIUPC:
8583 check_mips_64(ctx);
8584 offset = extended ? offset : offset << 2;
8585 gen_addiupc(ctx, ry, offset, 1, extended);
8586 break;
8587 case I64_DADDIUSP:
8588 check_mips_64(ctx);
8589 offset = extended ? offset : offset << 2;
8590 gen_arith_imm(env, ctx, OPC_DADDIU, ry, 29, offset);
8591 break;
8592 }
8593 }
8594 #endif
8595
8596 static int decode_extended_mips16_opc (CPUState *env, DisasContext *ctx,
8597 int *is_branch)
8598 {
8599 int extend = lduw_code(ctx->pc + 2);
8600 int op, rx, ry, funct, sa;
8601 int16_t imm, offset;
8602
8603 ctx->opcode = (ctx->opcode << 16) | extend;
8604 op = (ctx->opcode >> 11) & 0x1f;
8605 sa = (ctx->opcode >> 22) & 0x1f;
8606 funct = (ctx->opcode >> 8) & 0x7;
8607 rx = xlat((ctx->opcode >> 8) & 0x7);
8608 ry = xlat((ctx->opcode >> 5) & 0x7);
8609 offset = imm = (int16_t) (((ctx->opcode >> 16) & 0x1f) << 11
8610 | ((ctx->opcode >> 21) & 0x3f) << 5
8611 | (ctx->opcode & 0x1f));
8612
8613 /* The extended opcodes cleverly reuse the opcodes from their 16-bit
8614 counterparts. */
8615 switch (op) {
8616 case M16_OPC_ADDIUSP:
8617 gen_arith_imm(env, ctx, OPC_ADDIU, rx, 29, imm);
8618 break;
8619 case M16_OPC_ADDIUPC:
8620 gen_addiupc(ctx, rx, imm, 0, 1);
8621 break;
8622 case M16_OPC_B:
8623 gen_compute_branch(ctx, OPC_BEQ, 4, 0, 0, offset << 1);
8624 /* No delay slot, so just process as a normal instruction */
8625 break;
8626 case M16_OPC_BEQZ:
8627 gen_compute_branch(ctx, OPC_BEQ, 4, rx, 0, offset << 1);
8628 /* No delay slot, so just process as a normal instruction */
8629 break;
8630 case M16_OPC_BNEQZ:
8631 gen_compute_branch(ctx, OPC_BNE, 4, rx, 0, offset << 1);
8632 /* No delay slot, so just process as a normal instruction */
8633 break;
8634 case M16_OPC_SHIFT:
8635 switch (ctx->opcode & 0x3) {
8636 case 0x0:
8637 gen_shift_imm(env, ctx, OPC_SLL, rx, ry, sa);
8638 break;
8639 case 0x1:
8640 #if defined(TARGET_MIPS64)
8641 check_mips_64(ctx);
8642 gen_shift_imm(env, ctx, OPC_DSLL, rx, ry, sa);
8643 #else
8644 generate_exception(ctx, EXCP_RI);
8645 #endif
8646 break;
8647 case 0x2:
8648 gen_shift_imm(env, ctx, OPC_SRL, rx, ry, sa);
8649 break;
8650 case 0x3:
8651 gen_shift_imm(env, ctx, OPC_SRA, rx, ry, sa);
8652 break;
8653 }
8654 break;
8655 #if defined(TARGET_MIPS64)
8656 case M16_OPC_LD:
8657 check_mips_64(ctx);
8658 gen_ld(env, ctx, OPC_LD, ry, rx, offset);
8659 break;
8660 #endif
8661 case M16_OPC_RRIA:
8662 imm = ctx->opcode & 0xf;
8663 imm = imm | ((ctx->opcode >> 20) & 0x7f) << 4;
8664 imm = imm | ((ctx->opcode >> 16) & 0xf) << 11;
8665 imm = (int16_t) (imm << 1) >> 1;
8666 if ((ctx->opcode >> 4) & 0x1) {
8667 #if defined(TARGET_MIPS64)
8668 check_mips_64(ctx);
8669 gen_arith_imm(env, ctx, OPC_DADDIU, ry, rx, imm);
8670 #else
8671 generate_exception(ctx, EXCP_RI);
8672 #endif
8673 } else {
8674 gen_arith_imm(env, ctx, OPC_ADDIU, ry, rx, imm);
8675 }
8676 break;
8677 case M16_OPC_ADDIU8:
8678 gen_arith_imm(env, ctx, OPC_ADDIU, rx, rx, imm);
8679 break;
8680 case M16_OPC_SLTI:
8681 gen_slt_imm(env, OPC_SLTI, 24, rx, imm);
8682 break;
8683 case M16_OPC_SLTIU:
8684 gen_slt_imm(env, OPC_SLTIU, 24, rx, imm);
8685 break;
8686 case M16_OPC_I8:
8687 switch (funct) {
8688 case I8_BTEQZ:
8689 gen_compute_branch(ctx, OPC_BEQ, 4, 24, 0, offset << 1);
8690 break;
8691 case I8_BTNEZ:
8692 gen_compute_branch(ctx, OPC_BNE, 4, 24, 0, offset << 1);
8693 break;
8694 case I8_SWRASP:
8695 gen_st(ctx, OPC_SW, 31, 29, imm);
8696 break;
8697 case I8_ADJSP:
8698 gen_arith_imm(env, ctx, OPC_ADDIU, 29, 29, imm);
8699 break;
8700 case I8_SVRS:
8701 {
8702 int xsregs = (ctx->opcode >> 24) & 0x7;
8703 int aregs = (ctx->opcode >> 16) & 0xf;
8704 int do_ra = (ctx->opcode >> 6) & 0x1;
8705 int do_s0 = (ctx->opcode >> 5) & 0x1;
8706 int do_s1 = (ctx->opcode >> 4) & 0x1;
8707 int framesize = (((ctx->opcode >> 20) & 0xf) << 4
8708 | (ctx->opcode & 0xf)) << 3;
8709
8710 if (ctx->opcode & (1 << 7)) {
8711 gen_mips16_save(ctx, xsregs, aregs,
8712 do_ra, do_s0, do_s1,
8713 framesize);
8714 } else {
8715 gen_mips16_restore(ctx, xsregs, aregs,
8716 do_ra, do_s0, do_s1,
8717 framesize);
8718 }
8719 }
8720 break;
8721 default:
8722 generate_exception(ctx, EXCP_RI);
8723 break;
8724 }
8725 break;
8726 case M16_OPC_LI:
8727 tcg_gen_movi_tl(cpu_gpr[rx], (uint16_t) imm);
8728 break;
8729 case M16_OPC_CMPI:
8730 tcg_gen_xori_tl(cpu_gpr[24], cpu_gpr[rx], (uint16_t) imm);
8731 break;
8732 #if defined(TARGET_MIPS64)
8733 case M16_OPC_SD:
8734 gen_st(ctx, OPC_SD, ry, rx, offset);
8735 break;
8736 #endif
8737 case M16_OPC_LB:
8738 gen_ld(env, ctx, OPC_LB, ry, rx, offset);
8739 break;
8740 case M16_OPC_LH:
8741 gen_ld(env, ctx, OPC_LH, ry, rx, offset);
8742 break;
8743 case M16_OPC_LWSP:
8744 gen_ld(env, ctx, OPC_LW, rx, 29, offset);
8745 break;
8746 case M16_OPC_LW:
8747 gen_ld(env, ctx, OPC_LW, ry, rx, offset);
8748 break;
8749 case M16_OPC_LBU:
8750 gen_ld(env, ctx, OPC_LBU, ry, rx, offset);
8751 break;
8752 case M16_OPC_LHU:
8753 gen_ld(env, ctx, OPC_LHU, ry, rx, offset);
8754 break;
8755 case M16_OPC_LWPC:
8756 gen_ld(env, ctx, OPC_LWPC, rx, 0, offset);
8757 break;
8758 #if defined(TARGET_MIPS64)
8759 case M16_OPC_LWU:
8760 gen_ld(env, ctx, OPC_LWU, ry, rx, offset);
8761 break;
8762 #endif
8763 case M16_OPC_SB:
8764 gen_st(ctx, OPC_SB, ry, rx, offset);
8765 break;
8766 case M16_OPC_SH:
8767 gen_st(ctx, OPC_SH, ry, rx, offset);
8768 break;
8769 case M16_OPC_SWSP:
8770 gen_st(ctx, OPC_SW, rx, 29, offset);
8771 break;
8772 case M16_OPC_SW:
8773 gen_st(ctx, OPC_SW, ry, rx, offset);
8774 break;
8775 #if defined(TARGET_MIPS64)
8776 case M16_OPC_I64:
8777 decode_i64_mips16(env, ctx, ry, funct, offset, 1);
8778 break;
8779 #endif
8780 default:
8781 generate_exception(ctx, EXCP_RI);
8782 break;
8783 }
8784
8785 return 4;
8786 }
8787
8788 static int decode_mips16_opc (CPUState *env, DisasContext *ctx,
8789 int *is_branch)
8790 {
8791 int rx, ry;
8792 int sa;
8793 int op, cnvt_op, op1, offset;
8794 int funct;
8795 int n_bytes;
8796
8797 op = (ctx->opcode >> 11) & 0x1f;
8798 sa = (ctx->opcode >> 2) & 0x7;
8799 sa = sa == 0 ? 8 : sa;
8800 rx = xlat((ctx->opcode >> 8) & 0x7);
8801 cnvt_op = (ctx->opcode >> 5) & 0x7;
8802 ry = xlat((ctx->opcode >> 5) & 0x7);
8803 op1 = offset = ctx->opcode & 0x1f;
8804
8805 n_bytes = 2;
8806
8807 switch (op) {
8808 case M16_OPC_ADDIUSP:
8809 {
8810 int16_t imm = ((uint8_t) ctx->opcode) << 2;
8811
8812 gen_arith_imm(env, ctx, OPC_ADDIU, rx, 29, imm);
8813 }
8814 break;
8815 case M16_OPC_ADDIUPC:
8816 gen_addiupc(ctx, rx, ((uint8_t) ctx->opcode) << 2, 0, 0);
8817 break;
8818 case M16_OPC_B:
8819 offset = (ctx->opcode & 0x7ff) << 1;
8820 offset = (int16_t)(offset << 4) >> 4;
8821 gen_compute_branch(ctx, OPC_BEQ, 2, 0, 0, offset);
8822 /* No delay slot, so just process as a normal instruction */
8823 break;
8824 case M16_OPC_JAL:
8825 offset = lduw_code(ctx->pc + 2);
8826 offset = (((ctx->opcode & 0x1f) << 21)
8827 | ((ctx->opcode >> 5) & 0x1f) << 16
8828 | offset) << 2;
8829 op = ((ctx->opcode >> 10) & 0x1) ? OPC_JALXS : OPC_JALS;
8830 gen_compute_branch(ctx, op, 4, rx, ry, offset);
8831 n_bytes = 4;
8832 *is_branch = 1;
8833 break;
8834 case M16_OPC_BEQZ:
8835 gen_compute_branch(ctx, OPC_BEQ, 2, rx, 0, ((int8_t)ctx->opcode) << 1);
8836 /* No delay slot, so just process as a normal instruction */
8837 break;
8838 case M16_OPC_BNEQZ:
8839 gen_compute_branch(ctx, OPC_BNE, 2, rx, 0, ((int8_t)ctx->opcode) << 1);
8840 /* No delay slot, so just process as a normal instruction */
8841 break;
8842 case M16_OPC_SHIFT:
8843 switch (ctx->opcode & 0x3) {
8844 case 0x0:
8845 gen_shift_imm(env, ctx, OPC_SLL, rx, ry, sa);
8846 break;
8847 case 0x1:
8848 #if defined(TARGET_MIPS64)
8849 check_mips_64(ctx);
8850 gen_shift_imm(env, ctx, OPC_DSLL, rx, ry, sa);
8851 #else
8852 generate_exception(ctx, EXCP_RI);
8853 #endif
8854 break;
8855 case 0x2:
8856 gen_shift_imm(env, ctx, OPC_SRL, rx, ry, sa);
8857 break;
8858 case 0x3:
8859 gen_shift_imm(env, ctx, OPC_SRA, rx, ry, sa);
8860 break;
8861 }
8862 break;
8863 #if defined(TARGET_MIPS64)
8864 case M16_OPC_LD:
8865 check_mips_64(ctx);
8866 gen_ld(env, ctx, OPC_LD, ry, rx, offset << 3);
8867 break;
8868 #endif
8869 case M16_OPC_RRIA:
8870 {
8871 int16_t imm = (int8_t)((ctx->opcode & 0xf) << 4) >> 4;
8872
8873 if ((ctx->opcode >> 4) & 1) {
8874 #if defined(TARGET_MIPS64)
8875 check_mips_64(ctx);
8876 gen_arith_imm(env, ctx, OPC_DADDIU, ry, rx, imm);
8877 #else
8878 generate_exception(ctx, EXCP_RI);
8879 #endif
8880 } else {
8881 gen_arith_imm(env, ctx, OPC_ADDIU, ry, rx, imm);
8882 }
8883 }
8884 break;
8885 case M16_OPC_ADDIU8:
8886 {
8887 int16_t imm = (int8_t) ctx->opcode;
8888
8889 gen_arith_imm(env, ctx, OPC_ADDIU, rx, rx, imm);
8890 }
8891 break;
8892 case M16_OPC_SLTI:
8893 {
8894 int16_t imm = (uint8_t) ctx->opcode;
8895
8896 gen_slt_imm(env, OPC_SLTI, 24, rx, imm);
8897 }
8898 break;
8899 case M16_OPC_SLTIU:
8900 {
8901 int16_t imm = (uint8_t) ctx->opcode;
8902
8903 gen_slt_imm(env, OPC_SLTIU, 24, rx, imm);
8904 }
8905 break;
8906 case M16_OPC_I8:
8907 {
8908 int reg32;
8909
8910 funct = (ctx->opcode >> 8) & 0x7;
8911 switch (funct) {
8912 case I8_BTEQZ:
8913 gen_compute_branch(ctx, OPC_BEQ, 2, 24, 0,
8914 ((int8_t)ctx->opcode) << 1);
8915 break;
8916 case I8_BTNEZ:
8917 gen_compute_branch(ctx, OPC_BNE, 2, 24, 0,
8918 ((int8_t)ctx->opcode) << 1);
8919 break;
8920 case I8_SWRASP:
8921 gen_st(ctx, OPC_SW, 31, 29, (ctx->opcode & 0xff) << 2);
8922 break;
8923 case I8_ADJSP:
8924 gen_arith_imm(env, ctx, OPC_ADDIU, 29, 29,
8925 ((int8_t)ctx->opcode) << 3);
8926 break;
8927 case I8_SVRS:
8928 {
8929 int do_ra = ctx->opcode & (1 << 6);
8930 int do_s0 = ctx->opcode & (1 << 5);
8931 int do_s1 = ctx->opcode & (1 << 4);
8932 int framesize = ctx->opcode & 0xf;
8933
8934 if (framesize == 0) {
8935 framesize = 128;
8936 } else {
8937 framesize = framesize << 3;
8938 }
8939
8940 if (ctx->opcode & (1 << 7)) {
8941 gen_mips16_save(ctx, 0, 0,
8942 do_ra, do_s0, do_s1, framesize);
8943 } else {
8944 gen_mips16_restore(ctx, 0, 0,
8945 do_ra, do_s0, do_s1, framesize);
8946 }
8947 }
8948 break;
8949 case I8_MOV32R:
8950 {
8951 int rz = xlat(ctx->opcode & 0x7);
8952
8953 reg32 = (((ctx->opcode >> 3) & 0x3) << 3) |
8954 ((ctx->opcode >> 5) & 0x7);
8955 gen_arith(env, ctx, OPC_ADDU, reg32, rz, 0);
8956 }
8957 break;
8958 case I8_MOVR32:
8959 reg32 = ctx->opcode & 0x1f;
8960 gen_arith(env, ctx, OPC_ADDU, ry, reg32, 0);
8961 break;
8962 default:
8963 generate_exception(ctx, EXCP_RI);
8964 break;
8965 }
8966 }
8967 break;
8968 case M16_OPC_LI:
8969 {
8970 int16_t imm = (uint8_t) ctx->opcode;
8971
8972 gen_arith_imm(env, ctx, OPC_ADDIU, rx, 0, imm);
8973 }
8974 break;
8975 case M16_OPC_CMPI:
8976 {
8977 int16_t imm = (uint8_t) ctx->opcode;
8978
8979 gen_logic_imm(env, OPC_XORI, 24, rx, imm);
8980 }
8981 break;
8982 #if defined(TARGET_MIPS64)
8983 case M16_OPC_SD:
8984 check_mips_64(ctx);
8985 gen_st(ctx, OPC_SD, ry, rx, offset << 3);
8986 break;
8987 #endif
8988 case M16_OPC_LB:
8989 gen_ld(env, ctx, OPC_LB, ry, rx, offset);
8990 break;
8991 case M16_OPC_LH:
8992 gen_ld(env, ctx, OPC_LH, ry, rx, offset << 1);
8993 break;
8994 case M16_OPC_LWSP:
8995 gen_ld(env, ctx, OPC_LW, rx, 29, ((uint8_t)ctx->opcode) << 2);
8996 break;
8997 case M16_OPC_LW:
8998 gen_ld(env, ctx, OPC_LW, ry, rx, offset << 2);
8999 break;
9000 case M16_OPC_LBU:
9001 gen_ld(env, ctx, OPC_LBU, ry, rx, offset);
9002 break;
9003 case M16_OPC_LHU:
9004 gen_ld(env, ctx, OPC_LHU, ry, rx, offset << 1);
9005 break;
9006 case M16_OPC_LWPC:
9007 gen_ld(env, ctx, OPC_LWPC, rx, 0, ((uint8_t)ctx->opcode) << 2);
9008 break;
9009 #if defined (TARGET_MIPS64)
9010 case M16_OPC_LWU:
9011 check_mips_64(ctx);
9012 gen_ld(env, ctx, OPC_LWU, ry, rx, offset << 2);
9013 break;
9014 #endif
9015 case M16_OPC_SB:
9016 gen_st(ctx, OPC_SB, ry, rx, offset);
9017 break;
9018 case M16_OPC_SH:
9019 gen_st(ctx, OPC_SH, ry, rx, offset << 1);
9020 break;
9021 case M16_OPC_SWSP:
9022 gen_st(ctx, OPC_SW, rx, 29, ((uint8_t)ctx->opcode) << 2);
9023 break;
9024 case M16_OPC_SW:
9025 gen_st(ctx, OPC_SW, ry, rx, offset << 2);
9026 break;
9027 case M16_OPC_RRR:
9028 {
9029 int rz = xlat((ctx->opcode >> 2) & 0x7);
9030 int mips32_op;
9031
9032 switch (ctx->opcode & 0x3) {
9033 case RRR_ADDU:
9034 mips32_op = OPC_ADDU;
9035 break;
9036 case RRR_SUBU:
9037 mips32_op = OPC_SUBU;
9038 break;
9039 #if defined(TARGET_MIPS64)
9040 case RRR_DADDU:
9041 mips32_op = OPC_DADDU;
9042 check_mips_64(ctx);
9043 break;
9044 case RRR_DSUBU:
9045 mips32_op = OPC_DSUBU;
9046 check_mips_64(ctx);
9047 break;
9048 #endif
9049 default:
9050 generate_exception(ctx, EXCP_RI);
9051 goto done;
9052 }
9053
9054 gen_arith(env, ctx, mips32_op, rz, rx, ry);
9055 done:
9056 ;
9057 }
9058 break;
9059 case M16_OPC_RR:
9060 switch (op1) {
9061 case RR_JR:
9062 {
9063 int nd = (ctx->opcode >> 7) & 0x1;
9064 int link = (ctx->opcode >> 6) & 0x1;
9065 int ra = (ctx->opcode >> 5) & 0x1;
9066
9067 if (link) {
9068 op = nd ? OPC_JALRC : OPC_JALRS;
9069 } else {
9070 op = OPC_JR;
9071 }
9072
9073 gen_compute_branch(ctx, op, 2, ra ? 31 : rx, 31, 0);
9074 if (!nd) {
9075 *is_branch = 1;
9076 }
9077 }
9078 break;
9079 case RR_SDBBP:
9080 /* XXX: not clear which exception should be raised
9081 * when in debug mode...
9082 */
9083 check_insn(env, ctx, ISA_MIPS32);
9084 if (!(ctx->hflags & MIPS_HFLAG_DM)) {
9085 generate_exception(ctx, EXCP_DBp);
9086 } else {
9087 generate_exception(ctx, EXCP_DBp);
9088 }
9089 break;
9090 case RR_SLT:
9091 gen_slt(env, OPC_SLT, 24, rx, ry);
9092 break;
9093 case RR_SLTU:
9094 gen_slt(env, OPC_SLTU, 24, rx, ry);
9095 break;
9096 case RR_BREAK:
9097 generate_exception(ctx, EXCP_BREAK);
9098 break;
9099 case RR_SLLV:
9100 gen_shift(env, ctx, OPC_SLLV, ry, rx, ry);
9101 break;
9102 case RR_SRLV:
9103 gen_shift(env, ctx, OPC_SRLV, ry, rx, ry);
9104 break;
9105 case RR_SRAV:
9106 gen_shift(env, ctx, OPC_SRAV, ry, rx, ry);
9107 break;
9108 #if defined (TARGET_MIPS64)
9109 case RR_DSRL:
9110 check_mips_64(ctx);
9111 gen_shift_imm(env, ctx, OPC_DSRL, ry, ry, sa);
9112 break;
9113 #endif
9114 case RR_CMP:
9115 gen_logic(env, OPC_XOR, 24, rx, ry);
9116 break;
9117 case RR_NEG:
9118 gen_arith(env, ctx, OPC_SUBU, rx, 0, ry);
9119 break;
9120 case RR_AND:
9121 gen_logic(env, OPC_AND, rx, rx, ry);
9122 break;
9123 case RR_OR:
9124 gen_logic(env, OPC_OR, rx, rx, ry);
9125 break;
9126 case RR_XOR:
9127 gen_logic(env, OPC_XOR, rx, rx, ry);
9128 break;
9129 case RR_NOT:
9130 gen_logic(env, OPC_NOR, rx, ry, 0);
9131 break;
9132 case RR_MFHI:
9133 gen_HILO(ctx, OPC_MFHI, rx);
9134 break;
9135 case RR_CNVT:
9136 switch (cnvt_op) {
9137 case RR_RY_CNVT_ZEB:
9138 tcg_gen_ext8u_tl(cpu_gpr[rx], cpu_gpr[rx]);
9139 break;
9140 case RR_RY_CNVT_ZEH:
9141 tcg_gen_ext16u_tl(cpu_gpr[rx], cpu_gpr[rx]);
9142 break;
9143 case RR_RY_CNVT_SEB:
9144 tcg_gen_ext8s_tl(cpu_gpr[rx], cpu_gpr[rx]);
9145 break;
9146 case RR_RY_CNVT_SEH:
9147 tcg_gen_ext16s_tl(cpu_gpr[rx], cpu_gpr[rx]);
9148 break;
9149 #if defined (TARGET_MIPS64)
9150 case RR_RY_CNVT_ZEW:
9151 check_mips_64(ctx);
9152 tcg_gen_ext32u_tl(cpu_gpr[rx], cpu_gpr[rx]);
9153 break;
9154 case RR_RY_CNVT_SEW:
9155 check_mips_64(ctx);
9156 tcg_gen_ext32s_tl(cpu_gpr[rx], cpu_gpr[rx]);
9157 break;
9158 #endif
9159 default:
9160 generate_exception(ctx, EXCP_RI);
9161 break;
9162 }
9163 break;
9164 case RR_MFLO:
9165 gen_HILO(ctx, OPC_MFLO, rx);
9166 break;
9167 #if defined (TARGET_MIPS64)
9168 case RR_DSRA:
9169 check_mips_64(ctx);
9170 gen_shift_imm(env, ctx, OPC_DSRA, ry, ry, sa);
9171 break;
9172 case RR_DSLLV:
9173 check_mips_64(ctx);
9174 gen_shift(env, ctx, OPC_DSLLV, ry, rx, ry);
9175 break;
9176 case RR_DSRLV:
9177 check_mips_64(ctx);
9178 gen_shift(env, ctx, OPC_DSRLV, ry, rx, ry);
9179 break;
9180 case RR_DSRAV:
9181 check_mips_64(ctx);
9182 gen_shift(env, ctx, OPC_DSRAV, ry, rx, ry);
9183 break;
9184 #endif
9185 case RR_MULT:
9186 gen_muldiv(ctx, OPC_MULT, rx, ry);
9187 break;
9188 case RR_MULTU:
9189 gen_muldiv(ctx, OPC_MULTU, rx, ry);
9190 break;
9191 case RR_DIV:
9192 gen_muldiv(ctx, OPC_DIV, rx, ry);
9193 break;
9194 case RR_DIVU:
9195 gen_muldiv(ctx, OPC_DIVU, rx, ry);
9196 break;
9197 #if defined (TARGET_MIPS64)
9198 case RR_DMULT:
9199 check_mips_64(ctx);
9200 gen_muldiv(ctx, OPC_DMULT, rx, ry);
9201 break;
9202 case RR_DMULTU:
9203 check_mips_64(ctx);
9204 gen_muldiv(ctx, OPC_DMULTU, rx, ry);
9205 break;
9206 case RR_DDIV:
9207 check_mips_64(ctx);
9208 gen_muldiv(ctx, OPC_DDIV, rx, ry);
9209 break;
9210 case RR_DDIVU:
9211 check_mips_64(ctx);
9212 gen_muldiv(ctx, OPC_DDIVU, rx, ry);
9213 break;
9214 #endif
9215 default:
9216 generate_exception(ctx, EXCP_RI);
9217 break;
9218 }
9219 break;
9220 case M16_OPC_EXTEND:
9221 decode_extended_mips16_opc(env, ctx, is_branch);
9222 n_bytes = 4;
9223 break;
9224 #if defined(TARGET_MIPS64)
9225 case M16_OPC_I64:
9226 funct = (ctx->opcode >> 8) & 0x7;
9227 decode_i64_mips16(env, ctx, ry, funct, offset, 0);
9228 break;
9229 #endif
9230 default:
9231 generate_exception(ctx, EXCP_RI);
9232 break;
9233 }
9234
9235 return n_bytes;
9236 }
9237
9238 /* microMIPS extension to MIPS32 */
9239
9240 /* microMIPS32 major opcodes */
9241
9242 enum {
9243 POOL32A = 0x00,
9244 POOL16A = 0x01,
9245 LBU16 = 0x02,
9246 MOVE16 = 0x03,
9247 ADDI32 = 0x04,
9248 LBU32 = 0x05,
9249 SB32 = 0x06,
9250 LB32 = 0x07,
9251
9252 POOL32B = 0x08,
9253 POOL16B = 0x09,
9254 LHU16 = 0x0a,
9255 ANDI16 = 0x0b,
9256 ADDIU32 = 0x0c,
9257 LHU32 = 0x0d,
9258 SH32 = 0x0e,
9259 LH32 = 0x0f,
9260
9261 POOL32I = 0x10,
9262 POOL16C = 0x11,
9263 LWSP16 = 0x12,
9264 POOL16D = 0x13,
9265 ORI32 = 0x14,
9266 POOL32F = 0x15,
9267 POOL32S = 0x16,
9268 DADDIU32 = 0x17,
9269
9270 POOL32C = 0x18,
9271 LWGP16 = 0x19,
9272 LW16 = 0x1a,
9273 POOL16E = 0x1b,
9274 XORI32 = 0x1c,
9275 JALS32 = 0x1d,
9276 ADDIUPC = 0x1e,
9277 POOL48A = 0x1f,
9278
9279 /* 0x20 is reserved */
9280 RES_20 = 0x20,
9281 POOL16F = 0x21,
9282 SB16 = 0x22,
9283 BEQZ16 = 0x23,
9284 SLTI32 = 0x24,
9285 BEQ32 = 0x25,
9286 SWC132 = 0x26,
9287 LWC132 = 0x27,
9288
9289 /* 0x28 and 0x29 are reserved */
9290 RES_28 = 0x28,
9291 RES_29 = 0x29,
9292 SH16 = 0x2a,
9293 BNEZ16 = 0x2b,
9294 SLTIU32 = 0x2c,
9295 BNE32 = 0x2d,
9296 SDC132 = 0x2e,
9297 LDC132 = 0x2f,
9298
9299 /* 0x30 and 0x31 are reserved */
9300 RES_30 = 0x30,
9301 RES_31 = 0x31,
9302 SWSP16 = 0x32,
9303 B16 = 0x33,
9304 ANDI32 = 0x34,
9305 J32 = 0x35,
9306 SD32 = 0x36,
9307 LD32 = 0x37,
9308
9309 /* 0x38 and 0x39 are reserved */
9310 RES_38 = 0x38,
9311 RES_39 = 0x39,
9312 SW16 = 0x3a,
9313 LI16 = 0x3b,
9314 JALX32 = 0x3c,
9315 JAL32 = 0x3d,
9316 SW32 = 0x3e,
9317 LW32 = 0x3f
9318 };
9319
9320 /* POOL32A encoding of minor opcode field */
9321
9322 enum {
9323 /* These opcodes are distinguished only by bits 9..6; those bits are
9324 * what are recorded below. */
9325 SLL32 = 0x0,
9326 SRL32 = 0x1,
9327 SRA = 0x2,
9328 ROTR = 0x3,
9329
9330 SLLV = 0x0,
9331 SRLV = 0x1,
9332 SRAV = 0x2,
9333 ROTRV = 0x3,
9334 ADD = 0x4,
9335 ADDU32 = 0x5,
9336 SUB = 0x6,
9337 SUBU32 = 0x7,
9338 MUL = 0x8,
9339 AND = 0x9,
9340 OR32 = 0xa,
9341 NOR = 0xb,
9342 XOR32 = 0xc,
9343 SLT = 0xd,
9344 SLTU = 0xe,
9345
9346 MOVN = 0x0,
9347 MOVZ = 0x1,
9348 LWXS = 0x4,
9349
9350 /* The following can be distinguished by their lower 6 bits. */
9351 INS = 0x0c,
9352 EXT = 0x2c,
9353 POOL32AXF = 0x3c
9354 };
9355
9356 /* POOL32AXF encoding of minor opcode field extension */
9357
9358 enum {
9359 /* bits 11..6 */
9360 TEQ = 0x00,
9361 TGE = 0x08,
9362 TGEU = 0x10,
9363 TLT = 0x20,
9364 TLTU = 0x28,
9365 TNE = 0x30,
9366
9367 MFC0 = 0x03,
9368 MTC0 = 0x0b,
9369
9370 /* bits 13..12 for 0x01 */
9371 MFHI_ACC = 0x0,
9372 MFLO_ACC = 0x1,
9373 MTHI_ACC = 0x2,
9374 MTLO_ACC = 0x3,
9375
9376 /* bits 13..12 for 0x2a */
9377 MADD_ACC = 0x0,
9378 MADDU_ACC = 0x1,
9379 MSUB_ACC = 0x2,
9380 MSUBU_ACC = 0x3,
9381
9382 /* bits 13..12 for 0x32 */
9383 MULT_ACC = 0x0,
9384 MULTU_ACC = 0x0,
9385
9386 /* bits 15..12 for 0x2c */
9387 SEB = 0x2,
9388 SEH = 0x3,
9389 CLO = 0x4,
9390 CLZ = 0x5,
9391 RDHWR = 0x6,
9392 WSBH = 0x7,
9393 MULT = 0x8,
9394 MULTU = 0x9,
9395 DIV = 0xa,
9396 DIVU = 0xb,
9397 MADD = 0xc,
9398 MADDU = 0xd,
9399 MSUB = 0xe,
9400 MSUBU = 0xf,
9401
9402 /* bits 15..12 for 0x34 */
9403 MFC2 = 0x4,
9404 MTC2 = 0x5,
9405 MFHC2 = 0x8,
9406 MTHC2 = 0x9,
9407 CFC2 = 0xc,
9408 CTC2 = 0xd,
9409
9410 /* bits 15..12 for 0x3c */
9411 JALR = 0x0,
9412 JR = 0x0, /* alias */
9413 JALR_HB = 0x1,
9414 JALRS = 0x4,
9415 JALRS_HB = 0x5,
9416
9417 /* bits 15..12 for 0x05 */
9418 RDPGPR = 0xe,
9419 WRPGPR = 0xf,
9420
9421 /* bits 15..12 for 0x0d */
9422 TLBP = 0x0,
9423 TLBR = 0x1,
9424 TLBWI = 0x2,
9425 TLBWR = 0x3,
9426 WAIT = 0x9,
9427 IRET = 0xd,
9428 DERET = 0xe,
9429 ERET = 0xf,
9430
9431 /* bits 15..12 for 0x15 */
9432 DMT = 0x0,
9433 DVPE = 0x1,
9434 EMT = 0x2,
9435 EVPE = 0x3,
9436
9437 /* bits 15..12 for 0x1d */
9438 DI = 0x4,
9439 EI = 0x5,
9440
9441 /* bits 15..12 for 0x2d */
9442 SYNC = 0x6,
9443 SYSCALL = 0x8,
9444 SDBBP = 0xd,
9445
9446 /* bits 15..12 for 0x35 */
9447 MFHI32 = 0x0,
9448 MFLO32 = 0x1,
9449 MTHI32 = 0x2,
9450 MTLO32 = 0x3,
9451 };
9452
9453 /* POOL32B encoding of minor opcode field (bits 15..12) */
9454
9455 enum {
9456 LWC2 = 0x0,
9457 LWP = 0x1,
9458 LDP = 0x4,
9459 LWM32 = 0x5,
9460 CACHE = 0x6,
9461 LDM = 0x7,
9462 SWC2 = 0x8,
9463 SWP = 0x9,
9464 SDP = 0xc,
9465 SWM32 = 0xd,
9466 SDM = 0xf
9467 };
9468
9469 /* POOL32C encoding of minor opcode field (bits 15..12) */
9470
9471 enum {
9472 LWL = 0x0,
9473 SWL = 0x8,
9474 LWR = 0x1,
9475 SWR = 0x9,
9476 PREF = 0x2,
9477 /* 0xa is reserved */
9478 LL = 0x3,
9479 SC = 0xb,
9480 LDL = 0x4,
9481 SDL = 0xc,
9482 LDR = 0x5,
9483 SDR = 0xd,
9484 /* 0x6 is reserved */
9485 LWU = 0xe,
9486 LLD = 0x7,
9487 SCD = 0xf
9488 };
9489
9490 /* POOL32F encoding of minor opcode field (bits 5..0) */
9491
9492 enum {
9493 /* These are the bit 7..6 values */
9494 ADD_FMT = 0x0,
9495 MOVN_FMT = 0x0,
9496
9497 SUB_FMT = 0x1,
9498 MOVZ_FMT = 0x1,
9499
9500 MUL_FMT = 0x2,
9501
9502 DIV_FMT = 0x3,
9503
9504 /* These are the bit 8..6 values */
9505 RSQRT2_FMT = 0x0,
9506 MOVF_FMT = 0x0,
9507
9508 LWXC1 = 0x1,
9509 MOVT_FMT = 0x1,
9510
9511 PLL_PS = 0x2,
9512 SWXC1 = 0x2,
9513
9514 PLU_PS = 0x3,
9515 LDXC1 = 0x3,
9516
9517 PUL_PS = 0x4,
9518 SDXC1 = 0x4,
9519 RECIP2_FMT = 0x4,
9520
9521 PUU_PS = 0x5,
9522 LUXC1 = 0x5,
9523
9524 CVT_PS_S = 0x6,
9525 SUXC1 = 0x6,
9526 ADDR_PS = 0x6,
9527 PREFX = 0x6,
9528
9529 MULR_PS = 0x7,
9530
9531 MADD_S = 0x01,
9532 MADD_D = 0x09,
9533 MADD_PS = 0x11,
9534 ALNV_PS = 0x19,
9535 MSUB_S = 0x21,
9536 MSUB_D = 0x29,
9537 MSUB_PS = 0x31,
9538
9539 NMADD_S = 0x02,
9540 NMADD_D = 0x0a,
9541 NMADD_PS = 0x12,
9542 NMSUB_S = 0x22,
9543 NMSUB_D = 0x2a,
9544 NMSUB_PS = 0x32,
9545
9546 POOL32FXF = 0x3b,
9547
9548 CABS_COND_FMT = 0x1c, /* MIPS3D */
9549 C_COND_FMT = 0x3c
9550 };
9551
9552 /* POOL32Fxf encoding of minor opcode extension field */
9553
9554 enum {
9555 CVT_L = 0x04,
9556 RSQRT_FMT = 0x08,
9557 FLOOR_L = 0x0c,
9558 CVT_PW_PS = 0x1c,
9559 CVT_W = 0x24,
9560 SQRT_FMT = 0x28,
9561 FLOOR_W = 0x2c,
9562 CVT_PS_PW = 0x3c,
9563 CFC1 = 0x40,
9564 RECIP_FMT = 0x48,
9565 CEIL_L = 0x4c,
9566 CTC1 = 0x60,
9567 CEIL_W = 0x6c,
9568 MFC1 = 0x80,
9569 CVT_S_PL = 0x84,
9570 TRUNC_L = 0x8c,
9571 MTC1 = 0xa0,
9572 CVT_S_PU = 0xa4,
9573 TRUNC_W = 0xac,
9574 MFHC1 = 0xc0,
9575 ROUND_L = 0xcc,
9576 MTHC1 = 0xe0,
9577 ROUND_W = 0xec,
9578
9579 MOV_FMT = 0x01,
9580 MOVF = 0x05,
9581 ABS_FMT = 0x0d,
9582 RSQRT1_FMT = 0x1d,
9583 MOVT = 0x25,
9584 NEG_FMT = 0x2d,
9585 CVT_D = 0x4d,
9586 RECIP1_FMT = 0x5d,
9587 CVT_S = 0x6d
9588 };
9589
9590 /* POOL32I encoding of minor opcode field (bits 25..21) */
9591
9592 enum {
9593 BLTZ = 0x00,
9594 BLTZAL = 0x01,
9595 BGEZ = 0x02,
9596 BGEZAL = 0x03,
9597 BLEZ = 0x04,
9598 BNEZC = 0x05,
9599 BGTZ = 0x06,
9600 BEQZC = 0x07,
9601 TLTI = 0x08,
9602 TGEI = 0x09,
9603 TLTIU = 0x0a,
9604 TGEIU = 0x0b,
9605 TNEI = 0x0c,
9606 LUI = 0x0d,
9607 TEQI = 0x0e,
9608 SYNCI = 0x10,
9609 BLTZALS = 0x11,
9610 BGEZALS = 0x13,
9611 BC2F = 0x14,
9612 BC2T = 0x15,
9613 BPOSGE64 = 0x1a,
9614 BPOSGE32 = 0x1b,
9615 /* These overlap and are distinguished by bit16 of the instruction */
9616 BC1F = 0x1c,
9617 BC1T = 0x1d,
9618 BC1ANY2F = 0x1c,
9619 BC1ANY2T = 0x1d,
9620 BC1ANY4F = 0x1e,
9621 BC1ANY4T = 0x1f
9622 };
9623
9624 /* POOL16A encoding of minor opcode field */
9625
9626 enum {
9627 ADDU16 = 0x0,
9628 SUBU16 = 0x1
9629 };
9630
9631 /* POOL16B encoding of minor opcode field */
9632
9633 enum {
9634 SLL16 = 0x0,
9635 SRL16 = 0x1
9636 };
9637
9638 /* POOL16C encoding of minor opcode field */
9639
9640 enum {
9641 NOT16 = 0x00,
9642 XOR16 = 0x04,
9643 AND16 = 0x08,
9644 OR16 = 0x0c,
9645 LWM16 = 0x10,
9646 SWM16 = 0x14,
9647 JR16 = 0x18,
9648 JRC16 = 0x1a,
9649 JALR16 = 0x1c,
9650 JALR16S = 0x1e,
9651 MFHI16 = 0x20,
9652 MFLO16 = 0x24,
9653 BREAK16 = 0x28,
9654 SDBBP16 = 0x2c,
9655 JRADDIUSP = 0x30
9656 };
9657
9658 /* POOL16D encoding of minor opcode field */
9659
9660 enum {
9661 ADDIUS5 = 0x0,
9662 ADDIUSP = 0x1
9663 };
9664
9665 /* POOL16E encoding of minor opcode field */
9666
9667 enum {
9668 ADDIUR2 = 0x0,
9669 ADDIUR1SP = 0x1
9670 };
9671
9672 static int mmreg (int r)
9673 {
9674 static const int map[] = { 16, 17, 2, 3, 4, 5, 6, 7 };
9675
9676 return map[r];
9677 }
9678
9679 /* Used for 16-bit store instructions. */
9680 static int mmreg2 (int r)
9681 {
9682 static const int map[] = { 0, 17, 2, 3, 4, 5, 6, 7 };
9683
9684 return map[r];
9685 }
9686
9687 #define uMIPS_RD(op) ((op >> 7) & 0x7)
9688 #define uMIPS_RS(op) ((op >> 4) & 0x7)
9689 #define uMIPS_RS2(op) uMIPS_RS(op)
9690 #define uMIPS_RS1(op) ((op >> 1) & 0x7)
9691 #define uMIPS_RD5(op) ((op >> 5) & 0x1f)
9692 #define uMIPS_RS5(op) (op & 0x1f)
9693
9694 /* Signed immediate */
9695 #define SIMM(op, start, width) \
9696 ((int32_t)(((op >> start) & ((~0U) >> (32-width))) \
9697 << (32-width)) \
9698 >> (32-width))
9699 /* Zero-extended immediate */
9700 #define ZIMM(op, start, width) ((op >> start) & ((~0U) >> (32-width)))
9701
9702 static void gen_addiur1sp (CPUState *env, DisasContext *ctx)
9703 {
9704 int rd = mmreg(uMIPS_RD(ctx->opcode));
9705
9706 gen_arith_imm(env, ctx, OPC_ADDIU, rd, 29, ((ctx->opcode >> 1) & 0x3f) << 2);
9707 }
9708
9709 static void gen_addiur2 (CPUState *env, DisasContext *ctx)
9710 {
9711 static const int decoded_imm[] = { 1, 4, 8, 12, 16, 20, 24, -1 };
9712 int rd = mmreg(uMIPS_RD(ctx->opcode));
9713 int rs = mmreg(uMIPS_RS(ctx->opcode));
9714
9715 gen_arith_imm(env, ctx, OPC_ADDIU, rd, rs, decoded_imm[ZIMM(ctx->opcode, 1, 3)]);
9716 }
9717
9718 static void gen_addiusp (CPUState *env, DisasContext *ctx)
9719 {
9720 int encoded = ZIMM(ctx->opcode, 1, 9);
9721 int decoded;
9722
9723 if (encoded <= 1) {
9724 decoded = 256 + encoded;
9725 } else if (encoded <= 255) {
9726 decoded = encoded;
9727 } else if (encoded <= 509) {
9728 decoded = encoded - 512;
9729 } else {
9730 decoded = encoded - 768;
9731 }
9732
9733 gen_arith_imm(env, ctx, OPC_ADDIU, 29, 29, decoded << 2);
9734 }
9735
9736 static void gen_addius5 (CPUState *env, DisasContext *ctx)
9737 {
9738 int imm = SIMM(ctx->opcode, 1, 4);
9739 int rd = (ctx->opcode >> 5) & 0x1f;
9740
9741 gen_arith_imm(env, ctx, OPC_ADDIU, rd, rd, imm);
9742 }
9743
9744 static void gen_andi16 (CPUState *env, DisasContext *ctx)
9745 {
9746 static const int decoded_imm[] = { 128, 1, 2, 3, 4, 7, 8, 15, 16,
9747 31, 32, 63, 64, 255, 32768, 65535 };
9748 int rd = mmreg(uMIPS_RD(ctx->opcode));
9749 int rs = mmreg(uMIPS_RS(ctx->opcode));
9750 int encoded = ZIMM(ctx->opcode, 0, 4);
9751
9752 gen_logic_imm(env, OPC_ANDI, rd, rs, decoded_imm[encoded]);
9753 }
9754
9755 static void gen_ldst_multiple (DisasContext *ctx, uint32_t opc, int reglist,
9756 int base, int16_t offset)
9757 {
9758 TCGv t0, t1;
9759 TCGv_i32 t2;
9760
9761 if (ctx->hflags & MIPS_HFLAG_BMASK) {
9762 generate_exception(ctx, EXCP_RI);
9763 return;
9764 }
9765
9766 t0 = tcg_temp_new();
9767
9768 gen_base_offset_addr(ctx, t0, base, offset);
9769
9770 t1 = tcg_const_tl(reglist);
9771 t2 = tcg_const_i32(ctx->mem_idx);
9772
9773 save_cpu_state(ctx, 1);
9774 switch (opc) {
9775 case LWM32:
9776 gen_helper_lwm(t0, t1, t2);
9777 break;
9778 case SWM32:
9779 gen_helper_swm(t0, t1, t2);
9780 break;
9781 #ifdef TARGET_MIPS64
9782 case LDM:
9783 gen_helper_ldm(t0, t1, t2);
9784 break;
9785 case SDM:
9786 gen_helper_sdm(t0, t1, t2);
9787 break;
9788 #endif
9789 }
9790 MIPS_DEBUG("%s, %x, %d(%s)", opn, reglist, offset, regnames[base]);
9791 tcg_temp_free(t0);
9792 tcg_temp_free(t1);
9793 tcg_temp_free_i32(t2);
9794 }
9795
9796
9797 static void gen_pool16c_insn (CPUState *env, DisasContext *ctx, int *is_branch)
9798 {
9799 int rd = mmreg((ctx->opcode >> 3) & 0x7);
9800 int rs = mmreg(ctx->opcode & 0x7);
9801 int opc;
9802
9803 switch (((ctx->opcode) >> 4) & 0x3f) {
9804 case NOT16 + 0:
9805 case NOT16 + 1:
9806 case NOT16 + 2:
9807 case NOT16 + 3:
9808 gen_logic(env, OPC_NOR, rd, rs, 0);
9809 break;
9810 case XOR16 + 0:
9811 case XOR16 + 1:
9812 case XOR16 + 2:
9813 case XOR16 + 3:
9814 gen_logic(env, OPC_XOR, rd, rd, rs);
9815 break;
9816 case AND16 + 0:
9817 case AND16 + 1:
9818 case AND16 + 2:
9819 case AND16 + 3:
9820 gen_logic(env, OPC_AND, rd, rd, rs);
9821 break;
9822 case OR16 + 0:
9823 case OR16 + 1:
9824 case OR16 + 2:
9825 case OR16 + 3:
9826 gen_logic(env, OPC_OR, rd, rd, rs);
9827 break;
9828 case LWM16 + 0:
9829 case LWM16 + 1:
9830 case LWM16 + 2:
9831 case LWM16 + 3:
9832 {
9833 static const int lwm_convert[] = { 0x11, 0x12, 0x13, 0x14 };
9834 int offset = ZIMM(ctx->opcode, 0, 4);
9835
9836 gen_ldst_multiple(ctx, LWM32, lwm_convert[(ctx->opcode >> 4) & 0x3],
9837 29, offset << 2);
9838 }
9839 break;
9840 case SWM16 + 0:
9841 case SWM16 + 1:
9842 case SWM16 + 2:
9843 case SWM16 + 3:
9844 {
9845 static const int swm_convert[] = { 0x11, 0x12, 0x13, 0x14 };
9846 int offset = ZIMM(ctx->opcode, 0, 4);
9847
9848 gen_ldst_multiple(ctx, SWM32, swm_convert[(ctx->opcode >> 4) & 0x3],
9849 29, offset << 2);
9850 }
9851 break;
9852 case JR16 + 0:
9853 case JR16 + 1:
9854 {
9855 int reg = ctx->opcode & 0x1f;
9856
9857 gen_compute_branch(ctx, OPC_JR, 2, reg, 0, 0);
9858 }
9859 *is_branch = 1;
9860 break;
9861 case JRC16 + 0:
9862 case JRC16 + 1:
9863 {
9864 int reg = ctx->opcode & 0x1f;
9865
9866 gen_compute_branch(ctx, OPC_JR, 2, reg, 0, 0);
9867 /* Let normal delay slot handling in our caller take us
9868 to the branch target. */
9869 }
9870 break;
9871 case JALR16 + 0:
9872 case JALR16 + 1:
9873 opc = OPC_JALR;
9874 goto do_jalr;
9875 case JALR16S + 0:
9876 case JALR16S + 1:
9877 opc = OPC_JALRS;
9878 do_jalr:
9879 {
9880 int reg = ctx->opcode & 0x1f;
9881
9882 gen_compute_branch(ctx, opc, 2, reg, 31, 0);
9883 }
9884 *is_branch = 1;
9885 break;
9886 case MFHI16 + 0:
9887 case MFHI16 + 1:
9888 gen_HILO(ctx, OPC_MFHI, uMIPS_RS5(ctx->opcode));
9889 break;
9890 case MFLO16 + 0:
9891 case MFLO16 + 1:
9892 gen_HILO(ctx, OPC_MFLO, uMIPS_RS5(ctx->opcode));
9893 break;
9894 case BREAK16:
9895 generate_exception(ctx, EXCP_BREAK);
9896 break;
9897 case SDBBP16:
9898 /* XXX: not clear which exception should be raised
9899 * when in debug mode...
9900 */
9901 check_insn(env, ctx, ISA_MIPS32);
9902 if (!(ctx->hflags & MIPS_HFLAG_DM)) {
9903 generate_exception(ctx, EXCP_DBp);
9904 } else {
9905 generate_exception(ctx, EXCP_DBp);
9906 }
9907 break;
9908 case JRADDIUSP + 0:
9909 case JRADDIUSP + 1:
9910 {
9911 int imm = ZIMM(ctx->opcode, 0, 5);
9912
9913 gen_compute_branch(ctx, OPC_JR, 2, 31, 0, 0);
9914 gen_arith_imm(env, ctx, OPC_ADDIU, 29, 29, imm << 2);
9915 /* Let normal delay slot handling in our caller take us
9916 to the branch target. */
9917 }
9918 break;
9919 default:
9920 generate_exception(ctx, EXCP_RI);
9921 break;
9922 }
9923 }
9924
9925 static void gen_ldxs (DisasContext *ctx, int base, int index, int rd)
9926 {
9927 TCGv t0 = tcg_temp_new();
9928 TCGv t1 = tcg_temp_new();
9929
9930 gen_load_gpr(t0, base);
9931
9932 if (index != 0) {
9933 gen_load_gpr(t1, index);
9934 tcg_gen_shli_tl(t1, t1, 2);
9935 gen_op_addr_add(ctx, t0, t1, t0);
9936 }
9937
9938 save_cpu_state(ctx, 0);
9939 op_ld_lw(t1, t0, ctx);
9940 gen_store_gpr(t1, rd);
9941
9942 tcg_temp_free(t0);
9943 tcg_temp_free(t1);
9944 }
9945
9946 static void gen_ldst_pair (DisasContext *ctx, uint32_t opc, int rd,
9947 int base, int16_t offset)
9948 {
9949 const char *opn = "ldst_pair";
9950 TCGv t0, t1;
9951
9952 if (ctx->hflags & MIPS_HFLAG_BMASK || rd == 31 || rd == base) {
9953 generate_exception(ctx, EXCP_RI);
9954 return;
9955 }
9956
9957 t0 = tcg_temp_new();
9958 t1 = tcg_temp_new();
9959
9960 gen_base_offset_addr(ctx, t0, base, offset);
9961
9962 switch (opc) {
9963 case LWP:
9964 save_cpu_state(ctx, 0);
9965 op_ld_lw(t1, t0, ctx);
9966 gen_store_gpr(t1, rd);
9967 tcg_gen_movi_tl(t1, 4);
9968 gen_op_addr_add(ctx, t0, t0, t1);
9969 op_ld_lw(t1, t0, ctx);
9970 gen_store_gpr(t1, rd+1);
9971 opn = "lwp";
9972 break;
9973 case SWP:
9974 save_cpu_state(ctx, 0);
9975 gen_load_gpr(t1, rd);
9976 op_st_sw(t1, t0, ctx);
9977 tcg_gen_movi_tl(t1, 4);
9978 gen_op_addr_add(ctx, t0, t0, t1);
9979 gen_load_gpr(t1, rd+1);
9980 op_st_sw(t1, t0, ctx);
9981 opn = "swp";
9982 break;
9983 #ifdef TARGET_MIPS64
9984 case LDP:
9985 save_cpu_state(ctx, 0);
9986 op_ld_ld(t1, t0, ctx);
9987 gen_store_gpr(t1, rd);
9988 tcg_gen_movi_tl(t1, 8);
9989 gen_op_addr_add(ctx, t0, t0, t1);
9990 op_ld_ld(t1, t0, ctx);
9991 gen_store_gpr(t1, rd+1);
9992 opn = "ldp";
9993 break;
9994 case SDP:
9995 save_cpu_state(ctx, 0);
9996 gen_load_gpr(t1, rd);
9997 op_st_sd(t1, t0, ctx);
9998 tcg_gen_movi_tl(t1, 8);
9999 gen_op_addr_add(ctx, t0, t0, t1);
10000 gen_load_gpr(t1, rd+1);
10001 op_st_sd(t1, t0, ctx);
10002 opn = "sdp";
10003 break;
10004 #endif
10005 }
10006 (void)opn; /* avoid a compiler warning */
10007 MIPS_DEBUG("%s, %s, %d(%s)", opn, regnames[rd], offset, regnames[base]);
10008 tcg_temp_free(t0);
10009 tcg_temp_free(t1);
10010 }
10011
10012 static void gen_pool32axf (CPUState *env, DisasContext *ctx, int rt, int rs,
10013 int *is_branch)
10014 {
10015 int extension = (ctx->opcode >> 6) & 0x3f;
10016 int minor = (ctx->opcode >> 12) & 0xf;
10017 uint32_t mips32_op;
10018
10019 switch (extension) {
10020 case TEQ:
10021 mips32_op = OPC_TEQ;
10022 goto do_trap;
10023 case TGE:
10024 mips32_op = OPC_TGE;
10025 goto do_trap;
10026 case TGEU:
10027 mips32_op = OPC_TGEU;
10028 goto do_trap;
10029 case TLT:
10030 mips32_op = OPC_TLT;
10031 goto do_trap;
10032 case TLTU:
10033 mips32_op = OPC_TLTU;
10034 goto do_trap;
10035 case TNE:
10036 mips32_op = OPC_TNE;
10037 do_trap:
10038 gen_trap(ctx, mips32_op, rs, rt, -1);
10039 break;
10040 #ifndef CONFIG_USER_ONLY
10041 case MFC0:
10042 case MFC0 + 32:
10043 if (rt == 0) {
10044 /* Treat as NOP. */
10045 break;
10046 }
10047 gen_mfc0(env, ctx, cpu_gpr[rt], rs, (ctx->opcode >> 11) & 0x7);
10048 break;
10049 case MTC0:
10050 case MTC0 + 32:
10051 {
10052 TCGv t0 = tcg_temp_new();
10053
10054 gen_load_gpr(t0, rt);
10055 gen_mtc0(env, ctx, t0, rs, (ctx->opcode >> 11) & 0x7);
10056 tcg_temp_free(t0);
10057 }
10058 break;
10059 #endif
10060 case 0x2c:
10061 switch (minor) {
10062 case SEB:
10063 gen_bshfl(ctx, OPC_SEB, rs, rt);
10064 break;
10065 case SEH:
10066 gen_bshfl(ctx, OPC_SEH, rs, rt);
10067 break;
10068 case CLO:
10069 mips32_op = OPC_CLO;
10070 goto do_cl;
10071 case CLZ:
10072 mips32_op = OPC_CLZ;
10073 do_cl:
10074 check_insn(env, ctx, ISA_MIPS32);
10075 gen_cl(ctx, mips32_op, rt, rs);
10076 break;
10077 case RDHWR:
10078 gen_rdhwr(env, ctx, rt, rs);
10079 break;
10080 case WSBH:
10081 gen_bshfl(ctx, OPC_WSBH, rs, rt);
10082 break;
10083 case MULT:
10084 mips32_op = OPC_MULT;
10085 goto do_muldiv;
10086 case MULTU:
10087 mips32_op = OPC_MULTU;
10088 goto do_muldiv;
10089 case DIV:
10090 mips32_op = OPC_DIV;
10091 goto do_muldiv;
10092 case DIVU:
10093 mips32_op = OPC_DIVU;
10094 goto do_muldiv;
10095 case MADD:
10096 mips32_op = OPC_MADD;
10097 goto do_muldiv;
10098 case MADDU:
10099 mips32_op = OPC_MADDU;
10100 goto do_muldiv;
10101 case MSUB:
10102 mips32_op = OPC_MSUB;
10103 goto do_muldiv;
10104 case MSUBU:
10105 mips32_op = OPC_MSUBU;
10106 do_muldiv:
10107 check_insn(env, ctx, ISA_MIPS32);
10108 gen_muldiv(ctx, mips32_op, rs, rt);
10109 break;
10110 default:
10111 goto pool32axf_invalid;
10112 }
10113 break;
10114 case 0x34:
10115 switch (minor) {
10116 case MFC2:
10117 case MTC2:
10118 case MFHC2:
10119 case MTHC2:
10120 case CFC2:
10121 case CTC2:
10122 generate_exception_err(ctx, EXCP_CpU, 2);
10123 break;
10124 default:
10125 goto pool32axf_invalid;
10126 }
10127 break;
10128 case 0x3c:
10129 switch (minor) {
10130 case JALR:
10131 case JALR_HB:
10132 gen_compute_branch (ctx, OPC_JALR, 4, rs, rt, 0);
10133 *is_branch = 1;
10134 break;
10135 case JALRS:
10136 case JALRS_HB:
10137 gen_compute_branch (ctx, OPC_JALRS, 4, rs, rt, 0);
10138 *is_branch = 1;
10139 break;
10140 default:
10141 goto pool32axf_invalid;
10142 }
10143 break;
10144 case 0x05:
10145 switch (minor) {
10146 case RDPGPR:
10147 check_insn(env, ctx, ISA_MIPS32R2);
10148 gen_load_srsgpr(rt, rs);
10149 break;
10150 case WRPGPR:
10151 check_insn(env, ctx, ISA_MIPS32R2);
10152 gen_store_srsgpr(rt, rs);
10153 break;
10154 default:
10155 goto pool32axf_invalid;
10156 }
10157 break;
10158 #ifndef CONFIG_USER_ONLY
10159 case 0x0d:
10160 switch (minor) {
10161 case TLBP:
10162 mips32_op = OPC_TLBP;
10163 goto do_cp0;
10164 case TLBR:
10165 mips32_op = OPC_TLBR;
10166 goto do_cp0;
10167 case TLBWI:
10168 mips32_op = OPC_TLBWI;
10169 goto do_cp0;
10170 case TLBWR:
10171 mips32_op = OPC_TLBWR;
10172 goto do_cp0;
10173 case WAIT:
10174 mips32_op = OPC_WAIT;
10175 goto do_cp0;
10176 case DERET:
10177 mips32_op = OPC_DERET;
10178 goto do_cp0;
10179 case ERET:
10180 mips32_op = OPC_ERET;
10181 do_cp0:
10182 gen_cp0(env, ctx, mips32_op, rt, rs);
10183 break;
10184 default:
10185 goto pool32axf_invalid;
10186 }
10187 break;
10188 case 0x1d:
10189 switch (minor) {
10190 case DI:
10191 {
10192 TCGv t0 = tcg_temp_new();
10193
10194 save_cpu_state(ctx, 1);
10195 gen_helper_di(t0);
10196 gen_store_gpr(t0, rs);
10197 /* Stop translation as we may have switched the execution mode */
10198 ctx->bstate = BS_STOP;
10199 tcg_temp_free(t0);
10200 }
10201 break;
10202 case EI:
10203 {
10204 TCGv t0 = tcg_temp_new();
10205
10206 save_cpu_state(ctx, 1);
10207 gen_helper_ei(t0);
10208 gen_store_gpr(t0, rs);
10209 /* Stop translation as we may have switched the execution mode */
10210 ctx->bstate = BS_STOP;
10211 tcg_temp_free(t0);
10212 }
10213 break;
10214 default:
10215 goto pool32axf_invalid;
10216 }
10217 break;
10218 #endif
10219 case 0x2d:
10220 switch (minor) {
10221 case SYNC:
10222 /* NOP */
10223 break;
10224 case SYSCALL:
10225 generate_exception(ctx, EXCP_SYSCALL);
10226 ctx->bstate = BS_STOP;
10227 break;
10228 case SDBBP:
10229 check_insn(env, ctx, ISA_MIPS32);
10230 if (!(ctx->hflags & MIPS_HFLAG_DM)) {
10231 generate_exception(ctx, EXCP_DBp);
10232 } else {
10233 generate_exception(ctx, EXCP_DBp);
10234 }
10235 break;
10236 default:
10237 goto pool32axf_invalid;
10238 }
10239 break;
10240 case 0x35:
10241 switch (minor) {
10242 case MFHI32:
10243 gen_HILO(ctx, OPC_MFHI, rs);
10244 break;
10245 case MFLO32:
10246 gen_HILO(ctx, OPC_MFLO, rs);
10247 break;
10248 case MTHI32:
10249 gen_HILO(ctx, OPC_MTHI, rs);
10250 break;
10251 case MTLO32:
10252 gen_HILO(ctx, OPC_MTLO, rs);
10253 break;
10254 default:
10255 goto pool32axf_invalid;
10256 }
10257 break;
10258 default:
10259 pool32axf_invalid:
10260 MIPS_INVAL("pool32axf");
10261 generate_exception(ctx, EXCP_RI);
10262 break;
10263 }
10264 }
10265
10266 /* Values for microMIPS fmt field. Variable-width, depending on which
10267 formats the instruction supports. */
10268
10269 enum {
10270 FMT_SD_S = 0,
10271 FMT_SD_D = 1,
10272
10273 FMT_SDPS_S = 0,
10274 FMT_SDPS_D = 1,
10275 FMT_SDPS_PS = 2,
10276
10277 FMT_SWL_S = 0,
10278 FMT_SWL_W = 1,
10279 FMT_SWL_L = 2,
10280
10281 FMT_DWL_D = 0,
10282 FMT_DWL_W = 1,
10283 FMT_DWL_L = 2
10284 };
10285
10286 static void gen_pool32fxf (CPUState *env, DisasContext *ctx, int rt, int rs)
10287 {
10288 int extension = (ctx->opcode >> 6) & 0x3ff;
10289 uint32_t mips32_op;
10290
10291 #define FLOAT_1BIT_FMT(opc, fmt) (fmt << 8) | opc
10292 #define FLOAT_2BIT_FMT(opc, fmt) (fmt << 7) | opc
10293 #define COND_FLOAT_MOV(opc, cond) (cond << 7) | opc
10294
10295 switch (extension) {
10296 case FLOAT_1BIT_FMT(CFC1, 0):
10297 mips32_op = OPC_CFC1;
10298 goto do_cp1;
10299 case FLOAT_1BIT_FMT(CTC1, 0):
10300 mips32_op = OPC_CTC1;
10301 goto do_cp1;
10302 case FLOAT_1BIT_FMT(MFC1, 0):
10303 mips32_op = OPC_MFC1;
10304 goto do_cp1;
10305 case FLOAT_1BIT_FMT(MTC1, 0):
10306 mips32_op = OPC_MTC1;
10307 goto do_cp1;
10308 case FLOAT_1BIT_FMT(MFHC1, 0):
10309 mips32_op = OPC_MFHC1;
10310 goto do_cp1;
10311 case FLOAT_1BIT_FMT(MTHC1, 0):
10312 mips32_op = OPC_MTHC1;
10313 do_cp1:
10314 gen_cp1(ctx, mips32_op, rt, rs);
10315 break;
10316
10317 /* Reciprocal square root */
10318 case FLOAT_1BIT_FMT(RSQRT_FMT, FMT_SD_S):
10319 mips32_op = OPC_RSQRT_S;
10320 goto do_unaryfp;
10321 case FLOAT_1BIT_FMT(RSQRT_FMT, FMT_SD_D):
10322 mips32_op = OPC_RSQRT_D;
10323 goto do_unaryfp;
10324
10325 /* Square root */
10326 case FLOAT_1BIT_FMT(SQRT_FMT, FMT_SD_S):
10327 mips32_op = OPC_SQRT_S;
10328 goto do_unaryfp;
10329 case FLOAT_1BIT_FMT(SQRT_FMT, FMT_SD_D):
10330 mips32_op = OPC_SQRT_D;
10331 goto do_unaryfp;
10332
10333 /* Reciprocal */
10334 case FLOAT_1BIT_FMT(RECIP_FMT, FMT_SD_S):
10335 mips32_op = OPC_RECIP_S;
10336 goto do_unaryfp;
10337 case FLOAT_1BIT_FMT(RECIP_FMT, FMT_SD_D):
10338 mips32_op = OPC_RECIP_D;
10339 goto do_unaryfp;
10340
10341 /* Floor */
10342 case FLOAT_1BIT_FMT(FLOOR_L, FMT_SD_S):
10343 mips32_op = OPC_FLOOR_L_S;
10344 goto do_unaryfp;
10345 case FLOAT_1BIT_FMT(FLOOR_L, FMT_SD_D):
10346 mips32_op = OPC_FLOOR_L_D;
10347 goto do_unaryfp;
10348 case FLOAT_1BIT_FMT(FLOOR_W, FMT_SD_S):
10349 mips32_op = OPC_FLOOR_W_S;
10350 goto do_unaryfp;
10351 case FLOAT_1BIT_FMT(FLOOR_W, FMT_SD_D):
10352 mips32_op = OPC_FLOOR_W_D;
10353 goto do_unaryfp;
10354
10355 /* Ceiling */
10356 case FLOAT_1BIT_FMT(CEIL_L, FMT_SD_S):
10357 mips32_op = OPC_CEIL_L_S;
10358 goto do_unaryfp;
10359 case FLOAT_1BIT_FMT(CEIL_L, FMT_SD_D):
10360 mips32_op = OPC_CEIL_L_D;
10361 goto do_unaryfp;
10362 case FLOAT_1BIT_FMT(CEIL_W, FMT_SD_S):
10363 mips32_op = OPC_CEIL_W_S;
10364 goto do_unaryfp;
10365 case FLOAT_1BIT_FMT(CEIL_W, FMT_SD_D):
10366 mips32_op = OPC_CEIL_W_D;
10367 goto do_unaryfp;
10368
10369 /* Truncation */
10370 case FLOAT_1BIT_FMT(TRUNC_L, FMT_SD_S):
10371 mips32_op = OPC_TRUNC_L_S;
10372 goto do_unaryfp;
10373 case FLOAT_1BIT_FMT(TRUNC_L, FMT_SD_D):
10374 mips32_op = OPC_TRUNC_L_D;
10375 goto do_unaryfp;
10376 case FLOAT_1BIT_FMT(TRUNC_W, FMT_SD_S):
10377 mips32_op = OPC_TRUNC_W_S;
10378 goto do_unaryfp;
10379 case FLOAT_1BIT_FMT(TRUNC_W, FMT_SD_D):
10380 mips32_op = OPC_TRUNC_W_D;
10381 goto do_unaryfp;
10382
10383 /* Round */
10384 case FLOAT_1BIT_FMT(ROUND_L, FMT_SD_S):
10385 mips32_op = OPC_ROUND_L_S;
10386 goto do_unaryfp;
10387 case FLOAT_1BIT_FMT(ROUND_L, FMT_SD_D):
10388 mips32_op = OPC_ROUND_L_D;
10389 goto do_unaryfp;
10390 case FLOAT_1BIT_FMT(ROUND_W, FMT_SD_S):
10391 mips32_op = OPC_ROUND_W_S;
10392 goto do_unaryfp;
10393 case FLOAT_1BIT_FMT(ROUND_W, FMT_SD_D):
10394 mips32_op = OPC_ROUND_W_D;
10395 goto do_unaryfp;
10396
10397 /* Integer to floating-point conversion */
10398 case FLOAT_1BIT_FMT(CVT_L, FMT_SD_S):
10399 mips32_op = OPC_CVT_L_S;
10400 goto do_unaryfp;
10401 case FLOAT_1BIT_FMT(CVT_L, FMT_SD_D):
10402 mips32_op = OPC_CVT_L_D;
10403 goto do_unaryfp;
10404 case FLOAT_1BIT_FMT(CVT_W, FMT_SD_S):
10405 mips32_op = OPC_CVT_W_S;
10406 goto do_unaryfp;
10407 case FLOAT_1BIT_FMT(CVT_W, FMT_SD_D):
10408 mips32_op = OPC_CVT_W_D;
10409 goto do_unaryfp;
10410
10411 /* Paired-foo conversions */
10412 case FLOAT_1BIT_FMT(CVT_S_PL, 0):
10413 mips32_op = OPC_CVT_S_PL;
10414 goto do_unaryfp;
10415 case FLOAT_1BIT_FMT(CVT_S_PU, 0):
10416 mips32_op = OPC_CVT_S_PU;
10417 goto do_unaryfp;
10418 case FLOAT_1BIT_FMT(CVT_PW_PS, 0):
10419 mips32_op = OPC_CVT_PW_PS;
10420 goto do_unaryfp;
10421 case FLOAT_1BIT_FMT(CVT_PS_PW, 0):
10422 mips32_op = OPC_CVT_PS_PW;
10423 goto do_unaryfp;
10424
10425 /* Floating-point moves */
10426 case FLOAT_2BIT_FMT(MOV_FMT, FMT_SDPS_S):
10427 mips32_op = OPC_MOV_S;
10428 goto do_unaryfp;
10429 case FLOAT_2BIT_FMT(MOV_FMT, FMT_SDPS_D):
10430 mips32_op = OPC_MOV_D;
10431 goto do_unaryfp;
10432 case FLOAT_2BIT_FMT(MOV_FMT, FMT_SDPS_PS):
10433 mips32_op = OPC_MOV_PS;
10434 goto do_unaryfp;
10435
10436 /* Absolute value */
10437 case FLOAT_2BIT_FMT(ABS_FMT, FMT_SDPS_S):
10438 mips32_op = OPC_ABS_S;
10439 goto do_unaryfp;
10440 case FLOAT_2BIT_FMT(ABS_FMT, FMT_SDPS_D):
10441 mips32_op = OPC_ABS_D;
10442 goto do_unaryfp;
10443 case FLOAT_2BIT_FMT(ABS_FMT, FMT_SDPS_PS):
10444 mips32_op = OPC_ABS_PS;
10445 goto do_unaryfp;
10446
10447 /* Negation */
10448 case FLOAT_2BIT_FMT(NEG_FMT, FMT_SDPS_S):
10449 mips32_op = OPC_NEG_S;
10450 goto do_unaryfp;
10451 case FLOAT_2BIT_FMT(NEG_FMT, FMT_SDPS_D):
10452 mips32_op = OPC_NEG_D;
10453 goto do_unaryfp;
10454 case FLOAT_2BIT_FMT(NEG_FMT, FMT_SDPS_PS):
10455 mips32_op = OPC_NEG_PS;
10456 goto do_unaryfp;
10457
10458 /* Reciprocal square root step */
10459 case FLOAT_2BIT_FMT(RSQRT1_FMT, FMT_SDPS_S):
10460 mips32_op = OPC_RSQRT1_S;
10461 goto do_unaryfp;
10462 case FLOAT_2BIT_FMT(RSQRT1_FMT, FMT_SDPS_D):
10463 mips32_op = OPC_RSQRT1_D;
10464 goto do_unaryfp;
10465 case FLOAT_2BIT_FMT(RSQRT1_FMT, FMT_SDPS_PS):
10466 mips32_op = OPC_RSQRT1_PS;
10467 goto do_unaryfp;
10468
10469 /* Reciprocal step */
10470 case FLOAT_2BIT_FMT(RECIP1_FMT, FMT_SDPS_S):
10471 mips32_op = OPC_RECIP1_S;
10472 goto do_unaryfp;
10473 case FLOAT_2BIT_FMT(RECIP1_FMT, FMT_SDPS_D):
10474 mips32_op = OPC_RECIP1_S;
10475 goto do_unaryfp;
10476 case FLOAT_2BIT_FMT(RECIP1_FMT, FMT_SDPS_PS):
10477 mips32_op = OPC_RECIP1_PS;
10478 goto do_unaryfp;
10479
10480 /* Conversions from double */
10481 case FLOAT_2BIT_FMT(CVT_D, FMT_SWL_S):
10482 mips32_op = OPC_CVT_D_S;
10483 goto do_unaryfp;
10484 case FLOAT_2BIT_FMT(CVT_D, FMT_SWL_W):
10485 mips32_op = OPC_CVT_D_W;
10486 goto do_unaryfp;
10487 case FLOAT_2BIT_FMT(CVT_D, FMT_SWL_L):
10488 mips32_op = OPC_CVT_D_L;
10489 goto do_unaryfp;
10490
10491 /* Conversions from single */
10492 case FLOAT_2BIT_FMT(CVT_S, FMT_DWL_D):
10493 mips32_op = OPC_CVT_S_D;
10494 goto do_unaryfp;
10495 case FLOAT_2BIT_FMT(CVT_S, FMT_DWL_W):
10496 mips32_op = OPC_CVT_S_W;
10497 goto do_unaryfp;
10498 case FLOAT_2BIT_FMT(CVT_S, FMT_DWL_L):
10499 mips32_op = OPC_CVT_S_L;
10500 do_unaryfp:
10501 gen_farith(ctx, mips32_op, -1, rs, rt, 0);
10502 break;
10503
10504 /* Conditional moves on floating-point codes */
10505 case COND_FLOAT_MOV(MOVT, 0):
10506 case COND_FLOAT_MOV(MOVT, 1):
10507 case COND_FLOAT_MOV(MOVT, 2):
10508 case COND_FLOAT_MOV(MOVT, 3):
10509 case COND_FLOAT_MOV(MOVT, 4):
10510 case COND_FLOAT_MOV(MOVT, 5):
10511 case COND_FLOAT_MOV(MOVT, 6):
10512 case COND_FLOAT_MOV(MOVT, 7):
10513 gen_movci(ctx, rt, rs, (ctx->opcode >> 13) & 0x7, 1);
10514 break;
10515 case COND_FLOAT_MOV(MOVF, 0):
10516 case COND_FLOAT_MOV(MOVF, 1):
10517 case COND_FLOAT_MOV(MOVF, 2):
10518 case COND_FLOAT_MOV(MOVF, 3):
10519 case COND_FLOAT_MOV(MOVF, 4):
10520 case COND_FLOAT_MOV(MOVF, 5):
10521 case COND_FLOAT_MOV(MOVF, 6):
10522 case COND_FLOAT_MOV(MOVF, 7):
10523 gen_movci(ctx, rt, rs, (ctx->opcode >> 13) & 0x7, 0);
10524 break;
10525 default:
10526 MIPS_INVAL("pool32fxf");
10527 generate_exception(ctx, EXCP_RI);
10528 break;
10529 }
10530 }
10531
10532 static void decode_micromips32_opc (CPUState *env, DisasContext *ctx,
10533 uint16_t insn_hw1, int *is_branch)
10534 {
10535 int32_t offset;
10536 uint16_t insn;
10537 int rt, rs, rd, rr;
10538 int16_t imm;
10539 uint32_t op, minor, mips32_op;
10540 uint32_t cond, fmt, cc;
10541
10542 insn = lduw_code(ctx->pc + 2);
10543 ctx->opcode = (ctx->opcode << 16) | insn;
10544
10545 rt = (ctx->opcode >> 21) & 0x1f;
10546 rs = (ctx->opcode >> 16) & 0x1f;
10547 rd = (ctx->opcode >> 11) & 0x1f;
10548 rr = (ctx->opcode >> 6) & 0x1f;
10549 imm = (int16_t) ctx->opcode;
10550
10551 op = (ctx->opcode >> 26) & 0x3f;
10552 switch (op) {
10553 case POOL32A:
10554 minor = ctx->opcode & 0x3f;
10555 switch (minor) {
10556 case 0x00:
10557 minor = (ctx->opcode >> 6) & 0xf;
10558 switch (minor) {
10559 case SLL32:
10560 mips32_op = OPC_SLL;
10561 goto do_shifti;
10562 case SRA:
10563 mips32_op = OPC_SRA;
10564 goto do_shifti;
10565 case SRL32:
10566 mips32_op = OPC_SRL;
10567 goto do_shifti;
10568 case ROTR:
10569 mips32_op = OPC_ROTR;
10570 do_shifti:
10571 gen_shift_imm(env, ctx, mips32_op, rt, rs, rd);
10572 break;
10573 default:
10574 goto pool32a_invalid;
10575 }
10576 break;
10577 case 0x10:
10578 minor = (ctx->opcode >> 6) & 0xf;
10579 switch (minor) {
10580 /* Arithmetic */
10581 case ADD:
10582 mips32_op = OPC_ADD;
10583 goto do_arith;
10584 case ADDU32:
10585 mips32_op = OPC_ADDU;
10586 goto do_arith;
10587 case SUB:
10588 mips32_op = OPC_SUB;
10589 goto do_arith;
10590 case SUBU32:
10591 mips32_op = OPC_SUBU;
10592 goto do_arith;
10593 case MUL:
10594 mips32_op = OPC_MUL;
10595 do_arith:
10596 gen_arith(env, ctx, mips32_op, rd, rs, rt);
10597 break;
10598 /* Shifts */
10599 case SLLV:
10600 mips32_op = OPC_SLLV;
10601 goto do_shift;
10602 case SRLV:
10603 mips32_op = OPC_SRLV;
10604 goto do_shift;
10605 case SRAV:
10606 mips32_op = OPC_SRAV;
10607 goto do_shift;
10608 case ROTRV:
10609 mips32_op = OPC_ROTRV;
10610 do_shift:
10611 gen_shift(env, ctx, mips32_op, rd, rs, rt);
10612 break;
10613 /* Logical operations */
10614 case AND:
10615 mips32_op = OPC_AND;
10616 goto do_logic;
10617 case OR32:
10618 mips32_op = OPC_OR;
10619 goto do_logic;
10620 case NOR:
10621 mips32_op = OPC_NOR;
10622 goto do_logic;
10623 case XOR32:
10624 mips32_op = OPC_XOR;
10625 do_logic:
10626 gen_logic(env, mips32_op, rd, rs, rt);
10627 break;
10628 /* Set less than */
10629 case SLT:
10630 mips32_op = OPC_SLT;
10631 goto do_slt;
10632 case SLTU:
10633 mips32_op = OPC_SLTU;
10634 do_slt:
10635 gen_slt(env, mips32_op, rd, rs, rt);
10636 break;
10637 default:
10638 goto pool32a_invalid;
10639 }
10640 break;
10641 case 0x18:
10642 minor = (ctx->opcode >> 6) & 0xf;
10643 switch (minor) {
10644 /* Conditional moves */
10645 case MOVN:
10646 mips32_op = OPC_MOVN;
10647 goto do_cmov;
10648 case MOVZ:
10649 mips32_op = OPC_MOVZ;
10650 do_cmov:
10651 gen_cond_move(env, mips32_op, rd, rs, rt);
10652 break;
10653 case LWXS:
10654 gen_ldxs(ctx, rs, rt, rd);
10655 break;
10656 default:
10657 goto pool32a_invalid;
10658 }
10659 break;
10660 case INS:
10661 gen_bitops(ctx, OPC_INS, rt, rs, rr, rd);
10662 return;
10663 case EXT:
10664 gen_bitops(ctx, OPC_EXT, rt, rs, rr, rd);
10665 return;
10666 case POOL32AXF:
10667 gen_pool32axf(env, ctx, rt, rs, is_branch);
10668 break;
10669 case 0x07:
10670 generate_exception(ctx, EXCP_BREAK);
10671 break;
10672 default:
10673 pool32a_invalid:
10674 MIPS_INVAL("pool32a");
10675 generate_exception(ctx, EXCP_RI);
10676 break;
10677 }
10678 break;
10679 case POOL32B:
10680 minor = (ctx->opcode >> 12) & 0xf;
10681 switch (minor) {
10682 case CACHE:
10683 /* Treat as no-op. */
10684 break;
10685 case LWC2:
10686 case SWC2:
10687 /* COP2: Not implemented. */
10688 generate_exception_err(ctx, EXCP_CpU, 2);
10689 break;
10690 case LWP:
10691 case SWP:
10692 #ifdef TARGET_MIPS64
10693 case LDP:
10694 case SDP:
10695 #endif
10696 gen_ldst_pair(ctx, minor, rt, rs, SIMM(ctx->opcode, 0, 12));
10697 break;
10698 case LWM32:
10699 case SWM32:
10700 #ifdef TARGET_MIPS64
10701 case LDM:
10702 case SDM:
10703 #endif
10704 gen_ldst_multiple(ctx, minor, rt, rs, SIMM(ctx->opcode, 0, 12));
10705 break;
10706 default:
10707 MIPS_INVAL("pool32b");
10708 generate_exception(ctx, EXCP_RI);
10709 break;
10710 }
10711 break;
10712 case POOL32F:
10713 if (env->CP0_Config1 & (1 << CP0C1_FP)) {
10714 minor = ctx->opcode & 0x3f;
10715 check_cp1_enabled(ctx);
10716 switch (minor) {
10717 case ALNV_PS:
10718 mips32_op = OPC_ALNV_PS;
10719 goto do_madd;
10720 case MADD_S:
10721 mips32_op = OPC_MADD_S;
10722 goto do_madd;
10723 case MADD_D:
10724 mips32_op = OPC_MADD_D;
10725 goto do_madd;
10726 case MADD_PS:
10727 mips32_op = OPC_MADD_PS;
10728 goto do_madd;
10729 case MSUB_S:
10730 mips32_op = OPC_MSUB_S;
10731 goto do_madd;
10732 case MSUB_D:
10733 mips32_op = OPC_MSUB_D;
10734 goto do_madd;
10735 case MSUB_PS:
10736 mips32_op = OPC_MSUB_PS;
10737 goto do_madd;
10738 case NMADD_S:
10739 mips32_op = OPC_NMADD_S;
10740 goto do_madd;
10741 case NMADD_D:
10742 mips32_op = OPC_NMADD_D;
10743 goto do_madd;
10744 case NMADD_PS:
10745 mips32_op = OPC_NMADD_PS;
10746 goto do_madd;
10747 case NMSUB_S:
10748 mips32_op = OPC_NMSUB_S;
10749 goto do_madd;
10750 case NMSUB_D:
10751 mips32_op = OPC_NMSUB_D;
10752 goto do_madd;
10753 case NMSUB_PS:
10754 mips32_op = OPC_NMSUB_PS;
10755 do_madd:
10756 gen_flt3_arith(ctx, mips32_op, rd, rr, rs, rt);
10757 break;
10758 case CABS_COND_FMT:
10759 cond = (ctx->opcode >> 6) & 0xf;
10760 cc = (ctx->opcode >> 13) & 0x7;
10761 fmt = (ctx->opcode >> 10) & 0x3;
10762 switch (fmt) {
10763 case 0x0:
10764 gen_cmpabs_s(ctx, cond, rt, rs, cc);
10765 break;
10766 case 0x1:
10767 gen_cmpabs_d(ctx, cond, rt, rs, cc);
10768 break;
10769 case 0x2:
10770 gen_cmpabs_ps(ctx, cond, rt, rs, cc);
10771 break;
10772 default:
10773 goto pool32f_invalid;
10774 }
10775 break;
10776 case C_COND_FMT:
10777 cond = (ctx->opcode >> 6) & 0xf;
10778 cc = (ctx->opcode >> 13) & 0x7;
10779 fmt = (ctx->opcode >> 10) & 0x3;
10780 switch (fmt) {
10781 case 0x0:
10782 gen_cmp_s(ctx, cond, rt, rs, cc);
10783 break;
10784 case 0x1:
10785 gen_cmp_d(ctx, cond, rt, rs, cc);
10786 break;
10787 case 0x2:
10788 gen_cmp_ps(ctx, cond, rt, rs, cc);
10789 break;
10790 default:
10791 goto pool32f_invalid;
10792 }
10793 break;
10794 case POOL32FXF:
10795 gen_pool32fxf(env, ctx, rt, rs);
10796 break;
10797 case 0x00:
10798 /* PLL foo */
10799 switch ((ctx->opcode >> 6) & 0x7) {
10800 case PLL_PS:
10801 mips32_op = OPC_PLL_PS;
10802 goto do_ps;
10803 case PLU_PS:
10804 mips32_op = OPC_PLU_PS;
10805 goto do_ps;
10806 case PUL_PS:
10807 mips32_op = OPC_PUL_PS;
10808 goto do_ps;
10809 case PUU_PS:
10810 mips32_op = OPC_PUU_PS;
10811 goto do_ps;
10812 case CVT_PS_S:
10813 mips32_op = OPC_CVT_PS_S;
10814 do_ps:
10815 gen_farith(ctx, mips32_op, rt, rs, rd, 0);
10816 break;
10817 default:
10818 goto pool32f_invalid;
10819 }
10820 break;
10821 case 0x08:
10822 /* [LS][WDU]XC1 */
10823 switch ((ctx->opcode >> 6) & 0x7) {
10824 case LWXC1:
10825 mips32_op = OPC_LWXC1;
10826 goto do_ldst_cp1;
10827 case SWXC1:
10828 mips32_op = OPC_SWXC1;
10829 goto do_ldst_cp1;
10830 case LDXC1:
10831 mips32_op = OPC_LDXC1;
10832 goto do_ldst_cp1;
10833 case SDXC1:
10834 mips32_op = OPC_SDXC1;
10835 goto do_ldst_cp1;
10836 case LUXC1:
10837 mips32_op = OPC_LUXC1;
10838 goto do_ldst_cp1;
10839 case SUXC1:
10840 mips32_op = OPC_SUXC1;
10841 do_ldst_cp1:
10842 gen_flt3_ldst(ctx, mips32_op, rd, rd, rt, rs);
10843 break;
10844 default:
10845 goto pool32f_invalid;
10846 }
10847 break;
10848 case 0x18:
10849 /* 3D insns */
10850 fmt = (ctx->opcode >> 9) & 0x3;
10851 switch ((ctx->opcode >> 6) & 0x7) {
10852 case RSQRT2_FMT:
10853 switch (fmt) {
10854 case FMT_SDPS_S:
10855 mips32_op = OPC_RSQRT2_S;
10856 goto do_3d;
10857 case FMT_SDPS_D:
10858 mips32_op = OPC_RSQRT2_D;
10859 goto do_3d;
10860 case FMT_SDPS_PS:
10861 mips32_op = OPC_RSQRT2_PS;
10862 goto do_3d;
10863 default:
10864 goto pool32f_invalid;
10865 }
10866 break;
10867 case RECIP2_FMT:
10868 switch (fmt) {
10869 case FMT_SDPS_S:
10870 mips32_op = OPC_RECIP2_S;
10871 goto do_3d;
10872 case FMT_SDPS_D:
10873 mips32_op = OPC_RECIP2_D;
10874 goto do_3d;
10875 case FMT_SDPS_PS:
10876 mips32_op = OPC_RECIP2_PS;
10877 goto do_3d;
10878 default:
10879 goto pool32f_invalid;
10880 }
10881 break;
10882 case ADDR_PS:
10883 mips32_op = OPC_ADDR_PS;
10884 goto do_3d;
10885 case MULR_PS:
10886 mips32_op = OPC_MULR_PS;
10887 do_3d:
10888 gen_farith(ctx, mips32_op, rt, rs, rd, 0);
10889 break;
10890 default:
10891 goto pool32f_invalid;
10892 }
10893 break;
10894 case 0x20:
10895 /* MOV[FT].fmt and PREFX */
10896 cc = (ctx->opcode >> 13) & 0x7;
10897 fmt = (ctx->opcode >> 9) & 0x3;
10898 switch ((ctx->opcode >> 6) & 0x7) {
10899 case MOVF_FMT:
10900 switch (fmt) {
10901 case FMT_SDPS_S:
10902 gen_movcf_s(rs, rt, cc, 0);
10903 break;
10904 case FMT_SDPS_D:
10905 gen_movcf_d(ctx, rs, rt, cc, 0);
10906 break;
10907 case FMT_SDPS_PS:
10908 gen_movcf_ps(rs, rt, cc, 0);
10909 break;
10910 default:
10911 goto pool32f_invalid;
10912 }
10913 break;
10914 case MOVT_FMT:
10915 switch (fmt) {
10916 case FMT_SDPS_S:
10917 gen_movcf_s(rs, rt, cc, 1);
10918 break;
10919 case FMT_SDPS_D:
10920 gen_movcf_d(ctx, rs, rt, cc, 1);
10921 break;
10922 case FMT_SDPS_PS:
10923 gen_movcf_ps(rs, rt, cc, 1);
10924 break;
10925 default:
10926 goto pool32f_invalid;
10927 }
10928 break;
10929 case PREFX:
10930 break;
10931 default:
10932 goto pool32f_invalid;
10933 }
10934 break;
10935 #define FINSN_3ARG_SDPS(prfx) \
10936 switch ((ctx->opcode >> 8) & 0x3) { \
10937 case FMT_SDPS_S: \
10938 mips32_op = OPC_##prfx##_S; \
10939 goto do_fpop; \
10940 case FMT_SDPS_D: \
10941 mips32_op = OPC_##prfx##_D; \
10942 goto do_fpop; \
10943 case FMT_SDPS_PS: \
10944 mips32_op = OPC_##prfx##_PS; \
10945 goto do_fpop; \
10946 default: \
10947 goto pool32f_invalid; \
10948 }
10949 case 0x30:
10950 /* regular FP ops */
10951 switch ((ctx->opcode >> 6) & 0x3) {
10952 case ADD_FMT:
10953 FINSN_3ARG_SDPS(ADD);
10954 break;
10955 case SUB_FMT:
10956 FINSN_3ARG_SDPS(SUB);
10957 break;
10958 case MUL_FMT:
10959 FINSN_3ARG_SDPS(MUL);
10960 break;
10961 case DIV_FMT:
10962 fmt = (ctx->opcode >> 8) & 0x3;
10963 if (fmt == 1) {
10964 mips32_op = OPC_DIV_D;
10965 } else if (fmt == 0) {
10966 mips32_op = OPC_DIV_S;
10967 } else {
10968 goto pool32f_invalid;
10969 }
10970 goto do_fpop;
10971 default:
10972 goto pool32f_invalid;
10973 }
10974 break;
10975 case 0x38:
10976 /* cmovs */
10977 switch ((ctx->opcode >> 6) & 0x3) {
10978 case MOVN_FMT:
10979 FINSN_3ARG_SDPS(MOVN);
10980 break;
10981 case MOVZ_FMT:
10982 FINSN_3ARG_SDPS(MOVZ);
10983 break;
10984 default:
10985 goto pool32f_invalid;
10986 }
10987 break;
10988 do_fpop:
10989 gen_farith(ctx, mips32_op, rt, rs, rd, 0);
10990 break;
10991 default:
10992 pool32f_invalid:
10993 MIPS_INVAL("pool32f");
10994 generate_exception(ctx, EXCP_RI);
10995 break;
10996 }
10997 } else {
10998 generate_exception_err(ctx, EXCP_CpU, 1);
10999 }
11000 break;
11001 case POOL32I:
11002 minor = (ctx->opcode >> 21) & 0x1f;
11003 switch (minor) {
11004 case BLTZ:
11005 mips32_op = OPC_BLTZ;
11006 goto do_branch;
11007 case BLTZAL:
11008 mips32_op = OPC_BLTZAL;
11009 goto do_branch;
11010 case BLTZALS:
11011 mips32_op = OPC_BLTZALS;
11012 goto do_branch;
11013 case BGEZ:
11014 mips32_op = OPC_BGEZ;
11015 goto do_branch;
11016 case BGEZAL:
11017 mips32_op = OPC_BGEZAL;
11018 goto do_branch;
11019 case BGEZALS:
11020 mips32_op = OPC_BGEZALS;
11021 goto do_branch;
11022 case BLEZ:
11023 mips32_op = OPC_BLEZ;
11024 goto do_branch;
11025 case BGTZ:
11026 mips32_op = OPC_BGTZ;
11027 do_branch:
11028 gen_compute_branch(ctx, mips32_op, 4, rs, -1, imm << 1);
11029 *is_branch = 1;
11030 break;
11031
11032 /* Traps */
11033 case TLTI:
11034 mips32_op = OPC_TLTI;
11035 goto do_trapi;
11036 case TGEI:
11037 mips32_op = OPC_TGEI;
11038 goto do_trapi;
11039 case TLTIU:
11040 mips32_op = OPC_TLTIU;
11041 goto do_trapi;
11042 case TGEIU:
11043 mips32_op = OPC_TGEIU;
11044 goto do_trapi;
11045 case TNEI:
11046 mips32_op = OPC_TNEI;
11047 goto do_trapi;
11048 case TEQI:
11049 mips32_op = OPC_TEQI;
11050 do_trapi:
11051 gen_trap(ctx, mips32_op, rs, -1, imm);
11052 break;
11053
11054 case BNEZC:
11055 case BEQZC:
11056 gen_compute_branch(ctx, minor == BNEZC ? OPC_BNE : OPC_BEQ,
11057 4, rs, 0, imm << 1);
11058 /* Compact branches don't have a delay slot, so just let
11059 the normal delay slot handling take us to the branch
11060 target. */
11061 break;
11062 case LUI:
11063 gen_logic_imm(env, OPC_LUI, rs, -1, imm);
11064 break;
11065 case SYNCI:
11066 break;
11067 case BC2F:
11068 case BC2T:
11069 /* COP2: Not implemented. */
11070 generate_exception_err(ctx, EXCP_CpU, 2);
11071 break;
11072 case BC1F:
11073 mips32_op = (ctx->opcode & (1 << 16)) ? OPC_BC1FANY2 : OPC_BC1F;
11074 goto do_cp1branch;
11075 case BC1T:
11076 mips32_op = (ctx->opcode & (1 << 16)) ? OPC_BC1TANY2 : OPC_BC1T;
11077 goto do_cp1branch;
11078 case BC1ANY4F:
11079 mips32_op = OPC_BC1FANY4;
11080 goto do_cp1mips3d;
11081 case BC1ANY4T:
11082 mips32_op = OPC_BC1TANY4;
11083 do_cp1mips3d:
11084 check_cop1x(ctx);
11085 check_insn(env, ctx, ASE_MIPS3D);
11086 /* Fall through */
11087 do_cp1branch:
11088 gen_compute_branch1(env, ctx, mips32_op,
11089 (ctx->opcode >> 18) & 0x7, imm << 1);
11090 *is_branch = 1;
11091 break;
11092 case BPOSGE64:
11093 case BPOSGE32:
11094 /* MIPS DSP: not implemented */
11095 /* Fall through */
11096 default:
11097 MIPS_INVAL("pool32i");
11098 generate_exception(ctx, EXCP_RI);
11099 break;
11100 }
11101 break;
11102 case POOL32C:
11103 minor = (ctx->opcode >> 12) & 0xf;
11104 switch (minor) {
11105 case LWL:
11106 mips32_op = OPC_LWL;
11107 goto do_ld_lr;
11108 case SWL:
11109 mips32_op = OPC_SWL;
11110 goto do_st_lr;
11111 case LWR:
11112 mips32_op = OPC_LWR;
11113 goto do_ld_lr;
11114 case SWR:
11115 mips32_op = OPC_SWR;
11116 goto do_st_lr;
11117 #if defined(TARGET_MIPS64)
11118 case LDL:
11119 mips32_op = OPC_LDL;
11120 goto do_ld_lr;
11121 case SDL:
11122 mips32_op = OPC_SDL;
11123 goto do_st_lr;
11124 case LDR:
11125 mips32_op = OPC_LDR;
11126 goto do_ld_lr;
11127 case SDR:
11128 mips32_op = OPC_SDR;
11129 goto do_st_lr;
11130 case LWU:
11131 mips32_op = OPC_LWU;
11132 goto do_ld_lr;
11133 case LLD:
11134 mips32_op = OPC_LLD;
11135 goto do_ld_lr;
11136 #endif
11137 case LL:
11138 mips32_op = OPC_LL;
11139 goto do_ld_lr;
11140 do_ld_lr:
11141 gen_ld(env, ctx, mips32_op, rt, rs, SIMM(ctx->opcode, 0, 12));
11142 break;
11143 do_st_lr:
11144 gen_st(ctx, mips32_op, rt, rs, SIMM(ctx->opcode, 0, 12));
11145 break;
11146 case SC:
11147 gen_st_cond(ctx, OPC_SC, rt, rs, SIMM(ctx->opcode, 0, 12));
11148 break;
11149 #if defined(TARGET_MIPS64)
11150 case SCD:
11151 gen_st_cond(ctx, OPC_SCD, rt, rs, SIMM(ctx->opcode, 0, 12));
11152 break;
11153 #endif
11154 case PREF:
11155 /* Treat as no-op */
11156 break;
11157 default:
11158 MIPS_INVAL("pool32c");
11159 generate_exception(ctx, EXCP_RI);
11160 break;
11161 }
11162 break;
11163 case ADDI32:
11164 mips32_op = OPC_ADDI;
11165 goto do_addi;
11166 case ADDIU32:
11167 mips32_op = OPC_ADDIU;
11168 do_addi:
11169 gen_arith_imm(env, ctx, mips32_op, rt, rs, imm);
11170 break;
11171
11172 /* Logical operations */
11173 case ORI32:
11174 mips32_op = OPC_ORI;
11175 goto do_logici;
11176 case XORI32:
11177 mips32_op = OPC_XORI;
11178 goto do_logici;
11179 case ANDI32:
11180 mips32_op = OPC_ANDI;
11181 do_logici:
11182 gen_logic_imm(env, mips32_op, rt, rs, imm);
11183 break;
11184
11185 /* Set less than immediate */
11186 case SLTI32:
11187 mips32_op = OPC_SLTI;
11188 goto do_slti;
11189 case SLTIU32:
11190 mips32_op = OPC_SLTIU;
11191 do_slti:
11192 gen_slt_imm(env, mips32_op, rt, rs, imm);
11193 break;
11194 case JALX32:
11195 offset = (int32_t)(ctx->opcode & 0x3FFFFFF) << 2;
11196 gen_compute_branch(ctx, OPC_JALX, 4, rt, rs, offset);
11197 *is_branch = 1;
11198 break;
11199 case JALS32:
11200 offset = (int32_t)(ctx->opcode & 0x3FFFFFF) << 1;
11201 gen_compute_branch(ctx, OPC_JALS, 4, rt, rs, offset);
11202 *is_branch = 1;
11203 break;
11204 case BEQ32:
11205 gen_compute_branch(ctx, OPC_BEQ, 4, rt, rs, imm << 1);
11206 *is_branch = 1;
11207 break;
11208 case BNE32:
11209 gen_compute_branch(ctx, OPC_BNE, 4, rt, rs, imm << 1);
11210 *is_branch = 1;
11211 break;
11212 case J32:
11213 gen_compute_branch(ctx, OPC_J, 4, rt, rs,
11214 (int32_t)(ctx->opcode & 0x3FFFFFF) << 1);
11215 *is_branch = 1;
11216 break;
11217 case JAL32:
11218 gen_compute_branch(ctx, OPC_JAL, 4, rt, rs,
11219 (int32_t)(ctx->opcode & 0x3FFFFFF) << 1);
11220 *is_branch = 1;
11221 break;
11222 /* Floating point (COP1) */
11223 case LWC132:
11224 mips32_op = OPC_LWC1;
11225 goto do_cop1;
11226 case LDC132:
11227 mips32_op = OPC_LDC1;
11228 goto do_cop1;
11229 case SWC132:
11230 mips32_op = OPC_SWC1;
11231 goto do_cop1;
11232 case SDC132:
11233 mips32_op = OPC_SDC1;
11234 do_cop1:
11235 gen_cop1_ldst(env, ctx, mips32_op, rt, rs, imm);
11236 break;
11237 case ADDIUPC:
11238 {
11239 int reg = mmreg(ZIMM(ctx->opcode, 23, 3));
11240 int offset = SIMM(ctx->opcode, 0, 23) << 2;
11241
11242 gen_addiupc(ctx, reg, offset, 0, 0);
11243 }
11244 break;
11245 /* Loads and stores */
11246 case LB32:
11247 mips32_op = OPC_LB;
11248 goto do_ld;
11249 case LBU32:
11250 mips32_op = OPC_LBU;
11251 goto do_ld;
11252 case LH32:
11253 mips32_op = OPC_LH;
11254 goto do_ld;
11255 case LHU32:
11256 mips32_op = OPC_LHU;
11257 goto do_ld;
11258 case LW32:
11259 mips32_op = OPC_LW;
11260 goto do_ld;
11261 #ifdef TARGET_MIPS64
11262 case LD32:
11263 mips32_op = OPC_LD;
11264 goto do_ld;
11265 case SD32:
11266 mips32_op = OPC_SD;
11267 goto do_st;
11268 #endif
11269 case SB32:
11270 mips32_op = OPC_SB;
11271 goto do_st;
11272 case SH32:
11273 mips32_op = OPC_SH;
11274 goto do_st;
11275 case SW32:
11276 mips32_op = OPC_SW;
11277 goto do_st;
11278 do_ld:
11279 gen_ld(env, ctx, mips32_op, rt, rs, imm);
11280 break;
11281 do_st:
11282 gen_st(ctx, mips32_op, rt, rs, imm);
11283 break;
11284 default:
11285 generate_exception(ctx, EXCP_RI);
11286 break;
11287 }
11288 }
11289
11290 static int decode_micromips_opc (CPUState *env, DisasContext *ctx, int *is_branch)
11291 {
11292 uint32_t op;
11293
11294 /* make sure instructions are on a halfword boundary */
11295 if (ctx->pc & 0x1) {
11296 env->CP0_BadVAddr = ctx->pc;
11297 generate_exception(ctx, EXCP_AdEL);
11298 ctx->bstate = BS_STOP;
11299 return 2;
11300 }
11301
11302 op = (ctx->opcode >> 10) & 0x3f;
11303 /* Enforce properly-sized instructions in a delay slot */
11304 if (ctx->hflags & MIPS_HFLAG_BMASK) {
11305 int bits = ctx->hflags & MIPS_HFLAG_BMASK_EXT;
11306
11307 switch (op) {
11308 case POOL32A:
11309 case POOL32B:
11310 case POOL32I:
11311 case POOL32C:
11312 case ADDI32:
11313 case ADDIU32:
11314 case ORI32:
11315 case XORI32:
11316 case SLTI32:
11317 case SLTIU32:
11318 case ANDI32:
11319 case JALX32:
11320 case LBU32:
11321 case LHU32:
11322 case POOL32F:
11323 case JALS32:
11324 case BEQ32:
11325 case BNE32:
11326 case J32:
11327 case JAL32:
11328 case SB32:
11329 case SH32:
11330 case POOL32S:
11331 case ADDIUPC:
11332 case SWC132:
11333 case SDC132:
11334 case SD32:
11335 case SW32:
11336 case LB32:
11337 case LH32:
11338 case DADDIU32:
11339 case POOL48A: /* ??? */
11340 case LWC132:
11341 case LDC132:
11342 case LD32:
11343 case LW32:
11344 if (bits & MIPS_HFLAG_BDS16) {
11345 generate_exception(ctx, EXCP_RI);
11346 /* Just stop translation; the user is confused. */
11347 ctx->bstate = BS_STOP;
11348 return 2;
11349 }
11350 break;
11351 case POOL16A:
11352 case POOL16B:
11353 case POOL16C:
11354 case LWGP16:
11355 case POOL16F:
11356 case LBU16:
11357 case LHU16:
11358 case LWSP16:
11359 case LW16:
11360 case SB16:
11361 case SH16:
11362 case SWSP16:
11363 case SW16:
11364 case MOVE16:
11365 case ANDI16:
11366 case POOL16D:
11367 case POOL16E:
11368 case BEQZ16:
11369 case BNEZ16:
11370 case B16:
11371 case LI16:
11372 if (bits & MIPS_HFLAG_BDS32) {
11373 generate_exception(ctx, EXCP_RI);
11374 /* Just stop translation; the user is confused. */
11375 ctx->bstate = BS_STOP;
11376 return 2;
11377 }
11378 break;
11379 default:
11380 break;
11381 }
11382 }
11383 switch (op) {
11384 case POOL16A:
11385 {
11386 int rd = mmreg(uMIPS_RD(ctx->opcode));
11387 int rs1 = mmreg(uMIPS_RS1(ctx->opcode));
11388 int rs2 = mmreg(uMIPS_RS2(ctx->opcode));
11389 uint32_t opc = 0;
11390
11391 switch (ctx->opcode & 0x1) {
11392 case ADDU16:
11393 opc = OPC_ADDU;
11394 break;
11395 case SUBU16:
11396 opc = OPC_SUBU;
11397 break;
11398 }
11399
11400 gen_arith(env, ctx, opc, rd, rs1, rs2);
11401 }
11402 break;
11403 case POOL16B:
11404 {
11405 int rd = mmreg(uMIPS_RD(ctx->opcode));
11406 int rs = mmreg(uMIPS_RS(ctx->opcode));
11407 int amount = (ctx->opcode >> 1) & 0x7;
11408 uint32_t opc = 0;
11409 amount = amount == 0 ? 8 : amount;
11410
11411 switch (ctx->opcode & 0x1) {
11412 case SLL16:
11413 opc = OPC_SLL;
11414 break;
11415 case SRL16:
11416 opc = OPC_SRL;
11417 break;
11418 }
11419
11420 gen_shift_imm(env, ctx, opc, rd, rs, amount);
11421 }
11422 break;
11423 case POOL16C:
11424 gen_pool16c_insn(env, ctx, is_branch);
11425 break;
11426 case LWGP16:
11427 {
11428 int rd = mmreg(uMIPS_RD(ctx->opcode));
11429 int rb = 28; /* GP */
11430 int16_t offset = SIMM(ctx->opcode, 0, 7) << 2;
11431
11432 gen_ld(env, ctx, OPC_LW, rd, rb, offset);
11433 }
11434 break;
11435 case POOL16F:
11436 if (ctx->opcode & 1) {
11437 generate_exception(ctx, EXCP_RI);
11438 } else {
11439 /* MOVEP */
11440 int enc_dest = uMIPS_RD(ctx->opcode);
11441 int enc_rt = uMIPS_RS2(ctx->opcode);
11442 int enc_rs = uMIPS_RS1(ctx->opcode);
11443 int rd, rs, re, rt;
11444 static const int rd_enc[] = { 5, 5, 6, 4, 4, 4, 4, 4 };
11445 static const int re_enc[] = { 6, 7, 7, 21, 22, 5, 6, 7 };
11446 static const int rs_rt_enc[] = { 0, 17, 2, 3, 16, 18, 19, 20 };
11447
11448 rd = rd_enc[enc_dest];
11449 re = re_enc[enc_dest];
11450 rs = rs_rt_enc[enc_rs];
11451 rt = rs_rt_enc[enc_rt];
11452
11453 gen_arith_imm(env, ctx, OPC_ADDIU, rd, rs, 0);
11454 gen_arith_imm(env, ctx, OPC_ADDIU, re, rt, 0);
11455 }
11456 break;
11457 case LBU16:
11458 {
11459 int rd = mmreg(uMIPS_RD(ctx->opcode));
11460 int rb = mmreg(uMIPS_RS(ctx->opcode));
11461 int16_t offset = ZIMM(ctx->opcode, 0, 4);
11462 offset = (offset == 0xf ? -1 : offset);
11463
11464 gen_ld(env, ctx, OPC_LBU, rd, rb, offset);
11465 }
11466 break;
11467 case LHU16:
11468 {
11469 int rd = mmreg(uMIPS_RD(ctx->opcode));
11470 int rb = mmreg(uMIPS_RS(ctx->opcode));
11471 int16_t offset = ZIMM(ctx->opcode, 0, 4) << 1;
11472
11473 gen_ld(env, ctx, OPC_LHU, rd, rb, offset);
11474 }
11475 break;
11476 case LWSP16:
11477 {
11478 int rd = (ctx->opcode >> 5) & 0x1f;
11479 int rb = 29; /* SP */
11480 int16_t offset = ZIMM(ctx->opcode, 0, 5) << 2;
11481
11482 gen_ld(env, ctx, OPC_LW, rd, rb, offset);
11483 }
11484 break;
11485 case LW16:
11486 {
11487 int rd = mmreg(uMIPS_RD(ctx->opcode));
11488 int rb = mmreg(uMIPS_RS(ctx->opcode));
11489 int16_t offset = ZIMM(ctx->opcode, 0, 4) << 2;
11490
11491 gen_ld(env, ctx, OPC_LW, rd, rb, offset);
11492 }
11493 break;
11494 case SB16:
11495 {
11496 int rd = mmreg2(uMIPS_RD(ctx->opcode));
11497 int rb = mmreg(uMIPS_RS(ctx->opcode));
11498 int16_t offset = ZIMM(ctx->opcode, 0, 4);
11499
11500 gen_st(ctx, OPC_SB, rd, rb, offset);
11501 }
11502 break;
11503 case SH16:
11504 {
11505 int rd = mmreg2(uMIPS_RD(ctx->opcode));
11506 int rb = mmreg(uMIPS_RS(ctx->opcode));
11507 int16_t offset = ZIMM(ctx->opcode, 0, 4) << 1;
11508
11509 gen_st(ctx, OPC_SH, rd, rb, offset);
11510 }
11511 break;
11512 case SWSP16:
11513 {
11514 int rd = (ctx->opcode >> 5) & 0x1f;
11515 int rb = 29; /* SP */
11516 int16_t offset = ZIMM(ctx->opcode, 0, 5) << 2;
11517
11518 gen_st(ctx, OPC_SW, rd, rb, offset);
11519 }
11520 break;
11521 case SW16:
11522 {
11523 int rd = mmreg2(uMIPS_RD(ctx->opcode));
11524 int rb = mmreg(uMIPS_RS(ctx->opcode));
11525 int16_t offset = ZIMM(ctx->opcode, 0, 4) << 2;
11526
11527 gen_st(ctx, OPC_SW, rd, rb, offset);
11528 }
11529 break;
11530 case MOVE16:
11531 {
11532 int rd = uMIPS_RD5(ctx->opcode);
11533 int rs = uMIPS_RS5(ctx->opcode);
11534
11535 gen_arith_imm(env, ctx, OPC_ADDIU, rd, rs, 0);
11536 }
11537 break;
11538 case ANDI16:
11539 gen_andi16(env, ctx);
11540 break;
11541 case POOL16D:
11542 switch (ctx->opcode & 0x1) {
11543 case ADDIUS5:
11544 gen_addius5(env, ctx);
11545 break;
11546 case ADDIUSP:
11547 gen_addiusp(env, ctx);
11548 break;
11549 }
11550 break;
11551 case POOL16E:
11552 switch (ctx->opcode & 0x1) {
11553 case ADDIUR2:
11554 gen_addiur2(env, ctx);
11555 break;
11556 case ADDIUR1SP:
11557 gen_addiur1sp(env, ctx);
11558 break;
11559 }
11560 break;
11561 case B16:
11562 gen_compute_branch(ctx, OPC_BEQ, 2, 0, 0,
11563 SIMM(ctx->opcode, 0, 10) << 1);
11564 *is_branch = 1;
11565 break;
11566 case BNEZ16:
11567 case BEQZ16:
11568 gen_compute_branch(ctx, op == BNEZ16 ? OPC_BNE : OPC_BEQ, 2,
11569 mmreg(uMIPS_RD(ctx->opcode)),
11570 0, SIMM(ctx->opcode, 0, 7) << 1);
11571 *is_branch = 1;
11572 break;
11573 case LI16:
11574 {
11575 int reg = mmreg(uMIPS_RD(ctx->opcode));
11576 int imm = ZIMM(ctx->opcode, 0, 7);
11577
11578 imm = (imm == 0x7f ? -1 : imm);
11579 tcg_gen_movi_tl(cpu_gpr[reg], imm);
11580 }
11581 break;
11582 case RES_20:
11583 case RES_28:
11584 case RES_29:
11585 case RES_30:
11586 case RES_31:
11587 case RES_38:
11588 case RES_39:
11589 generate_exception(ctx, EXCP_RI);
11590 break;
11591 default:
11592 decode_micromips32_opc (env, ctx, op, is_branch);
11593 return 4;
11594 }
11595
11596 return 2;
11597 }
11598
11599 /* SmartMIPS extension to MIPS32 */
11600
11601 #if defined(TARGET_MIPS64)
11602
11603 /* MDMX extension to MIPS64 */
11604
11605 #endif
11606
11607 static void decode_opc (CPUState *env, DisasContext *ctx, int *is_branch)
11608 {
11609 int32_t offset;
11610 int rs, rt, rd, sa;
11611 uint32_t op, op1, op2;
11612 int16_t imm;
11613
11614 /* make sure instructions are on a word boundary */
11615 if (ctx->pc & 0x3) {
11616 env->CP0_BadVAddr = ctx->pc;
11617 generate_exception(ctx, EXCP_AdEL);
11618 return;
11619 }
11620
11621 /* Handle blikely not taken case */
11622 if ((ctx->hflags & MIPS_HFLAG_BMASK_BASE) == MIPS_HFLAG_BL) {
11623 int l1 = gen_new_label();
11624
11625 MIPS_DEBUG("blikely condition (" TARGET_FMT_lx ")", ctx->pc + 4);
11626 tcg_gen_brcondi_tl(TCG_COND_NE, bcond, 0, l1);
11627 tcg_gen_movi_i32(hflags, ctx->hflags & ~MIPS_HFLAG_BMASK);
11628 gen_goto_tb(ctx, 1, ctx->pc + 4);
11629 gen_set_label(l1);
11630 }
11631
11632 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP)))
11633 tcg_gen_debug_insn_start(ctx->pc);
11634
11635 op = MASK_OP_MAJOR(ctx->opcode);
11636 rs = (ctx->opcode >> 21) & 0x1f;
11637 rt = (ctx->opcode >> 16) & 0x1f;
11638 rd = (ctx->opcode >> 11) & 0x1f;
11639 sa = (ctx->opcode >> 6) & 0x1f;
11640 imm = (int16_t)ctx->opcode;
11641 switch (op) {
11642 case OPC_SPECIAL:
11643 op1 = MASK_SPECIAL(ctx->opcode);
11644 switch (op1) {
11645 case OPC_SLL: /* Shift with immediate */
11646 case OPC_SRA:
11647 gen_shift_imm(env, ctx, op1, rd, rt, sa);
11648 break;
11649 case OPC_SRL:
11650 switch ((ctx->opcode >> 21) & 0x1f) {
11651 case 1:
11652 /* rotr is decoded as srl on non-R2 CPUs */
11653 if (env->insn_flags & ISA_MIPS32R2) {
11654 op1 = OPC_ROTR;
11655 }
11656 /* Fallthrough */
11657 case 0:
11658 gen_shift_imm(env, ctx, op1, rd, rt, sa);
11659 break;
11660 default:
11661 generate_exception(ctx, EXCP_RI);
11662 break;
11663 }
11664 break;
11665 case OPC_MOVN: /* Conditional move */
11666 case OPC_MOVZ:
11667 check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32 |
11668 INSN_LOONGSON2E | INSN_LOONGSON2F);
11669 gen_cond_move(env, op1, rd, rs, rt);
11670 break;
11671 case OPC_ADD ... OPC_SUBU:
11672 gen_arith(env, ctx, op1, rd, rs, rt);
11673 break;
11674 case OPC_SLLV: /* Shifts */
11675 case OPC_SRAV:
11676 gen_shift(env, ctx, op1, rd, rs, rt);
11677 break;
11678 case OPC_SRLV:
11679 switch ((ctx->opcode >> 6) & 0x1f) {
11680 case 1:
11681 /* rotrv is decoded as srlv on non-R2 CPUs */
11682 if (env->insn_flags & ISA_MIPS32R2) {
11683 op1 = OPC_ROTRV;
11684 }
11685 /* Fallthrough */
11686 case 0:
11687 gen_shift(env, ctx, op1, rd, rs, rt);
11688 break;
11689 default:
11690 generate_exception(ctx, EXCP_RI);
11691 break;
11692 }
11693 break;
11694 case OPC_SLT: /* Set on less than */
11695 case OPC_SLTU:
11696 gen_slt(env, op1, rd, rs, rt);
11697 break;
11698 case OPC_AND: /* Logic*/
11699 case OPC_OR:
11700 case OPC_NOR:
11701 case OPC_XOR:
11702 gen_logic(env, op1, rd, rs, rt);
11703 break;
11704 case OPC_MULT ... OPC_DIVU:
11705 if (sa) {
11706 check_insn(env, ctx, INSN_VR54XX);
11707 op1 = MASK_MUL_VR54XX(ctx->opcode);
11708 gen_mul_vr54xx(ctx, op1, rd, rs, rt);
11709 } else
11710 gen_muldiv(ctx, op1, rs, rt);
11711 break;
11712 case OPC_JR ... OPC_JALR:
11713 gen_compute_branch(ctx, op1, 4, rs, rd, sa);
11714 *is_branch = 1;
11715 break;
11716 case OPC_TGE ... OPC_TEQ: /* Traps */
11717 case OPC_TNE:
11718 gen_trap(ctx, op1, rs, rt, -1);
11719 break;
11720 case OPC_MFHI: /* Move from HI/LO */
11721 case OPC_MFLO:
11722 gen_HILO(ctx, op1, rd);
11723 break;
11724 case OPC_MTHI:
11725 case OPC_MTLO: /* Move to HI/LO */
11726 gen_HILO(ctx, op1, rs);
11727 break;
11728 case OPC_PMON: /* Pmon entry point, also R4010 selsl */
11729 #ifdef MIPS_STRICT_STANDARD
11730 MIPS_INVAL("PMON / selsl");
11731 generate_exception(ctx, EXCP_RI);
11732 #else
11733 gen_helper_0i(pmon, sa);
11734 #endif
11735 break;
11736 case OPC_SYSCALL:
11737 generate_exception(ctx, EXCP_SYSCALL);
11738 ctx->bstate = BS_STOP;
11739 break;
11740 case OPC_BREAK:
11741 generate_exception(ctx, EXCP_BREAK);
11742 break;
11743 case OPC_SPIM:
11744 #ifdef MIPS_STRICT_STANDARD
11745 MIPS_INVAL("SPIM");
11746 generate_exception(ctx, EXCP_RI);
11747 #else
11748 /* Implemented as RI exception for now. */
11749 MIPS_INVAL("spim (unofficial)");
11750 generate_exception(ctx, EXCP_RI);
11751 #endif
11752 break;
11753 case OPC_SYNC:
11754 /* Treat as NOP. */
11755 break;
11756
11757 case OPC_MOVCI:
11758 check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
11759 if (env->CP0_Config1 & (1 << CP0C1_FP)) {
11760 check_cp1_enabled(ctx);
11761 gen_movci(ctx, rd, rs, (ctx->opcode >> 18) & 0x7,
11762 (ctx->opcode >> 16) & 1);
11763 } else {
11764 generate_exception_err(ctx, EXCP_CpU, 1);
11765 }
11766 break;
11767
11768 #if defined(TARGET_MIPS64)
11769 /* MIPS64 specific opcodes */
11770 case OPC_DSLL:
11771 case OPC_DSRA:
11772 case OPC_DSLL32:
11773 case OPC_DSRA32:
11774 check_insn(env, ctx, ISA_MIPS3);
11775 check_mips_64(ctx);
11776 gen_shift_imm(env, ctx, op1, rd, rt, sa);
11777 break;
11778 case OPC_DSRL:
11779 switch ((ctx->opcode >> 21) & 0x1f) {
11780 case 1:
11781 /* drotr is decoded as dsrl on non-R2 CPUs */
11782 if (env->insn_flags & ISA_MIPS32R2) {
11783 op1 = OPC_DROTR;
11784 }
11785 /* Fallthrough */
11786 case 0:
11787 check_insn(env, ctx, ISA_MIPS3);
11788 check_mips_64(ctx);
11789 gen_shift_imm(env, ctx, op1, rd, rt, sa);
11790 break;
11791 default:
11792 generate_exception(ctx, EXCP_RI);
11793 break;
11794 }
11795 break;
11796 case OPC_DSRL32:
11797 switch ((ctx->opcode >> 21) & 0x1f) {
11798 case 1:
11799 /* drotr32 is decoded as dsrl32 on non-R2 CPUs */
11800 if (env->insn_flags & ISA_MIPS32R2) {
11801 op1 = OPC_DROTR32;
11802 }
11803 /* Fallthrough */
11804 case 0:
11805 check_insn(env, ctx, ISA_MIPS3);
11806 check_mips_64(ctx);
11807 gen_shift_imm(env, ctx, op1, rd, rt, sa);
11808 break;
11809 default:
11810 generate_exception(ctx, EXCP_RI);
11811 break;
11812 }
11813 break;
11814 case OPC_DADD ... OPC_DSUBU:
11815 check_insn(env, ctx, ISA_MIPS3);
11816 check_mips_64(ctx);
11817 gen_arith(env, ctx, op1, rd, rs, rt);
11818 break;
11819 case OPC_DSLLV:
11820 case OPC_DSRAV:
11821 check_insn(env, ctx, ISA_MIPS3);
11822 check_mips_64(ctx);
11823 gen_shift(env, ctx, op1, rd, rs, rt);
11824 break;
11825 case OPC_DSRLV:
11826 switch ((ctx->opcode >> 6) & 0x1f) {
11827 case 1:
11828 /* drotrv is decoded as dsrlv on non-R2 CPUs */
11829 if (env->insn_flags & ISA_MIPS32R2) {
11830 op1 = OPC_DROTRV;
11831 }
11832 /* Fallthrough */
11833 case 0:
11834 check_insn(env, ctx, ISA_MIPS3);
11835 check_mips_64(ctx);
11836 gen_shift(env, ctx, op1, rd, rs, rt);
11837 break;
11838 default:
11839 generate_exception(ctx, EXCP_RI);
11840 break;
11841 }
11842 break;
11843 case OPC_DMULT ... OPC_DDIVU:
11844 check_insn(env, ctx, ISA_MIPS3);
11845 check_mips_64(ctx);
11846 gen_muldiv(ctx, op1, rs, rt);
11847 break;
11848 #endif
11849 default: /* Invalid */
11850 MIPS_INVAL("special");
11851 generate_exception(ctx, EXCP_RI);
11852 break;
11853 }
11854 break;
11855 case OPC_SPECIAL2:
11856 op1 = MASK_SPECIAL2(ctx->opcode);
11857 switch (op1) {
11858 case OPC_MADD ... OPC_MADDU: /* Multiply and add/sub */
11859 case OPC_MSUB ... OPC_MSUBU:
11860 check_insn(env, ctx, ISA_MIPS32);
11861 gen_muldiv(ctx, op1, rs, rt);
11862 break;
11863 case OPC_MUL:
11864 gen_arith(env, ctx, op1, rd, rs, rt);
11865 break;
11866 case OPC_CLO:
11867 case OPC_CLZ:
11868 check_insn(env, ctx, ISA_MIPS32);
11869 gen_cl(ctx, op1, rd, rs);
11870 break;
11871 case OPC_SDBBP:
11872 /* XXX: not clear which exception should be raised
11873 * when in debug mode...
11874 */
11875 check_insn(env, ctx, ISA_MIPS32);
11876 if (!(ctx->hflags & MIPS_HFLAG_DM)) {
11877 generate_exception(ctx, EXCP_DBp);
11878 } else {
11879 generate_exception(ctx, EXCP_DBp);
11880 }
11881 /* Treat as NOP. */
11882 break;
11883 case OPC_DIV_G_2F:
11884 case OPC_DIVU_G_2F:
11885 case OPC_MULT_G_2F:
11886 case OPC_MULTU_G_2F:
11887 case OPC_MOD_G_2F:
11888 case OPC_MODU_G_2F:
11889 check_insn(env, ctx, INSN_LOONGSON2F);
11890 gen_loongson_integer(ctx, op1, rd, rs, rt);
11891 break;
11892 #if defined(TARGET_MIPS64)
11893 case OPC_DCLO:
11894 case OPC_DCLZ:
11895 check_insn(env, ctx, ISA_MIPS64);
11896 check_mips_64(ctx);
11897 gen_cl(ctx, op1, rd, rs);
11898 break;
11899 case OPC_DMULT_G_2F:
11900 case OPC_DMULTU_G_2F:
11901 case OPC_DDIV_G_2F:
11902 case OPC_DDIVU_G_2F:
11903 case OPC_DMOD_G_2F:
11904 case OPC_DMODU_G_2F:
11905 check_insn(env, ctx, INSN_LOONGSON2F);
11906 gen_loongson_integer(ctx, op1, rd, rs, rt);
11907 break;
11908 #endif
11909 default: /* Invalid */
11910 MIPS_INVAL("special2");
11911 generate_exception(ctx, EXCP_RI);
11912 break;
11913 }
11914 break;
11915 case OPC_SPECIAL3:
11916 op1 = MASK_SPECIAL3(ctx->opcode);
11917 switch (op1) {
11918 case OPC_EXT:
11919 case OPC_INS:
11920 check_insn(env, ctx, ISA_MIPS32R2);
11921 gen_bitops(ctx, op1, rt, rs, sa, rd);
11922 break;
11923 case OPC_BSHFL:
11924 check_insn(env, ctx, ISA_MIPS32R2);
11925 op2 = MASK_BSHFL(ctx->opcode);
11926 gen_bshfl(ctx, op2, rt, rd);
11927 break;
11928 case OPC_RDHWR:
11929 gen_rdhwr(env, ctx, rt, rd);
11930 break;
11931 case OPC_FORK:
11932 check_insn(env, ctx, ASE_MT);
11933 {
11934 TCGv t0 = tcg_temp_new();
11935 TCGv t1 = tcg_temp_new();
11936
11937 gen_load_gpr(t0, rt);
11938 gen_load_gpr(t1, rs);
11939 gen_helper_fork(t0, t1);
11940 tcg_temp_free(t0);
11941 tcg_temp_free(t1);
11942 }
11943 break;
11944 case OPC_YIELD:
11945 check_insn(env, ctx, ASE_MT);
11946 {
11947 TCGv t0 = tcg_temp_new();
11948
11949 save_cpu_state(ctx, 1);
11950 gen_load_gpr(t0, rs);
11951 gen_helper_yield(t0, t0);
11952 gen_store_gpr(t0, rd);
11953 tcg_temp_free(t0);
11954 }
11955 break;
11956 case OPC_DIV_G_2E ... OPC_DIVU_G_2E:
11957 case OPC_MULT_G_2E ... OPC_MULTU_G_2E:
11958 case OPC_MOD_G_2E ... OPC_MODU_G_2E:
11959 check_insn(env, ctx, INSN_LOONGSON2E);
11960 gen_loongson_integer(ctx, op1, rd, rs, rt);
11961 break;
11962 #if defined(TARGET_MIPS64)
11963 case OPC_DEXTM ... OPC_DEXT:
11964 case OPC_DINSM ... OPC_DINS:
11965 check_insn(env, ctx, ISA_MIPS64R2);
11966 check_mips_64(ctx);
11967 gen_bitops(ctx, op1, rt, rs, sa, rd);
11968 break;
11969 case OPC_DBSHFL:
11970 check_insn(env, ctx, ISA_MIPS64R2);
11971 check_mips_64(ctx);
11972 op2 = MASK_DBSHFL(ctx->opcode);
11973 gen_bshfl(ctx, op2, rt, rd);
11974 break;
11975 case OPC_DDIV_G_2E ... OPC_DDIVU_G_2E:
11976 case OPC_DMULT_G_2E ... OPC_DMULTU_G_2E:
11977 case OPC_DMOD_G_2E ... OPC_DMODU_G_2E:
11978 check_insn(env, ctx, INSN_LOONGSON2E);
11979 gen_loongson_integer(ctx, op1, rd, rs, rt);
11980 break;
11981 #endif
11982 default: /* Invalid */
11983 MIPS_INVAL("special3");
11984 generate_exception(ctx, EXCP_RI);
11985 break;
11986 }
11987 break;
11988 case OPC_REGIMM:
11989 op1 = MASK_REGIMM(ctx->opcode);
11990 switch (op1) {
11991 case OPC_BLTZ ... OPC_BGEZL: /* REGIMM branches */
11992 case OPC_BLTZAL ... OPC_BGEZALL:
11993 gen_compute_branch(ctx, op1, 4, rs, -1, imm << 2);
11994 *is_branch = 1;
11995 break;
11996 case OPC_TGEI ... OPC_TEQI: /* REGIMM traps */
11997 case OPC_TNEI:
11998 gen_trap(ctx, op1, rs, -1, imm);
11999 break;
12000 case OPC_SYNCI:
12001 check_insn(env, ctx, ISA_MIPS32R2);
12002 /* Treat as NOP. */
12003 break;
12004 default: /* Invalid */
12005 MIPS_INVAL("regimm");
12006 generate_exception(ctx, EXCP_RI);
12007 break;
12008 }
12009 break;
12010 case OPC_CP0:
12011 check_cp0_enabled(ctx);
12012 op1 = MASK_CP0(ctx->opcode);
12013 switch (op1) {
12014 case OPC_MFC0:
12015 case OPC_MTC0:
12016 case OPC_MFTR:
12017 case OPC_MTTR:
12018 #if defined(TARGET_MIPS64)
12019 case OPC_DMFC0:
12020 case OPC_DMTC0:
12021 #endif
12022 #ifndef CONFIG_USER_ONLY
12023 gen_cp0(env, ctx, op1, rt, rd);
12024 #endif /* !CONFIG_USER_ONLY */
12025 break;
12026 case OPC_C0_FIRST ... OPC_C0_LAST:
12027 #ifndef CONFIG_USER_ONLY
12028 gen_cp0(env, ctx, MASK_C0(ctx->opcode), rt, rd);
12029 #endif /* !CONFIG_USER_ONLY */
12030 break;
12031 case OPC_MFMC0:
12032 #ifndef CONFIG_USER_ONLY
12033 {
12034 TCGv t0 = tcg_temp_new();
12035
12036 op2 = MASK_MFMC0(ctx->opcode);
12037 switch (op2) {
12038 case OPC_DMT:
12039 check_insn(env, ctx, ASE_MT);
12040 gen_helper_dmt(t0);
12041 gen_store_gpr(t0, rt);
12042 break;
12043 case OPC_EMT:
12044 check_insn(env, ctx, ASE_MT);
12045 gen_helper_emt(t0);
12046 gen_store_gpr(t0, rt);
12047 break;
12048 case OPC_DVPE:
12049 check_insn(env, ctx, ASE_MT);
12050 gen_helper_dvpe(t0);
12051 gen_store_gpr(t0, rt);
12052 break;
12053 case OPC_EVPE:
12054 check_insn(env, ctx, ASE_MT);
12055 gen_helper_evpe(t0);
12056 gen_store_gpr(t0, rt);
12057 break;
12058 case OPC_DI:
12059 check_insn(env, ctx, ISA_MIPS32R2);
12060 save_cpu_state(ctx, 1);
12061 gen_helper_di(t0);
12062 gen_store_gpr(t0, rt);
12063 /* Stop translation as we may have switched the execution mode */
12064 ctx->bstate = BS_STOP;
12065 break;
12066 case OPC_EI:
12067 check_insn(env, ctx, ISA_MIPS32R2);
12068 save_cpu_state(ctx, 1);
12069 gen_helper_ei(t0);
12070 gen_store_gpr(t0, rt);
12071 /* Stop translation as we may have switched the execution mode */
12072 ctx->bstate = BS_STOP;
12073 break;
12074 default: /* Invalid */
12075 MIPS_INVAL("mfmc0");
12076 generate_exception(ctx, EXCP_RI);
12077 break;
12078 }
12079 tcg_temp_free(t0);
12080 }
12081 #endif /* !CONFIG_USER_ONLY */
12082 break;
12083 case OPC_RDPGPR:
12084 check_insn(env, ctx, ISA_MIPS32R2);
12085 gen_load_srsgpr(rt, rd);
12086 break;
12087 case OPC_WRPGPR:
12088 check_insn(env, ctx, ISA_MIPS32R2);
12089 gen_store_srsgpr(rt, rd);
12090 break;
12091 default:
12092 MIPS_INVAL("cp0");
12093 generate_exception(ctx, EXCP_RI);
12094 break;
12095 }
12096 break;
12097 case OPC_ADDI: /* Arithmetic with immediate opcode */
12098 case OPC_ADDIU:
12099 gen_arith_imm(env, ctx, op, rt, rs, imm);
12100 break;
12101 case OPC_SLTI: /* Set on less than with immediate opcode */
12102 case OPC_SLTIU:
12103 gen_slt_imm(env, op, rt, rs, imm);
12104 break;
12105 case OPC_ANDI: /* Arithmetic with immediate opcode */
12106 case OPC_LUI:
12107 case OPC_ORI:
12108 case OPC_XORI:
12109 gen_logic_imm(env, op, rt, rs, imm);
12110 break;
12111 case OPC_J ... OPC_JAL: /* Jump */
12112 offset = (int32_t)(ctx->opcode & 0x3FFFFFF) << 2;
12113 gen_compute_branch(ctx, op, 4, rs, rt, offset);
12114 *is_branch = 1;
12115 break;
12116 case OPC_BEQ ... OPC_BGTZ: /* Branch */
12117 case OPC_BEQL ... OPC_BGTZL:
12118 gen_compute_branch(ctx, op, 4, rs, rt, imm << 2);
12119 *is_branch = 1;
12120 break;
12121 case OPC_LB ... OPC_LWR: /* Load and stores */
12122 case OPC_LL:
12123 gen_ld(env, ctx, op, rt, rs, imm);
12124 break;
12125 case OPC_SB ... OPC_SW:
12126 case OPC_SWR:
12127 gen_st(ctx, op, rt, rs, imm);
12128 break;
12129 case OPC_SC:
12130 gen_st_cond(ctx, op, rt, rs, imm);
12131 break;
12132 case OPC_CACHE:
12133 check_insn(env, ctx, ISA_MIPS3 | ISA_MIPS32);
12134 /* Treat as NOP. */
12135 break;
12136 case OPC_PREF:
12137 check_insn(env, ctx, ISA_MIPS4 | ISA_MIPS32);
12138 /* Treat as NOP. */
12139 break;
12140
12141 /* Floating point (COP1). */
12142 case OPC_LWC1:
12143 case OPC_LDC1:
12144 case OPC_SWC1:
12145 case OPC_SDC1:
12146 gen_cop1_ldst(env, ctx, op, rt, rs, imm);
12147 break;
12148
12149 case OPC_CP1:
12150 if (env->CP0_Config1 & (1 << CP0C1_FP)) {
12151 check_cp1_enabled(ctx);
12152 op1 = MASK_CP1(ctx->opcode);
12153 switch (op1) {
12154 case OPC_MFHC1:
12155 case OPC_MTHC1:
12156 check_insn(env, ctx, ISA_MIPS32R2);
12157 case OPC_MFC1:
12158 case OPC_CFC1:
12159 case OPC_MTC1:
12160 case OPC_CTC1:
12161 gen_cp1(ctx, op1, rt, rd);
12162 break;
12163 #if defined(TARGET_MIPS64)
12164 case OPC_DMFC1:
12165 case OPC_DMTC1:
12166 check_insn(env, ctx, ISA_MIPS3);
12167 gen_cp1(ctx, op1, rt, rd);
12168 break;
12169 #endif
12170 case OPC_BC1ANY2:
12171 case OPC_BC1ANY4:
12172 check_cop1x(ctx);
12173 check_insn(env, ctx, ASE_MIPS3D);
12174 /* fall through */
12175 case OPC_BC1:
12176 gen_compute_branch1(env, ctx, MASK_BC1(ctx->opcode),
12177 (rt >> 2) & 0x7, imm << 2);
12178 *is_branch = 1;
12179 break;
12180 case OPC_S_FMT:
12181 case OPC_D_FMT:
12182 case OPC_W_FMT:
12183 case OPC_L_FMT:
12184 case OPC_PS_FMT:
12185 gen_farith(ctx, ctx->opcode & FOP(0x3f, 0x1f), rt, rd, sa,
12186 (imm >> 8) & 0x7);
12187 break;
12188 default:
12189 MIPS_INVAL("cp1");
12190 generate_exception (ctx, EXCP_RI);
12191 break;
12192 }
12193 } else {
12194 generate_exception_err(ctx, EXCP_CpU, 1);
12195 }
12196 break;
12197
12198 /* COP2. */
12199 case OPC_LWC2:
12200 case OPC_LDC2:
12201 case OPC_SWC2:
12202 case OPC_SDC2:
12203 case OPC_CP2:
12204 /* COP2: Not implemented. */
12205 generate_exception_err(ctx, EXCP_CpU, 2);
12206 break;
12207
12208 case OPC_CP3:
12209 if (env->CP0_Config1 & (1 << CP0C1_FP)) {
12210 check_cp1_enabled(ctx);
12211 op1 = MASK_CP3(ctx->opcode);
12212 switch (op1) {
12213 case OPC_LWXC1:
12214 case OPC_LDXC1:
12215 case OPC_LUXC1:
12216 case OPC_SWXC1:
12217 case OPC_SDXC1:
12218 case OPC_SUXC1:
12219 gen_flt3_ldst(ctx, op1, sa, rd, rs, rt);
12220 break;
12221 case OPC_PREFX:
12222 /* Treat as NOP. */
12223 break;
12224 case OPC_ALNV_PS:
12225 case OPC_MADD_S:
12226 case OPC_MADD_D:
12227 case OPC_MADD_PS:
12228 case OPC_MSUB_S:
12229 case OPC_MSUB_D:
12230 case OPC_MSUB_PS:
12231 case OPC_NMADD_S:
12232 case OPC_NMADD_D:
12233 case OPC_NMADD_PS:
12234 case OPC_NMSUB_S:
12235 case OPC_NMSUB_D:
12236 case OPC_NMSUB_PS:
12237 gen_flt3_arith(ctx, op1, sa, rs, rd, rt);
12238 break;
12239 default:
12240 MIPS_INVAL("cp3");
12241 generate_exception (ctx, EXCP_RI);
12242 break;
12243 }
12244 } else {
12245 generate_exception_err(ctx, EXCP_CpU, 1);
12246 }
12247 break;
12248
12249 #if defined(TARGET_MIPS64)
12250 /* MIPS64 opcodes */
12251 case OPC_LWU:
12252 case OPC_LDL ... OPC_LDR:
12253 case OPC_LLD:
12254 case OPC_LD:
12255 check_insn(env, ctx, ISA_MIPS3);
12256 check_mips_64(ctx);
12257 gen_ld(env, ctx, op, rt, rs, imm);
12258 break;
12259 case OPC_SDL ... OPC_SDR:
12260 case OPC_SD:
12261 check_insn(env, ctx, ISA_MIPS3);
12262 check_mips_64(ctx);
12263 gen_st(ctx, op, rt, rs, imm);
12264 break;
12265 case OPC_SCD:
12266 check_insn(env, ctx, ISA_MIPS3);
12267 check_mips_64(ctx);
12268 gen_st_cond(ctx, op, rt, rs, imm);
12269 break;
12270 case OPC_DADDI:
12271 case OPC_DADDIU:
12272 check_insn(env, ctx, ISA_MIPS3);
12273 check_mips_64(ctx);
12274 gen_arith_imm(env, ctx, op, rt, rs, imm);
12275 break;
12276 #endif
12277 case OPC_JALX:
12278 check_insn(env, ctx, ASE_MIPS16 | ASE_MICROMIPS);
12279 offset = (int32_t)(ctx->opcode & 0x3FFFFFF) << 2;
12280 gen_compute_branch(ctx, op, 4, rs, rt, offset);
12281 *is_branch = 1;
12282 break;
12283 case OPC_MDMX:
12284 check_insn(env, ctx, ASE_MDMX);
12285 /* MDMX: Not implemented. */
12286 default: /* Invalid */
12287 MIPS_INVAL("major opcode");
12288 generate_exception(ctx, EXCP_RI);
12289 break;
12290 }
12291 }
12292
12293 static inline void
12294 gen_intermediate_code_internal (CPUState *env, TranslationBlock *tb,
12295 int search_pc)
12296 {
12297 DisasContext ctx;
12298 target_ulong pc_start;
12299 uint16_t *gen_opc_end;
12300 CPUBreakpoint *bp;
12301 int j, lj = -1;
12302 int num_insns;
12303 int max_insns;
12304 int insn_bytes;
12305 int is_branch;
12306
12307 if (search_pc)
12308 qemu_log("search pc %d\n", search_pc);
12309
12310 pc_start = tb->pc;
12311 gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
12312 ctx.pc = pc_start;
12313 ctx.saved_pc = -1;
12314 ctx.singlestep_enabled = env->singlestep_enabled;
12315 ctx.tb = tb;
12316 ctx.bstate = BS_NONE;
12317 /* Restore delay slot state from the tb context. */
12318 ctx.hflags = (uint32_t)tb->flags; /* FIXME: maybe use 64 bits here? */
12319 restore_cpu_state(env, &ctx);
12320 #ifdef CONFIG_USER_ONLY
12321 ctx.mem_idx = MIPS_HFLAG_UM;
12322 #else
12323 ctx.mem_idx = ctx.hflags & MIPS_HFLAG_KSU;
12324 #endif
12325 num_insns = 0;
12326 max_insns = tb->cflags & CF_COUNT_MASK;
12327 if (max_insns == 0)
12328 max_insns = CF_COUNT_MASK;
12329 LOG_DISAS("\ntb %p idx %d hflags %04x\n", tb, ctx.mem_idx, ctx.hflags);
12330 gen_icount_start();
12331 while (ctx.bstate == BS_NONE) {
12332 if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
12333 QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
12334 if (bp->pc == ctx.pc) {
12335 save_cpu_state(&ctx, 1);
12336 ctx.bstate = BS_BRANCH;
12337 gen_helper_0i(raise_exception, EXCP_DEBUG);
12338 /* Include the breakpoint location or the tb won't
12339 * be flushed when it must be. */
12340 ctx.pc += 4;
12341 goto done_generating;
12342 }
12343 }
12344 }
12345
12346 if (search_pc) {
12347 j = gen_opc_ptr - gen_opc_buf;
12348 if (lj < j) {
12349 lj++;
12350 while (lj < j)
12351 gen_opc_instr_start[lj++] = 0;
12352 }
12353 gen_opc_pc[lj] = ctx.pc;
12354 gen_opc_hflags[lj] = ctx.hflags & MIPS_HFLAG_BMASK;
12355 gen_opc_instr_start[lj] = 1;
12356 gen_opc_icount[lj] = num_insns;
12357 }
12358 if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
12359 gen_io_start();
12360
12361 is_branch = 0;
12362 if (!(ctx.hflags & MIPS_HFLAG_M16)) {
12363 ctx.opcode = ldl_code(ctx.pc);
12364 insn_bytes = 4;
12365 decode_opc(env, &ctx, &is_branch);
12366 } else if (env->insn_flags & ASE_MICROMIPS) {
12367 ctx.opcode = lduw_code(ctx.pc);
12368 insn_bytes = decode_micromips_opc(env, &ctx, &is_branch);
12369 } else if (env->insn_flags & ASE_MIPS16) {
12370 ctx.opcode = lduw_code(ctx.pc);
12371 insn_bytes = decode_mips16_opc(env, &ctx, &is_branch);
12372 } else {
12373 generate_exception(&ctx, EXCP_RI);
12374 ctx.bstate = BS_STOP;
12375 break;
12376 }
12377 if (!is_branch) {
12378 handle_delay_slot(env, &ctx, insn_bytes);
12379 }
12380 ctx.pc += insn_bytes;
12381
12382 num_insns++;
12383
12384 /* Execute a branch and its delay slot as a single instruction.
12385 This is what GDB expects and is consistent with what the
12386 hardware does (e.g. if a delay slot instruction faults, the
12387 reported PC is the PC of the branch). */
12388 if (env->singlestep_enabled && (ctx.hflags & MIPS_HFLAG_BMASK) == 0)
12389 break;
12390
12391 if ((ctx.pc & (TARGET_PAGE_SIZE - 1)) == 0)
12392 break;
12393
12394 if (gen_opc_ptr >= gen_opc_end)
12395 break;
12396
12397 if (num_insns >= max_insns)
12398 break;
12399
12400 if (singlestep)
12401 break;
12402 }
12403 if (tb->cflags & CF_LAST_IO)
12404 gen_io_end();
12405 if (env->singlestep_enabled && ctx.bstate != BS_BRANCH) {
12406 save_cpu_state(&ctx, ctx.bstate == BS_NONE);
12407 gen_helper_0i(raise_exception, EXCP_DEBUG);
12408 } else {
12409 switch (ctx.bstate) {
12410 case BS_STOP:
12411 gen_goto_tb(&ctx, 0, ctx.pc);
12412 break;
12413 case BS_NONE:
12414 save_cpu_state(&ctx, 0);
12415 gen_goto_tb(&ctx, 0, ctx.pc);
12416 break;
12417 case BS_EXCP:
12418 tcg_gen_exit_tb(0);
12419 break;
12420 case BS_BRANCH:
12421 default:
12422 break;
12423 }
12424 }
12425 done_generating:
12426 gen_icount_end(tb, num_insns);
12427 *gen_opc_ptr = INDEX_op_end;
12428 if (search_pc) {
12429 j = gen_opc_ptr - gen_opc_buf;
12430 lj++;
12431 while (lj <= j)
12432 gen_opc_instr_start[lj++] = 0;
12433 } else {
12434 tb->size = ctx.pc - pc_start;
12435 tb->icount = num_insns;
12436 }
12437 #ifdef DEBUG_DISAS
12438 LOG_DISAS("\n");
12439 if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
12440 qemu_log("IN: %s\n", lookup_symbol(pc_start));
12441 log_target_disas(pc_start, ctx.pc - pc_start, 0);
12442 qemu_log("\n");
12443 }
12444 #endif
12445 }
12446
12447 void gen_intermediate_code (CPUState *env, struct TranslationBlock *tb)
12448 {
12449 gen_intermediate_code_internal(env, tb, 0);
12450 }
12451
12452 void gen_intermediate_code_pc (CPUState *env, struct TranslationBlock *tb)
12453 {
12454 gen_intermediate_code_internal(env, tb, 1);
12455 }
12456
12457 static void fpu_dump_state(CPUState *env, FILE *f, fprintf_function fpu_fprintf,
12458 int flags)
12459 {
12460 int i;
12461 int is_fpu64 = !!(env->hflags & MIPS_HFLAG_F64);
12462
12463 #define printfpr(fp) \
12464 do { \
12465 if (is_fpu64) \
12466 fpu_fprintf(f, "w:%08x d:%016" PRIx64 \
12467 " fd:%13g fs:%13g psu: %13g\n", \
12468 (fp)->w[FP_ENDIAN_IDX], (fp)->d, \
12469 (double)(fp)->fd, \
12470 (double)(fp)->fs[FP_ENDIAN_IDX], \
12471 (double)(fp)->fs[!FP_ENDIAN_IDX]); \
12472 else { \
12473 fpr_t tmp; \
12474 tmp.w[FP_ENDIAN_IDX] = (fp)->w[FP_ENDIAN_IDX]; \
12475 tmp.w[!FP_ENDIAN_IDX] = ((fp) + 1)->w[FP_ENDIAN_IDX]; \
12476 fpu_fprintf(f, "w:%08x d:%016" PRIx64 \
12477 " fd:%13g fs:%13g psu:%13g\n", \
12478 tmp.w[FP_ENDIAN_IDX], tmp.d, \
12479 (double)tmp.fd, \
12480 (double)tmp.fs[FP_ENDIAN_IDX], \
12481 (double)tmp.fs[!FP_ENDIAN_IDX]); \
12482 } \
12483 } while(0)
12484
12485
12486 fpu_fprintf(f, "CP1 FCR0 0x%08x FCR31 0x%08x SR.FR %d fp_status 0x%02x\n",
12487 env->active_fpu.fcr0, env->active_fpu.fcr31, is_fpu64,
12488 get_float_exception_flags(&env->active_fpu.fp_status));
12489 for (i = 0; i < 32; (is_fpu64) ? i++ : (i += 2)) {
12490 fpu_fprintf(f, "%3s: ", fregnames[i]);
12491 printfpr(&env->active_fpu.fpr[i]);
12492 }
12493
12494 #undef printfpr
12495 }
12496
12497 #if defined(TARGET_MIPS64) && defined(MIPS_DEBUG_SIGN_EXTENSIONS)
12498 /* Debug help: The architecture requires 32bit code to maintain proper
12499 sign-extended values on 64bit machines. */
12500
12501 #define SIGN_EXT_P(val) ((((val) & ~0x7fffffff) == 0) || (((val) & ~0x7fffffff) == ~0x7fffffff))
12502
12503 static void
12504 cpu_mips_check_sign_extensions (CPUState *env, FILE *f,
12505 fprintf_function cpu_fprintf,
12506 int flags)
12507 {
12508 int i;
12509
12510 if (!SIGN_EXT_P(env->active_tc.PC))
12511 cpu_fprintf(f, "BROKEN: pc=0x" TARGET_FMT_lx "\n", env->active_tc.PC);
12512 if (!SIGN_EXT_P(env->active_tc.HI[0]))
12513 cpu_fprintf(f, "BROKEN: HI=0x" TARGET_FMT_lx "\n", env->active_tc.HI[0]);
12514 if (!SIGN_EXT_P(env->active_tc.LO[0]))
12515 cpu_fprintf(f, "BROKEN: LO=0x" TARGET_FMT_lx "\n", env->active_tc.LO[0]);
12516 if (!SIGN_EXT_P(env->btarget))
12517 cpu_fprintf(f, "BROKEN: btarget=0x" TARGET_FMT_lx "\n", env->btarget);
12518
12519 for (i = 0; i < 32; i++) {
12520 if (!SIGN_EXT_P(env->active_tc.gpr[i]))
12521 cpu_fprintf(f, "BROKEN: %s=0x" TARGET_FMT_lx "\n", regnames[i], env->active_tc.gpr[i]);
12522 }
12523
12524 if (!SIGN_EXT_P(env->CP0_EPC))
12525 cpu_fprintf(f, "BROKEN: EPC=0x" TARGET_FMT_lx "\n", env->CP0_EPC);
12526 if (!SIGN_EXT_P(env->lladdr))
12527 cpu_fprintf(f, "BROKEN: LLAddr=0x" TARGET_FMT_lx "\n", env->lladdr);
12528 }
12529 #endif
12530
12531 void cpu_dump_state (CPUState *env, FILE *f, fprintf_function cpu_fprintf,
12532 int flags)
12533 {
12534 int i;
12535
12536 cpu_fprintf(f, "pc=0x" TARGET_FMT_lx " HI=0x" TARGET_FMT_lx
12537 " LO=0x" TARGET_FMT_lx " ds %04x "
12538 TARGET_FMT_lx " " TARGET_FMT_ld "\n",
12539 env->active_tc.PC, env->active_tc.HI[0], env->active_tc.LO[0],
12540 env->hflags, env->btarget, env->bcond);
12541 for (i = 0; i < 32; i++) {
12542 if ((i & 3) == 0)
12543 cpu_fprintf(f, "GPR%02d:", i);
12544 cpu_fprintf(f, " %s " TARGET_FMT_lx, regnames[i], env->active_tc.gpr[i]);
12545 if ((i & 3) == 3)
12546 cpu_fprintf(f, "\n");
12547 }
12548
12549 cpu_fprintf(f, "CP0 Status 0x%08x Cause 0x%08x EPC 0x" TARGET_FMT_lx "\n",
12550 env->CP0_Status, env->CP0_Cause, env->CP0_EPC);
12551 cpu_fprintf(f, " Config0 0x%08x Config1 0x%08x LLAddr 0x" TARGET_FMT_lx "\n",
12552 env->CP0_Config0, env->CP0_Config1, env->lladdr);
12553 if (env->hflags & MIPS_HFLAG_FPU)
12554 fpu_dump_state(env, f, cpu_fprintf, flags);
12555 #if defined(TARGET_MIPS64) && defined(MIPS_DEBUG_SIGN_EXTENSIONS)
12556 cpu_mips_check_sign_extensions(env, f, cpu_fprintf, flags);
12557 #endif
12558 }
12559
12560 static void mips_tcg_init(void)
12561 {
12562 int i;
12563 static int inited;
12564
12565 /* Initialize various static tables. */
12566 if (inited)
12567 return;
12568
12569 cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
12570 TCGV_UNUSED(cpu_gpr[0]);
12571 for (i = 1; i < 32; i++)
12572 cpu_gpr[i] = tcg_global_mem_new(TCG_AREG0,
12573 offsetof(CPUState, active_tc.gpr[i]),
12574 regnames[i]);
12575 cpu_PC = tcg_global_mem_new(TCG_AREG0,
12576 offsetof(CPUState, active_tc.PC), "PC");
12577 for (i = 0; i < MIPS_DSP_ACC; i++) {
12578 cpu_HI[i] = tcg_global_mem_new(TCG_AREG0,
12579 offsetof(CPUState, active_tc.HI[i]),
12580 regnames_HI[i]);
12581 cpu_LO[i] = tcg_global_mem_new(TCG_AREG0,
12582 offsetof(CPUState, active_tc.LO[i]),
12583 regnames_LO[i]);
12584 cpu_ACX[i] = tcg_global_mem_new(TCG_AREG0,
12585 offsetof(CPUState, active_tc.ACX[i]),
12586 regnames_ACX[i]);
12587 }
12588 cpu_dspctrl = tcg_global_mem_new(TCG_AREG0,
12589 offsetof(CPUState, active_tc.DSPControl),
12590 "DSPControl");
12591 bcond = tcg_global_mem_new(TCG_AREG0,
12592 offsetof(CPUState, bcond), "bcond");
12593 btarget = tcg_global_mem_new(TCG_AREG0,
12594 offsetof(CPUState, btarget), "btarget");
12595 hflags = tcg_global_mem_new_i32(TCG_AREG0,
12596 offsetof(CPUState, hflags), "hflags");
12597
12598 fpu_fcr0 = tcg_global_mem_new_i32(TCG_AREG0,
12599 offsetof(CPUState, active_fpu.fcr0),
12600 "fcr0");
12601 fpu_fcr31 = tcg_global_mem_new_i32(TCG_AREG0,
12602 offsetof(CPUState, active_fpu.fcr31),
12603 "fcr31");
12604
12605 /* register helpers */
12606 #define GEN_HELPER 2
12607 #include "helper.h"
12608
12609 inited = 1;
12610 }
12611
12612 #include "translate_init.c"
12613
12614 CPUMIPSState *cpu_mips_init (const char *cpu_model)
12615 {
12616 CPUMIPSState *env;
12617 const mips_def_t *def;
12618
12619 def = cpu_mips_find_by_name(cpu_model);
12620 if (!def)
12621 return NULL;
12622 env = qemu_mallocz(sizeof(CPUMIPSState));
12623 env->cpu_model = def;
12624 env->cpu_model_str = cpu_model;
12625
12626 cpu_exec_init(env);
12627 #ifndef CONFIG_USER_ONLY
12628 mmu_init(env, def);
12629 #endif
12630 fpu_init(env, def);
12631 mvp_init(env, def);
12632 mips_tcg_init();
12633 cpu_reset(env);
12634 qemu_init_vcpu(env);
12635 return env;
12636 }
12637
12638 void cpu_reset (CPUMIPSState *env)
12639 {
12640 if (qemu_loglevel_mask(CPU_LOG_RESET)) {
12641 qemu_log("CPU Reset (CPU %d)\n", env->cpu_index);
12642 log_cpu_state(env, 0);
12643 }
12644
12645 memset(env, 0, offsetof(CPUMIPSState, breakpoints));
12646 tlb_flush(env, 1);
12647
12648 /* Reset registers to their default values */
12649 env->CP0_PRid = env->cpu_model->CP0_PRid;
12650 env->CP0_Config0 = env->cpu_model->CP0_Config0;
12651 #ifdef TARGET_WORDS_BIGENDIAN
12652 env->CP0_Config0 |= (1 << CP0C0_BE);
12653 #endif
12654 env->CP0_Config1 = env->cpu_model->CP0_Config1;
12655 env->CP0_Config2 = env->cpu_model->CP0_Config2;
12656 env->CP0_Config3 = env->cpu_model->CP0_Config3;
12657 env->CP0_Config6 = env->cpu_model->CP0_Config6;
12658 env->CP0_Config7 = env->cpu_model->CP0_Config7;
12659 env->CP0_LLAddr_rw_bitmask = env->cpu_model->CP0_LLAddr_rw_bitmask
12660 << env->cpu_model->CP0_LLAddr_shift;
12661 env->CP0_LLAddr_shift = env->cpu_model->CP0_LLAddr_shift;
12662 env->SYNCI_Step = env->cpu_model->SYNCI_Step;
12663 env->CCRes = env->cpu_model->CCRes;
12664 env->CP0_Status_rw_bitmask = env->cpu_model->CP0_Status_rw_bitmask;
12665 env->CP0_TCStatus_rw_bitmask = env->cpu_model->CP0_TCStatus_rw_bitmask;
12666 env->CP0_SRSCtl = env->cpu_model->CP0_SRSCtl;
12667 env->current_tc = 0;
12668 env->SEGBITS = env->cpu_model->SEGBITS;
12669 env->SEGMask = (target_ulong)((1ULL << env->cpu_model->SEGBITS) - 1);
12670 #if defined(TARGET_MIPS64)
12671 if (env->cpu_model->insn_flags & ISA_MIPS3) {
12672 env->SEGMask |= 3ULL << 62;
12673 }
12674 #endif
12675 env->PABITS = env->cpu_model->PABITS;
12676 env->PAMask = (target_ulong)((1ULL << env->cpu_model->PABITS) - 1);
12677 env->CP0_SRSConf0_rw_bitmask = env->cpu_model->CP0_SRSConf0_rw_bitmask;
12678 env->CP0_SRSConf0 = env->cpu_model->CP0_SRSConf0;
12679 env->CP0_SRSConf1_rw_bitmask = env->cpu_model->CP0_SRSConf1_rw_bitmask;
12680 env->CP0_SRSConf1 = env->cpu_model->CP0_SRSConf1;
12681 env->CP0_SRSConf2_rw_bitmask = env->cpu_model->CP0_SRSConf2_rw_bitmask;
12682 env->CP0_SRSConf2 = env->cpu_model->CP0_SRSConf2;
12683 env->CP0_SRSConf3_rw_bitmask = env->cpu_model->CP0_SRSConf3_rw_bitmask;
12684 env->CP0_SRSConf3 = env->cpu_model->CP0_SRSConf3;
12685 env->CP0_SRSConf4_rw_bitmask = env->cpu_model->CP0_SRSConf4_rw_bitmask;
12686 env->CP0_SRSConf4 = env->cpu_model->CP0_SRSConf4;
12687 env->insn_flags = env->cpu_model->insn_flags;
12688
12689 #if defined(CONFIG_USER_ONLY)
12690 env->hflags = MIPS_HFLAG_UM;
12691 /* Enable access to the SYNCI_Step register. */
12692 env->CP0_HWREna |= (1 << 1);
12693 if (env->CP0_Config1 & (1 << CP0C1_FP)) {
12694 env->hflags |= MIPS_HFLAG_FPU;
12695 }
12696 #ifdef TARGET_MIPS64
12697 if (env->active_fpu.fcr0 & (1 << FCR0_F64)) {
12698 env->hflags |= MIPS_HFLAG_F64;
12699 }
12700 #endif
12701 #else
12702 if (env->hflags & MIPS_HFLAG_BMASK) {
12703 /* If the exception was raised from a delay slot,
12704 come back to the jump. */
12705 env->CP0_ErrorEPC = env->active_tc.PC - 4;
12706 } else {
12707 env->CP0_ErrorEPC = env->active_tc.PC;
12708 }
12709 env->active_tc.PC = (int32_t)0xBFC00000;
12710 env->CP0_Random = env->tlb->nb_tlb - 1;
12711 env->tlb->tlb_in_use = env->tlb->nb_tlb;
12712 env->CP0_Wired = 0;
12713 env->CP0_EBase = 0x80000000 | (env->cpu_index & 0x3FF);
12714 env->CP0_Status = (1 << CP0St_BEV) | (1 << CP0St_ERL);
12715 /* vectored interrupts not implemented, timer on int 7,
12716 no performance counters. */
12717 env->CP0_IntCtl = 0xe0000000;
12718 {
12719 int i;
12720
12721 for (i = 0; i < 7; i++) {
12722 env->CP0_WatchLo[i] = 0;
12723 env->CP0_WatchHi[i] = 0x80000000;
12724 }
12725 env->CP0_WatchLo[7] = 0;
12726 env->CP0_WatchHi[7] = 0;
12727 }
12728 /* Count register increments in debug mode, EJTAG version 1 */
12729 env->CP0_Debug = (1 << CP0DB_CNT) | (0x1 << CP0DB_VER);
12730 env->hflags = MIPS_HFLAG_CP0;
12731 #endif
12732 #if defined(TARGET_MIPS64)
12733 if (env->cpu_model->insn_flags & ISA_MIPS3) {
12734 env->hflags |= MIPS_HFLAG_64;
12735 }
12736 #endif
12737 env->exception_index = EXCP_NONE;
12738 }
12739
12740 void restore_state_to_opc(CPUState *env, TranslationBlock *tb, int pc_pos)
12741 {
12742 env->active_tc.PC = gen_opc_pc[pc_pos];
12743 env->hflags &= ~MIPS_HFLAG_BMASK;
12744 env->hflags |= gen_opc_hflags[pc_pos];
12745 }
QEmu