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