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