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