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