1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include "qemu/osdep.h"
22#include "cpu.h"
23#include "internal.h"
24#include "exec/helper-proto.h"
25#include "exec/exec-all.h"
26#include "exec/memop.h"
27#include "fpu_helper.h"
28
29
30
31
32void helper_raise_exception_err(CPUMIPSState *env, uint32_t exception,
33 int error_code)
34{
35 do_raise_exception_err(env, exception, error_code, 0);
36}
37
38void helper_raise_exception(CPUMIPSState *env, uint32_t exception)
39{
40 do_raise_exception(env, exception, GETPC());
41}
42
43void helper_raise_exception_debug(CPUMIPSState *env)
44{
45 do_raise_exception(env, EXCP_DEBUG, 0);
46}
47
48static void raise_exception(CPUMIPSState *env, uint32_t exception)
49{
50 do_raise_exception(env, exception, 0);
51}
52
53
54static inline uint64_t get_HILO(CPUMIPSState *env)
55{
56 return ((uint64_t)(env->active_tc.HI[0]) << 32) |
57 (uint32_t)env->active_tc.LO[0];
58}
59
60static inline target_ulong set_HIT0_LO(CPUMIPSState *env, uint64_t HILO)
61{
62 env->active_tc.LO[0] = (int32_t)(HILO & 0xFFFFFFFF);
63 return env->active_tc.HI[0] = (int32_t)(HILO >> 32);
64}
65
66static inline target_ulong set_HI_LOT0(CPUMIPSState *env, uint64_t HILO)
67{
68 target_ulong tmp = env->active_tc.LO[0] = (int32_t)(HILO & 0xFFFFFFFF);
69 env->active_tc.HI[0] = (int32_t)(HILO >> 32);
70 return tmp;
71}
72
73
74target_ulong helper_muls(CPUMIPSState *env, target_ulong arg1,
75 target_ulong arg2)
76{
77 return set_HI_LOT0(env, 0 - ((int64_t)(int32_t)arg1 *
78 (int64_t)(int32_t)arg2));
79}
80
81target_ulong helper_mulsu(CPUMIPSState *env, target_ulong arg1,
82 target_ulong arg2)
83{
84 return set_HI_LOT0(env, 0 - (uint64_t)(uint32_t)arg1 *
85 (uint64_t)(uint32_t)arg2);
86}
87
88target_ulong helper_macc(CPUMIPSState *env, target_ulong arg1,
89 target_ulong arg2)
90{
91 return set_HI_LOT0(env, (int64_t)get_HILO(env) + (int64_t)(int32_t)arg1 *
92 (int64_t)(int32_t)arg2);
93}
94
95target_ulong helper_macchi(CPUMIPSState *env, target_ulong arg1,
96 target_ulong arg2)
97{
98 return set_HIT0_LO(env, (int64_t)get_HILO(env) + (int64_t)(int32_t)arg1 *
99 (int64_t)(int32_t)arg2);
100}
101
102target_ulong helper_maccu(CPUMIPSState *env, target_ulong arg1,
103 target_ulong arg2)
104{
105 return set_HI_LOT0(env, (uint64_t)get_HILO(env) +
106 (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
107}
108
109target_ulong helper_macchiu(CPUMIPSState *env, target_ulong arg1,
110 target_ulong arg2)
111{
112 return set_HIT0_LO(env, (uint64_t)get_HILO(env) +
113 (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
114}
115
116target_ulong helper_msac(CPUMIPSState *env, target_ulong arg1,
117 target_ulong arg2)
118{
119 return set_HI_LOT0(env, (int64_t)get_HILO(env) - (int64_t)(int32_t)arg1 *
120 (int64_t)(int32_t)arg2);
121}
122
123target_ulong helper_msachi(CPUMIPSState *env, target_ulong arg1,
124 target_ulong arg2)
125{
126 return set_HIT0_LO(env, (int64_t)get_HILO(env) - (int64_t)(int32_t)arg1 *
127 (int64_t)(int32_t)arg2);
128}
129
130target_ulong helper_msacu(CPUMIPSState *env, target_ulong arg1,
131 target_ulong arg2)
132{
133 return set_HI_LOT0(env, (uint64_t)get_HILO(env) -
134 (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
135}
136
137target_ulong helper_msachiu(CPUMIPSState *env, target_ulong arg1,
138 target_ulong arg2)
139{
140 return set_HIT0_LO(env, (uint64_t)get_HILO(env) -
141 (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
142}
143
144target_ulong helper_mulhi(CPUMIPSState *env, target_ulong arg1,
145 target_ulong arg2)
146{
147 return set_HIT0_LO(env, (int64_t)(int32_t)arg1 * (int64_t)(int32_t)arg2);
148}
149
150target_ulong helper_mulhiu(CPUMIPSState *env, target_ulong arg1,
151 target_ulong arg2)
152{
153 return set_HIT0_LO(env, (uint64_t)(uint32_t)arg1 *
154 (uint64_t)(uint32_t)arg2);
155}
156
157target_ulong helper_mulshi(CPUMIPSState *env, target_ulong arg1,
158 target_ulong arg2)
159{
160 return set_HIT0_LO(env, 0 - (int64_t)(int32_t)arg1 *
161 (int64_t)(int32_t)arg2);
162}
163
164target_ulong helper_mulshiu(CPUMIPSState *env, target_ulong arg1,
165 target_ulong arg2)
166{
167 return set_HIT0_LO(env, 0 - (uint64_t)(uint32_t)arg1 *
168 (uint64_t)(uint32_t)arg2);
169}
170
171static inline target_ulong bitswap(target_ulong v)
172{
173 v = ((v >> 1) & (target_ulong)0x5555555555555555ULL) |
174 ((v & (target_ulong)0x5555555555555555ULL) << 1);
175 v = ((v >> 2) & (target_ulong)0x3333333333333333ULL) |
176 ((v & (target_ulong)0x3333333333333333ULL) << 2);
177 v = ((v >> 4) & (target_ulong)0x0F0F0F0F0F0F0F0FULL) |
178 ((v & (target_ulong)0x0F0F0F0F0F0F0F0FULL) << 4);
179 return v;
180}
181
182#ifdef TARGET_MIPS64
183target_ulong helper_dbitswap(target_ulong rt)
184{
185 return bitswap(rt);
186}
187#endif
188
189target_ulong helper_bitswap(target_ulong rt)
190{
191 return (int32_t)bitswap(rt);
192}
193
194target_ulong helper_rotx(target_ulong rs, uint32_t shift, uint32_t shiftx,
195 uint32_t stripe)
196{
197 int i;
198 uint64_t tmp0 = ((uint64_t)rs) << 32 | ((uint64_t)rs & 0xffffffff);
199 uint64_t tmp1 = tmp0;
200 for (i = 0; i <= 46; i++) {
201 int s;
202 if (i & 0x8) {
203 s = shift;
204 } else {
205 s = shiftx;
206 }
207
208 if (stripe != 0 && !(i & 0x4)) {
209 s = ~s;
210 }
211 if (s & 0x10) {
212 if (tmp0 & (1LL << (i + 16))) {
213 tmp1 |= 1LL << i;
214 } else {
215 tmp1 &= ~(1LL << i);
216 }
217 }
218 }
219
220 uint64_t tmp2 = tmp1;
221 for (i = 0; i <= 38; i++) {
222 int s;
223 if (i & 0x4) {
224 s = shift;
225 } else {
226 s = shiftx;
227 }
228
229 if (s & 0x8) {
230 if (tmp1 & (1LL << (i + 8))) {
231 tmp2 |= 1LL << i;
232 } else {
233 tmp2 &= ~(1LL << i);
234 }
235 }
236 }
237
238 uint64_t tmp3 = tmp2;
239 for (i = 0; i <= 34; i++) {
240 int s;
241 if (i & 0x2) {
242 s = shift;
243 } else {
244 s = shiftx;
245 }
246 if (s & 0x4) {
247 if (tmp2 & (1LL << (i + 4))) {
248 tmp3 |= 1LL << i;
249 } else {
250 tmp3 &= ~(1LL << i);
251 }
252 }
253 }
254
255 uint64_t tmp4 = tmp3;
256 for (i = 0; i <= 32; i++) {
257 int s;
258 if (i & 0x1) {
259 s = shift;
260 } else {
261 s = shiftx;
262 }
263 if (s & 0x2) {
264 if (tmp3 & (1LL << (i + 2))) {
265 tmp4 |= 1LL << i;
266 } else {
267 tmp4 &= ~(1LL << i);
268 }
269 }
270 }
271
272 uint64_t tmp5 = tmp4;
273 for (i = 0; i <= 31; i++) {
274 int s;
275 s = shift;
276 if (s & 0x1) {
277 if (tmp4 & (1LL << (i + 1))) {
278 tmp5 |= 1LL << i;
279 } else {
280 tmp5 &= ~(1LL << i);
281 }
282 }
283 }
284
285 return (int64_t)(int32_t)(uint32_t)tmp5;
286}
287
288#ifndef CONFIG_USER_ONLY
289
290static inline hwaddr do_translate_address(CPUMIPSState *env,
291 target_ulong address,
292 MMUAccessType access_type,
293 uintptr_t retaddr)
294{
295 hwaddr paddr;
296 CPUState *cs = env_cpu(env);
297
298 paddr = cpu_mips_translate_address(env, address, access_type);
299
300 if (paddr == -1LL) {
301 cpu_loop_exit_restore(cs, retaddr);
302 } else {
303 return paddr;
304 }
305}
306
307#define HELPER_LD_ATOMIC(name, insn, almask, do_cast) \
308target_ulong helper_##name(CPUMIPSState *env, target_ulong arg, int mem_idx) \
309{ \
310 if (arg & almask) { \
311 if (!(env->hflags & MIPS_HFLAG_DM)) { \
312 env->CP0_BadVAddr = arg; \
313 } \
314 do_raise_exception(env, EXCP_AdEL, GETPC()); \
315 } \
316 env->CP0_LLAddr = do_translate_address(env, arg, MMU_DATA_LOAD, GETPC()); \
317 env->lladdr = arg; \
318 env->llval = do_cast cpu_##insn##_mmuidx_ra(env, arg, mem_idx, GETPC()); \
319 return env->llval; \
320}
321HELPER_LD_ATOMIC(ll, ldl, 0x3, (target_long)(int32_t))
322#ifdef TARGET_MIPS64
323HELPER_LD_ATOMIC(lld, ldq, 0x7, (target_ulong))
324#endif
325#undef HELPER_LD_ATOMIC
326#endif
327
328#ifdef TARGET_WORDS_BIGENDIAN
329#define GET_LMASK(v) ((v) & 3)
330#define GET_OFFSET(addr, offset) (addr + (offset))
331#else
332#define GET_LMASK(v) (((v) & 3) ^ 3)
333#define GET_OFFSET(addr, offset) (addr - (offset))
334#endif
335
336void helper_swl(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
337 int mem_idx)
338{
339 cpu_stb_mmuidx_ra(env, arg2, (uint8_t)(arg1 >> 24), mem_idx, GETPC());
340
341 if (GET_LMASK(arg2) <= 2) {
342 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, 1), (uint8_t)(arg1 >> 16),
343 mem_idx, GETPC());
344 }
345
346 if (GET_LMASK(arg2) <= 1) {
347 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, 2), (uint8_t)(arg1 >> 8),
348 mem_idx, GETPC());
349 }
350
351 if (GET_LMASK(arg2) == 0) {
352 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, 3), (uint8_t)arg1,
353 mem_idx, GETPC());
354 }
355}
356
357void helper_swr(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
358 int mem_idx)
359{
360 cpu_stb_mmuidx_ra(env, arg2, (uint8_t)arg1, mem_idx, GETPC());
361
362 if (GET_LMASK(arg2) >= 1) {
363 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, -1), (uint8_t)(arg1 >> 8),
364 mem_idx, GETPC());
365 }
366
367 if (GET_LMASK(arg2) >= 2) {
368 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, -2), (uint8_t)(arg1 >> 16),
369 mem_idx, GETPC());
370 }
371
372 if (GET_LMASK(arg2) == 3) {
373 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, -3), (uint8_t)(arg1 >> 24),
374 mem_idx, GETPC());
375 }
376}
377
378#if defined(TARGET_MIPS64)
379
380
381
382
383#ifdef TARGET_WORDS_BIGENDIAN
384#define GET_LMASK64(v) ((v) & 7)
385#else
386#define GET_LMASK64(v) (((v) & 7) ^ 7)
387#endif
388
389void helper_sdl(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
390 int mem_idx)
391{
392 cpu_stb_mmuidx_ra(env, arg2, (uint8_t)(arg1 >> 56), mem_idx, GETPC());
393
394 if (GET_LMASK64(arg2) <= 6) {
395 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, 1), (uint8_t)(arg1 >> 48),
396 mem_idx, GETPC());
397 }
398
399 if (GET_LMASK64(arg2) <= 5) {
400 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, 2), (uint8_t)(arg1 >> 40),
401 mem_idx, GETPC());
402 }
403
404 if (GET_LMASK64(arg2) <= 4) {
405 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, 3), (uint8_t)(arg1 >> 32),
406 mem_idx, GETPC());
407 }
408
409 if (GET_LMASK64(arg2) <= 3) {
410 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, 4), (uint8_t)(arg1 >> 24),
411 mem_idx, GETPC());
412 }
413
414 if (GET_LMASK64(arg2) <= 2) {
415 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, 5), (uint8_t)(arg1 >> 16),
416 mem_idx, GETPC());
417 }
418
419 if (GET_LMASK64(arg2) <= 1) {
420 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, 6), (uint8_t)(arg1 >> 8),
421 mem_idx, GETPC());
422 }
423
424 if (GET_LMASK64(arg2) <= 0) {
425 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, 7), (uint8_t)arg1,
426 mem_idx, GETPC());
427 }
428}
429
430void helper_sdr(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
431 int mem_idx)
432{
433 cpu_stb_mmuidx_ra(env, arg2, (uint8_t)arg1, mem_idx, GETPC());
434
435 if (GET_LMASK64(arg2) >= 1) {
436 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, -1), (uint8_t)(arg1 >> 8),
437 mem_idx, GETPC());
438 }
439
440 if (GET_LMASK64(arg2) >= 2) {
441 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, -2), (uint8_t)(arg1 >> 16),
442 mem_idx, GETPC());
443 }
444
445 if (GET_LMASK64(arg2) >= 3) {
446 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, -3), (uint8_t)(arg1 >> 24),
447 mem_idx, GETPC());
448 }
449
450 if (GET_LMASK64(arg2) >= 4) {
451 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, -4), (uint8_t)(arg1 >> 32),
452 mem_idx, GETPC());
453 }
454
455 if (GET_LMASK64(arg2) >= 5) {
456 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, -5), (uint8_t)(arg1 >> 40),
457 mem_idx, GETPC());
458 }
459
460 if (GET_LMASK64(arg2) >= 6) {
461 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, -6), (uint8_t)(arg1 >> 48),
462 mem_idx, GETPC());
463 }
464
465 if (GET_LMASK64(arg2) == 7) {
466 cpu_stb_mmuidx_ra(env, GET_OFFSET(arg2, -7), (uint8_t)(arg1 >> 56),
467 mem_idx, GETPC());
468 }
469}
470#endif
471
472static const int multiple_regs[] = { 16, 17, 18, 19, 20, 21, 22, 23, 30 };
473
474void helper_lwm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
475 uint32_t mem_idx)
476{
477 target_ulong base_reglist = reglist & 0xf;
478 target_ulong do_r31 = reglist & 0x10;
479
480 if (base_reglist > 0 && base_reglist <= ARRAY_SIZE(multiple_regs)) {
481 target_ulong i;
482
483 for (i = 0; i < base_reglist; i++) {
484 env->active_tc.gpr[multiple_regs[i]] =
485 (target_long)cpu_ldl_mmuidx_ra(env, addr, mem_idx, GETPC());
486 addr += 4;
487 }
488 }
489
490 if (do_r31) {
491 env->active_tc.gpr[31] =
492 (target_long)cpu_ldl_mmuidx_ra(env, addr, mem_idx, GETPC());
493 }
494}
495
496void helper_swm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
497 uint32_t mem_idx)
498{
499 target_ulong base_reglist = reglist & 0xf;
500 target_ulong do_r31 = reglist & 0x10;
501
502 if (base_reglist > 0 && base_reglist <= ARRAY_SIZE(multiple_regs)) {
503 target_ulong i;
504
505 for (i = 0; i < base_reglist; i++) {
506 cpu_stw_mmuidx_ra(env, addr, env->active_tc.gpr[multiple_regs[i]],
507 mem_idx, GETPC());
508 addr += 4;
509 }
510 }
511
512 if (do_r31) {
513 cpu_stw_mmuidx_ra(env, addr, env->active_tc.gpr[31], mem_idx, GETPC());
514 }
515}
516
517#if defined(TARGET_MIPS64)
518void helper_ldm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
519 uint32_t mem_idx)
520{
521 target_ulong base_reglist = reglist & 0xf;
522 target_ulong do_r31 = reglist & 0x10;
523
524 if (base_reglist > 0 && base_reglist <= ARRAY_SIZE(multiple_regs)) {
525 target_ulong i;
526
527 for (i = 0; i < base_reglist; i++) {
528 env->active_tc.gpr[multiple_regs[i]] =
529 cpu_ldq_mmuidx_ra(env, addr, mem_idx, GETPC());
530 addr += 8;
531 }
532 }
533
534 if (do_r31) {
535 env->active_tc.gpr[31] =
536 cpu_ldq_mmuidx_ra(env, addr, mem_idx, GETPC());
537 }
538}
539
540void helper_sdm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
541 uint32_t mem_idx)
542{
543 target_ulong base_reglist = reglist & 0xf;
544 target_ulong do_r31 = reglist & 0x10;
545
546 if (base_reglist > 0 && base_reglist <= ARRAY_SIZE(multiple_regs)) {
547 target_ulong i;
548
549 for (i = 0; i < base_reglist; i++) {
550 cpu_stq_mmuidx_ra(env, addr, env->active_tc.gpr[multiple_regs[i]],
551 mem_idx, GETPC());
552 addr += 8;
553 }
554 }
555
556 if (do_r31) {
557 cpu_stq_mmuidx_ra(env, addr, env->active_tc.gpr[31], mem_idx, GETPC());
558 }
559}
560#endif
561
562
563void helper_fork(target_ulong arg1, target_ulong arg2)
564{
565
566
567
568
569}
570
571target_ulong helper_yield(CPUMIPSState *env, target_ulong arg)
572{
573 target_long arg1 = arg;
574
575 if (arg1 < 0) {
576
577 if (arg1 != -2) {
578 if (env->CP0_VPEControl & (1 << CP0VPECo_YSI) &&
579 env->active_tc.CP0_TCStatus & (1 << CP0TCSt_DT)) {
580 env->CP0_VPEControl &= ~(0x7 << CP0VPECo_EXCPT);
581 env->CP0_VPEControl |= 4 << CP0VPECo_EXCPT;
582 do_raise_exception(env, EXCP_THREAD, GETPC());
583 }
584 }
585 } else if (arg1 == 0) {
586 if (0) {
587
588 env->CP0_VPEControl &= ~(0x7 << CP0VPECo_EXCPT);
589 do_raise_exception(env, EXCP_THREAD, GETPC());
590 } else {
591
592 }
593 } else if (arg1 > 0) {
594
595 env->CP0_VPEControl &= ~(0x7 << CP0VPECo_EXCPT);
596 env->CP0_VPEControl |= 2 << CP0VPECo_EXCPT;
597 do_raise_exception(env, EXCP_THREAD, GETPC());
598 }
599 return env->CP0_YQMask;
600}
601
602#ifndef CONFIG_USER_ONLY
603
604static void r4k_mips_tlb_flush_extra(CPUMIPSState *env, int first)
605{
606
607 while (env->tlb->tlb_in_use > first) {
608 r4k_invalidate_tlb(env, --env->tlb->tlb_in_use, 0);
609 }
610}
611
612static inline uint64_t get_tlb_pfn_from_entrylo(uint64_t entrylo)
613{
614#if defined(TARGET_MIPS64)
615 return extract64(entrylo, 6, 54);
616#else
617 return extract64(entrylo, 6, 24) |
618 (extract64(entrylo, 32, 32) << 24);
619#endif
620}
621
622static void r4k_fill_tlb(CPUMIPSState *env, int idx)
623{
624 r4k_tlb_t *tlb;
625 uint64_t mask = env->CP0_PageMask >> (TARGET_PAGE_BITS + 1);
626
627
628 tlb = &env->tlb->mmu.r4k.tlb[idx];
629 if (env->CP0_EntryHi & (1 << CP0EnHi_EHINV)) {
630 tlb->EHINV = 1;
631 return;
632 }
633 tlb->EHINV = 0;
634 tlb->VPN = env->CP0_EntryHi & (TARGET_PAGE_MASK << 1);
635#if defined(TARGET_MIPS64)
636 tlb->VPN &= env->SEGMask;
637#endif
638 tlb->ASID = env->CP0_EntryHi & env->CP0_EntryHi_ASID_mask;
639 tlb->MMID = env->CP0_MemoryMapID;
640 tlb->PageMask = env->CP0_PageMask;
641 tlb->G = env->CP0_EntryLo0 & env->CP0_EntryLo1 & 1;
642 tlb->V0 = (env->CP0_EntryLo0 & 2) != 0;
643 tlb->D0 = (env->CP0_EntryLo0 & 4) != 0;
644 tlb->C0 = (env->CP0_EntryLo0 >> 3) & 0x7;
645 tlb->XI0 = (env->CP0_EntryLo0 >> CP0EnLo_XI) & 1;
646 tlb->RI0 = (env->CP0_EntryLo0 >> CP0EnLo_RI) & 1;
647 tlb->PFN[0] = (get_tlb_pfn_from_entrylo(env->CP0_EntryLo0) & ~mask) << 12;
648 tlb->V1 = (env->CP0_EntryLo1 & 2) != 0;
649 tlb->D1 = (env->CP0_EntryLo1 & 4) != 0;
650 tlb->C1 = (env->CP0_EntryLo1 >> 3) & 0x7;
651 tlb->XI1 = (env->CP0_EntryLo1 >> CP0EnLo_XI) & 1;
652 tlb->RI1 = (env->CP0_EntryLo1 >> CP0EnLo_RI) & 1;
653 tlb->PFN[1] = (get_tlb_pfn_from_entrylo(env->CP0_EntryLo1) & ~mask) << 12;
654}
655
656void r4k_helper_tlbinv(CPUMIPSState *env)
657{
658 bool mi = !!((env->CP0_Config5 >> CP0C5_MI) & 1);
659 uint16_t ASID = env->CP0_EntryHi & env->CP0_EntryHi_ASID_mask;
660 uint32_t MMID = env->CP0_MemoryMapID;
661 uint32_t tlb_mmid;
662 r4k_tlb_t *tlb;
663 int idx;
664
665 MMID = mi ? MMID : (uint32_t) ASID;
666 for (idx = 0; idx < env->tlb->nb_tlb; idx++) {
667 tlb = &env->tlb->mmu.r4k.tlb[idx];
668 tlb_mmid = mi ? tlb->MMID : (uint32_t) tlb->ASID;
669 if (!tlb->G && tlb_mmid == MMID) {
670 tlb->EHINV = 1;
671 }
672 }
673 cpu_mips_tlb_flush(env);
674}
675
676void r4k_helper_tlbinvf(CPUMIPSState *env)
677{
678 int idx;
679
680 for (idx = 0; idx < env->tlb->nb_tlb; idx++) {
681 env->tlb->mmu.r4k.tlb[idx].EHINV = 1;
682 }
683 cpu_mips_tlb_flush(env);
684}
685
686void r4k_helper_tlbwi(CPUMIPSState *env)
687{
688 bool mi = !!((env->CP0_Config5 >> CP0C5_MI) & 1);
689 target_ulong VPN;
690 uint16_t ASID = env->CP0_EntryHi & env->CP0_EntryHi_ASID_mask;
691 uint32_t MMID = env->CP0_MemoryMapID;
692 uint32_t tlb_mmid;
693 bool EHINV, G, V0, D0, V1, D1, XI0, XI1, RI0, RI1;
694 r4k_tlb_t *tlb;
695 int idx;
696
697 MMID = mi ? MMID : (uint32_t) ASID;
698
699 idx = (env->CP0_Index & ~0x80000000) % env->tlb->nb_tlb;
700 tlb = &env->tlb->mmu.r4k.tlb[idx];
701 VPN = env->CP0_EntryHi & (TARGET_PAGE_MASK << 1);
702#if defined(TARGET_MIPS64)
703 VPN &= env->SEGMask;
704#endif
705 EHINV = (env->CP0_EntryHi & (1 << CP0EnHi_EHINV)) != 0;
706 G = env->CP0_EntryLo0 & env->CP0_EntryLo1 & 1;
707 V0 = (env->CP0_EntryLo0 & 2) != 0;
708 D0 = (env->CP0_EntryLo0 & 4) != 0;
709 XI0 = (env->CP0_EntryLo0 >> CP0EnLo_XI) &1;
710 RI0 = (env->CP0_EntryLo0 >> CP0EnLo_RI) &1;
711 V1 = (env->CP0_EntryLo1 & 2) != 0;
712 D1 = (env->CP0_EntryLo1 & 4) != 0;
713 XI1 = (env->CP0_EntryLo1 >> CP0EnLo_XI) &1;
714 RI1 = (env->CP0_EntryLo1 >> CP0EnLo_RI) &1;
715
716 tlb_mmid = mi ? tlb->MMID : (uint32_t) tlb->ASID;
717
718
719
720
721 if (tlb->VPN != VPN || tlb_mmid != MMID || tlb->G != G ||
722 (!tlb->EHINV && EHINV) ||
723 (tlb->V0 && !V0) || (tlb->D0 && !D0) ||
724 (!tlb->XI0 && XI0) || (!tlb->RI0 && RI0) ||
725 (tlb->V1 && !V1) || (tlb->D1 && !D1) ||
726 (!tlb->XI1 && XI1) || (!tlb->RI1 && RI1)) {
727 r4k_mips_tlb_flush_extra(env, env->tlb->nb_tlb);
728 }
729
730 r4k_invalidate_tlb(env, idx, 0);
731 r4k_fill_tlb(env, idx);
732}
733
734void r4k_helper_tlbwr(CPUMIPSState *env)
735{
736 int r = cpu_mips_get_random(env);
737
738 r4k_invalidate_tlb(env, r, 1);
739 r4k_fill_tlb(env, r);
740}
741
742void r4k_helper_tlbp(CPUMIPSState *env)
743{
744 bool mi = !!((env->CP0_Config5 >> CP0C5_MI) & 1);
745 r4k_tlb_t *tlb;
746 target_ulong mask;
747 target_ulong tag;
748 target_ulong VPN;
749 uint16_t ASID = env->CP0_EntryHi & env->CP0_EntryHi_ASID_mask;
750 uint32_t MMID = env->CP0_MemoryMapID;
751 uint32_t tlb_mmid;
752 int i;
753
754 MMID = mi ? MMID : (uint32_t) ASID;
755 for (i = 0; i < env->tlb->nb_tlb; i++) {
756 tlb = &env->tlb->mmu.r4k.tlb[i];
757
758 mask = tlb->PageMask | ~(TARGET_PAGE_MASK << 1);
759 tag = env->CP0_EntryHi & ~mask;
760 VPN = tlb->VPN & ~mask;
761#if defined(TARGET_MIPS64)
762 tag &= env->SEGMask;
763#endif
764 tlb_mmid = mi ? tlb->MMID : (uint32_t) tlb->ASID;
765
766 if ((tlb->G == 1 || tlb_mmid == MMID) && VPN == tag && !tlb->EHINV) {
767
768 env->CP0_Index = i;
769 break;
770 }
771 }
772 if (i == env->tlb->nb_tlb) {
773
774 for (i = env->tlb->nb_tlb; i < env->tlb->tlb_in_use; i++) {
775 tlb = &env->tlb->mmu.r4k.tlb[i];
776
777 mask = tlb->PageMask | ~(TARGET_PAGE_MASK << 1);
778 tag = env->CP0_EntryHi & ~mask;
779 VPN = tlb->VPN & ~mask;
780#if defined(TARGET_MIPS64)
781 tag &= env->SEGMask;
782#endif
783 tlb_mmid = mi ? tlb->MMID : (uint32_t) tlb->ASID;
784
785 if ((tlb->G == 1 || tlb_mmid == MMID) && VPN == tag) {
786 r4k_mips_tlb_flush_extra(env, i);
787 break;
788 }
789 }
790
791 env->CP0_Index |= 0x80000000;
792 }
793}
794
795static inline uint64_t get_entrylo_pfn_from_tlb(uint64_t tlb_pfn)
796{
797#if defined(TARGET_MIPS64)
798 return tlb_pfn << 6;
799#else
800 return (extract64(tlb_pfn, 0, 24) << 6) |
801 (extract64(tlb_pfn, 24, 32) << 32);
802#endif
803}
804
805void r4k_helper_tlbr(CPUMIPSState *env)
806{
807 bool mi = !!((env->CP0_Config5 >> CP0C5_MI) & 1);
808 uint16_t ASID = env->CP0_EntryHi & env->CP0_EntryHi_ASID_mask;
809 uint32_t MMID = env->CP0_MemoryMapID;
810 uint32_t tlb_mmid;
811 r4k_tlb_t *tlb;
812 int idx;
813
814 MMID = mi ? MMID : (uint32_t) ASID;
815 idx = (env->CP0_Index & ~0x80000000) % env->tlb->nb_tlb;
816 tlb = &env->tlb->mmu.r4k.tlb[idx];
817
818 tlb_mmid = mi ? tlb->MMID : (uint32_t) tlb->ASID;
819
820 if (MMID != tlb_mmid) {
821 cpu_mips_tlb_flush(env);
822 }
823
824 r4k_mips_tlb_flush_extra(env, env->tlb->nb_tlb);
825
826 if (tlb->EHINV) {
827 env->CP0_EntryHi = 1 << CP0EnHi_EHINV;
828 env->CP0_PageMask = 0;
829 env->CP0_EntryLo0 = 0;
830 env->CP0_EntryLo1 = 0;
831 } else {
832 env->CP0_EntryHi = mi ? tlb->VPN : tlb->VPN | tlb->ASID;
833 env->CP0_MemoryMapID = tlb->MMID;
834 env->CP0_PageMask = tlb->PageMask;
835 env->CP0_EntryLo0 = tlb->G | (tlb->V0 << 1) | (tlb->D0 << 2) |
836 ((uint64_t)tlb->RI0 << CP0EnLo_RI) |
837 ((uint64_t)tlb->XI0 << CP0EnLo_XI) | (tlb->C0 << 3) |
838 get_entrylo_pfn_from_tlb(tlb->PFN[0] >> 12);
839 env->CP0_EntryLo1 = tlb->G | (tlb->V1 << 1) | (tlb->D1 << 2) |
840 ((uint64_t)tlb->RI1 << CP0EnLo_RI) |
841 ((uint64_t)tlb->XI1 << CP0EnLo_XI) | (tlb->C1 << 3) |
842 get_entrylo_pfn_from_tlb(tlb->PFN[1] >> 12);
843 }
844}
845
846void helper_tlbwi(CPUMIPSState *env)
847{
848 env->tlb->helper_tlbwi(env);
849}
850
851void helper_tlbwr(CPUMIPSState *env)
852{
853 env->tlb->helper_tlbwr(env);
854}
855
856void helper_tlbp(CPUMIPSState *env)
857{
858 env->tlb->helper_tlbp(env);
859}
860
861void helper_tlbr(CPUMIPSState *env)
862{
863 env->tlb->helper_tlbr(env);
864}
865
866void helper_tlbinv(CPUMIPSState *env)
867{
868 env->tlb->helper_tlbinv(env);
869}
870
871void helper_tlbinvf(CPUMIPSState *env)
872{
873 env->tlb->helper_tlbinvf(env);
874}
875
876static void global_invalidate_tlb(CPUMIPSState *env,
877 uint32_t invMsgVPN2,
878 uint8_t invMsgR,
879 uint32_t invMsgMMid,
880 bool invAll,
881 bool invVAMMid,
882 bool invMMid,
883 bool invVA)
884{
885
886 int idx;
887 r4k_tlb_t *tlb;
888 bool VAMatch;
889 bool MMidMatch;
890
891 for (idx = 0; idx < env->tlb->nb_tlb; idx++) {
892 tlb = &env->tlb->mmu.r4k.tlb[idx];
893 VAMatch =
894 (((tlb->VPN & ~tlb->PageMask) == (invMsgVPN2 & ~tlb->PageMask))
895#ifdef TARGET_MIPS64
896 &&
897 (extract64(env->CP0_EntryHi, 62, 2) == invMsgR)
898#endif
899 );
900 MMidMatch = tlb->MMID == invMsgMMid;
901 if ((invAll && (idx > env->CP0_Wired)) ||
902 (VAMatch && invVAMMid && (tlb->G || MMidMatch)) ||
903 (VAMatch && invVA) ||
904 (MMidMatch && !(tlb->G) && invMMid)) {
905 tlb->EHINV = 1;
906 }
907 }
908 cpu_mips_tlb_flush(env);
909}
910
911void helper_ginvt(CPUMIPSState *env, target_ulong arg, uint32_t type)
912{
913 bool invAll = type == 0;
914 bool invVA = type == 1;
915 bool invMMid = type == 2;
916 bool invVAMMid = type == 3;
917 uint32_t invMsgVPN2 = arg & (TARGET_PAGE_MASK << 1);
918 uint8_t invMsgR = 0;
919 uint32_t invMsgMMid = env->CP0_MemoryMapID;
920 CPUState *other_cs = first_cpu;
921
922#ifdef TARGET_MIPS64
923 invMsgR = extract64(arg, 62, 2);
924#endif
925
926 CPU_FOREACH(other_cs) {
927 MIPSCPU *other_cpu = MIPS_CPU(other_cs);
928 global_invalidate_tlb(&other_cpu->env, invMsgVPN2, invMsgR, invMsgMMid,
929 invAll, invVAMMid, invMMid, invVA);
930 }
931}
932
933
934target_ulong helper_di(CPUMIPSState *env)
935{
936 target_ulong t0 = env->CP0_Status;
937
938 env->CP0_Status = t0 & ~(1 << CP0St_IE);
939 return t0;
940}
941
942target_ulong helper_ei(CPUMIPSState *env)
943{
944 target_ulong t0 = env->CP0_Status;
945
946 env->CP0_Status = t0 | (1 << CP0St_IE);
947 return t0;
948}
949
950static void debug_pre_eret(CPUMIPSState *env)
951{
952 if (qemu_loglevel_mask(CPU_LOG_EXEC)) {
953 qemu_log("ERET: PC " TARGET_FMT_lx " EPC " TARGET_FMT_lx,
954 env->active_tc.PC, env->CP0_EPC);
955 if (env->CP0_Status & (1 << CP0St_ERL)) {
956 qemu_log(" ErrorEPC " TARGET_FMT_lx, env->CP0_ErrorEPC);
957 }
958 if (env->hflags & MIPS_HFLAG_DM) {
959 qemu_log(" DEPC " TARGET_FMT_lx, env->CP0_DEPC);
960 }
961 qemu_log("\n");
962 }
963}
964
965static void debug_post_eret(CPUMIPSState *env)
966{
967 if (qemu_loglevel_mask(CPU_LOG_EXEC)) {
968 qemu_log(" => PC " TARGET_FMT_lx " EPC " TARGET_FMT_lx,
969 env->active_tc.PC, env->CP0_EPC);
970 if (env->CP0_Status & (1 << CP0St_ERL)) {
971 qemu_log(" ErrorEPC " TARGET_FMT_lx, env->CP0_ErrorEPC);
972 }
973 if (env->hflags & MIPS_HFLAG_DM) {
974 qemu_log(" DEPC " TARGET_FMT_lx, env->CP0_DEPC);
975 }
976 switch (cpu_mmu_index(env, false)) {
977 case 3:
978 qemu_log(", ERL\n");
979 break;
980 case MIPS_HFLAG_UM:
981 qemu_log(", UM\n");
982 break;
983 case MIPS_HFLAG_SM:
984 qemu_log(", SM\n");
985 break;
986 case MIPS_HFLAG_KM:
987 qemu_log("\n");
988 break;
989 default:
990 cpu_abort(env_cpu(env), "Invalid MMU mode!\n");
991 break;
992 }
993 }
994}
995
996static void set_pc(CPUMIPSState *env, target_ulong error_pc)
997{
998 env->active_tc.PC = error_pc & ~(target_ulong)1;
999 if (error_pc & 1) {
1000 env->hflags |= MIPS_HFLAG_M16;
1001 } else {
1002 env->hflags &= ~(MIPS_HFLAG_M16);
1003 }
1004}
1005
1006static inline void exception_return(CPUMIPSState *env)
1007{
1008 debug_pre_eret(env);
1009 if (env->CP0_Status & (1 << CP0St_ERL)) {
1010 set_pc(env, env->CP0_ErrorEPC);
1011 env->CP0_Status &= ~(1 << CP0St_ERL);
1012 } else {
1013 set_pc(env, env->CP0_EPC);
1014 env->CP0_Status &= ~(1 << CP0St_EXL);
1015 }
1016 compute_hflags(env);
1017 debug_post_eret(env);
1018}
1019
1020void helper_eret(CPUMIPSState *env)
1021{
1022 exception_return(env);
1023 env->CP0_LLAddr = 1;
1024 env->lladdr = 1;
1025}
1026
1027void helper_eretnc(CPUMIPSState *env)
1028{
1029 exception_return(env);
1030}
1031
1032void helper_deret(CPUMIPSState *env)
1033{
1034 debug_pre_eret(env);
1035
1036 env->hflags &= ~MIPS_HFLAG_DM;
1037 compute_hflags(env);
1038
1039 set_pc(env, env->CP0_DEPC);
1040
1041 debug_post_eret(env);
1042}
1043#endif
1044
1045static inline void check_hwrena(CPUMIPSState *env, int reg, uintptr_t pc)
1046{
1047 if ((env->hflags & MIPS_HFLAG_CP0) || (env->CP0_HWREna & (1 << reg))) {
1048 return;
1049 }
1050 do_raise_exception(env, EXCP_RI, pc);
1051}
1052
1053target_ulong helper_rdhwr_cpunum(CPUMIPSState *env)
1054{
1055 check_hwrena(env, 0, GETPC());
1056 return env->CP0_EBase & 0x3ff;
1057}
1058
1059target_ulong helper_rdhwr_synci_step(CPUMIPSState *env)
1060{
1061 check_hwrena(env, 1, GETPC());
1062 return env->SYNCI_Step;
1063}
1064
1065target_ulong helper_rdhwr_cc(CPUMIPSState *env)
1066{
1067 check_hwrena(env, 2, GETPC());
1068#ifdef CONFIG_USER_ONLY
1069 return env->CP0_Count;
1070#else
1071 return (int32_t)cpu_mips_get_count(env);
1072#endif
1073}
1074
1075target_ulong helper_rdhwr_ccres(CPUMIPSState *env)
1076{
1077 check_hwrena(env, 3, GETPC());
1078 return env->CCRes;
1079}
1080
1081target_ulong helper_rdhwr_performance(CPUMIPSState *env)
1082{
1083 check_hwrena(env, 4, GETPC());
1084 return env->CP0_Performance0;
1085}
1086
1087target_ulong helper_rdhwr_xnp(CPUMIPSState *env)
1088{
1089 check_hwrena(env, 5, GETPC());
1090 return (env->CP0_Config5 >> CP0C5_XNP) & 1;
1091}
1092
1093void helper_pmon(CPUMIPSState *env, int function)
1094{
1095 function /= 2;
1096 switch (function) {
1097 case 2:
1098 if (env->active_tc.gpr[4] == 0) {
1099 env->active_tc.gpr[2] = -1;
1100 }
1101
1102 case 11:
1103 env->active_tc.gpr[2] = -1;
1104 break;
1105 case 3:
1106 case 12:
1107 printf("%c", (char)(env->active_tc.gpr[4] & 0xFF));
1108 break;
1109 case 17:
1110 break;
1111 case 158:
1112 {
1113 unsigned char *fmt = (void *)(uintptr_t)env->active_tc.gpr[4];
1114 printf("%s", fmt);
1115 }
1116 break;
1117 }
1118}
1119
1120void helper_wait(CPUMIPSState *env)
1121{
1122 CPUState *cs = env_cpu(env);
1123
1124 cs->halted = 1;
1125 cpu_reset_interrupt(cs, CPU_INTERRUPT_WAKE);
1126
1127
1128
1129
1130 raise_exception(env, EXCP_HLT);
1131}
1132
1133#if !defined(CONFIG_USER_ONLY)
1134
1135void mips_cpu_do_unaligned_access(CPUState *cs, vaddr addr,
1136 MMUAccessType access_type,
1137 int mmu_idx, uintptr_t retaddr)
1138{
1139 MIPSCPU *cpu = MIPS_CPU(cs);
1140 CPUMIPSState *env = &cpu->env;
1141 int error_code = 0;
1142 int excp;
1143
1144 if (!(env->hflags & MIPS_HFLAG_DM)) {
1145 env->CP0_BadVAddr = addr;
1146 }
1147
1148 if (access_type == MMU_DATA_STORE) {
1149 excp = EXCP_AdES;
1150 } else {
1151 excp = EXCP_AdEL;
1152 if (access_type == MMU_INST_FETCH) {
1153 error_code |= EXCP_INST_NOTAVAIL;
1154 }
1155 }
1156
1157 do_raise_exception_err(env, excp, error_code, retaddr);
1158}
1159
1160void mips_cpu_do_transaction_failed(CPUState *cs, hwaddr physaddr,
1161 vaddr addr, unsigned size,
1162 MMUAccessType access_type,
1163 int mmu_idx, MemTxAttrs attrs,
1164 MemTxResult response, uintptr_t retaddr)
1165{
1166 MIPSCPU *cpu = MIPS_CPU(cs);
1167 CPUMIPSState *env = &cpu->env;
1168
1169 if (access_type == MMU_INST_FETCH) {
1170 do_raise_exception(env, EXCP_IBE, retaddr);
1171 } else {
1172 do_raise_exception(env, EXCP_DBE, retaddr);
1173 }
1174}
1175#endif
1176
1177void helper_cache(CPUMIPSState *env, target_ulong addr, uint32_t op)
1178{
1179#ifndef CONFIG_USER_ONLY
1180 static const char *const type_name[] = {
1181 "Primary Instruction",
1182 "Primary Data or Unified Primary",
1183 "Tertiary",
1184 "Secondary"
1185 };
1186 uint32_t cache_type = extract32(op, 0, 2);
1187 uint32_t cache_operation = extract32(op, 2, 3);
1188 target_ulong index = addr & 0x1fffffff;
1189
1190 switch (cache_operation) {
1191 case 0b010:
1192 memory_region_dispatch_write(env->itc_tag, index, env->CP0_TagLo,
1193 MO_64, MEMTXATTRS_UNSPECIFIED);
1194 break;
1195 case 0b001:
1196 memory_region_dispatch_read(env->itc_tag, index, &env->CP0_TagLo,
1197 MO_64, MEMTXATTRS_UNSPECIFIED);
1198 break;
1199 case 0b000:
1200 case 0b100:
1201 case 0b110:
1202
1203 break;
1204 default:
1205 qemu_log_mask(LOG_UNIMP, "cache operation:%u (type: %s cache)\n",
1206 cache_operation, type_name[cache_type]);
1207 break;
1208 }
1209#endif
1210}
1211