?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vmdk: fix double free
[qemu.git] / target-sparc / op_helper.c
blobeb4f5a4338035277888f3a23c388c7676c1dab7c
1 #include "exec.h"
2 #include "host-utils.h"
3 #include "helper.h"
4 #if !defined(CONFIG_USER_ONLY)
5 #include "softmmu_exec.h"
6 #endif /* !defined(CONFIG_USER_ONLY) */
7
8 //#define DEBUG_MMU
9 //#define DEBUG_MXCC
10 //#define DEBUG_UNALIGNED
11 //#define DEBUG_UNASSIGNED
12 //#define DEBUG_ASI
13 //#define DEBUG_PCALL
14 //#define DEBUG_PSTATE
15
16 #ifdef DEBUG_MMU
17 #define DPRINTF_MMU(fmt, ...) \
18 do { printf("MMU: " fmt , ## __VA_ARGS__); } while (0)
19 #else
20 #define DPRINTF_MMU(fmt, ...) do {} while (0)
21 #endif
22
23 #ifdef DEBUG_MXCC
24 #define DPRINTF_MXCC(fmt, ...) \
25 do { printf("MXCC: " fmt , ## __VA_ARGS__); } while (0)
26 #else
27 #define DPRINTF_MXCC(fmt, ...) do {} while (0)
28 #endif
29
30 #ifdef DEBUG_ASI
31 #define DPRINTF_ASI(fmt, ...) \
32 do { printf("ASI: " fmt , ## __VA_ARGS__); } while (0)
33 #endif
34
35 #ifdef DEBUG_PSTATE
36 #define DPRINTF_PSTATE(fmt, ...) \
37 do { printf("PSTATE: " fmt , ## __VA_ARGS__); } while (0)
38 #else
39 #define DPRINTF_PSTATE(fmt, ...) do {} while (0)
40 #endif
41
42 #ifdef TARGET_SPARC64
43 #ifndef TARGET_ABI32
44 #define AM_CHECK(env1) ((env1)->pstate & PS_AM)
45 #else
46 #define AM_CHECK(env1) (1)
47 #endif
48 #endif
49
50 #if defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY)
51 // Calculates TSB pointer value for fault page size 8k or 64k
52 static uint64_t ultrasparc_tsb_pointer(uint64_t tsb_register,
53 uint64_t tag_access_register,
54 int page_size)
55 {
56 uint64_t tsb_base = tsb_register & ~0x1fffULL;
57 int tsb_split = (tsb_register & 0x1000ULL) ? 1 : 0;
58 int tsb_size = tsb_register & 0xf;
59
60 // discard lower 13 bits which hold tag access context
61 uint64_t tag_access_va = tag_access_register & ~0x1fffULL;
62
63 // now reorder bits
64 uint64_t tsb_base_mask = ~0x1fffULL;
65 uint64_t va = tag_access_va;
66
67 // move va bits to correct position
68 if (page_size == 8*1024) {
69 va >>= 9;
70 } else if (page_size == 64*1024) {
71 va >>= 12;
72 }
73
74 if (tsb_size) {
75 tsb_base_mask <<= tsb_size;
76 }
77
78 // calculate tsb_base mask and adjust va if split is in use
79 if (tsb_split) {
80 if (page_size == 8*1024) {
81 va &= ~(1ULL << (13 + tsb_size));
82 } else if (page_size == 64*1024) {
83 va |= (1ULL << (13 + tsb_size));
84 }
85 tsb_base_mask <<= 1;
86 }
87
88 return ((tsb_base & tsb_base_mask) | (va & ~tsb_base_mask)) & ~0xfULL;
89 }
90
91 // Calculates tag target register value by reordering bits
92 // in tag access register
93 static uint64_t ultrasparc_tag_target(uint64_t tag_access_register)
94 {
95 return ((tag_access_register & 0x1fff) << 48) | (tag_access_register >> 22);
96 }
97
98 static void replace_tlb_entry(SparcTLBEntry *tlb,
99 uint64_t tlb_tag, uint64_t tlb_tte,
100 CPUState *env1)
101 {
102 target_ulong mask, size, va, offset;
103
104 // flush page range if translation is valid
105 if (TTE_IS_VALID(tlb->tte)) {
106
107 mask = 0xffffffffffffe000ULL;
108 mask <<= 3 * ((tlb->tte >> 61) & 3);
109 size = ~mask + 1;
110
111 va = tlb->tag & mask;
112
113 for (offset = 0; offset < size; offset += TARGET_PAGE_SIZE) {
114 tlb_flush_page(env1, va + offset);
115 }
116 }
117
118 tlb->tag = tlb_tag;
119 tlb->tte = tlb_tte;
120 }
121
122 static void demap_tlb(SparcTLBEntry *tlb, target_ulong demap_addr,
123 const char* strmmu, CPUState *env1)
124 {
125 unsigned int i;
126 target_ulong mask;
127
128 for (i = 0; i < 64; i++) {
129 if (TTE_IS_VALID(tlb[i].tte)) {
130
131 mask = 0xffffffffffffe000ULL;
132 mask <<= 3 * ((tlb[i].tte >> 61) & 3);
133
134 if ((demap_addr & mask) == (tlb[i].tag & mask)) {
135 replace_tlb_entry(&tlb[i], 0, 0, env1);
136 #ifdef DEBUG_MMU
137 DPRINTF_MMU("%s demap invalidated entry [%02u]\n", strmmu, i);
138 dump_mmu(env1);
139 #endif
140 }
141 //return;
142 }
143 }
144
145 }
146
147 static void replace_tlb_1bit_lru(SparcTLBEntry *tlb,
148 uint64_t tlb_tag, uint64_t tlb_tte,
149 const char* strmmu, CPUState *env1)
150 {
151 unsigned int i, replace_used;
152
153 // Try replacing invalid entry
154 for (i = 0; i < 64; i++) {
155 if (!TTE_IS_VALID(tlb[i].tte)) {
156 replace_tlb_entry(&tlb[i], tlb_tag, tlb_tte, env1);
157 #ifdef DEBUG_MMU
158 DPRINTF_MMU("%s lru replaced invalid entry [%i]\n", strmmu, i);
159 dump_mmu(env1);
160 #endif
161 return;
162 }
163 }
164
165 // All entries are valid, try replacing unlocked entry
166
167 for (replace_used = 0; replace_used < 2; ++replace_used) {
168
169 // Used entries are not replaced on first pass
170
171 for (i = 0; i < 64; i++) {
172 if (!TTE_IS_LOCKED(tlb[i].tte) && !TTE_IS_USED(tlb[i].tte)) {
173
174 replace_tlb_entry(&tlb[i], tlb_tag, tlb_tte, env1);
175 #ifdef DEBUG_MMU
176 DPRINTF_MMU("%s lru replaced unlocked %s entry [%i]\n",
177 strmmu, (replace_used?"used":"unused"), i);
178 dump_mmu(env1);
179 #endif
180 return;
181 }
182 }
183
184 // Now reset used bit and search for unused entries again
185
186 for (i = 0; i < 64; i++) {
187 TTE_SET_UNUSED(tlb[i].tte);
188 }
189 }
190
191 #ifdef DEBUG_MMU
192 DPRINTF_MMU("%s lru replacement failed: no entries available\n", strmmu);
193 #endif
194 // error state?
195 }
196
197 #endif
198
199 static inline void address_mask(CPUState *env1, target_ulong *addr)
200 {
201 #ifdef TARGET_SPARC64
202 if (AM_CHECK(env1))
203 *addr &= 0xffffffffULL;
204 #endif
205 }
206
207 static void raise_exception(int tt)
208 {
209 env->exception_index = tt;
210 cpu_loop_exit();
211 }
212
213 void HELPER(raise_exception)(int tt)
214 {
215 raise_exception(tt);
216 }
217
218 static inline void set_cwp(int new_cwp)
219 {
220 cpu_set_cwp(env, new_cwp);
221 }
222
223 void helper_check_align(target_ulong addr, uint32_t align)
224 {
225 if (addr & align) {
226 #ifdef DEBUG_UNALIGNED
227 printf("Unaligned access to 0x" TARGET_FMT_lx " from 0x" TARGET_FMT_lx
228 "\n", addr, env->pc);
229 #endif
230 raise_exception(TT_UNALIGNED);
231 }
232 }
233
234 #define F_HELPER(name, p) void helper_f##name##p(void)
235
236 #define F_BINOP(name) \
237 float32 helper_f ## name ## s (float32 src1, float32 src2) \
238 { \
239 return float32_ ## name (src1, src2, &env->fp_status); \
240 } \
241 F_HELPER(name, d) \
242 { \
243 DT0 = float64_ ## name (DT0, DT1, &env->fp_status); \
244 } \
245 F_HELPER(name, q) \
246 { \
247 QT0 = float128_ ## name (QT0, QT1, &env->fp_status); \
248 }
249
250 F_BINOP(add);
251 F_BINOP(sub);
252 F_BINOP(mul);
253 F_BINOP(div);
254 #undef F_BINOP
255
256 void helper_fsmuld(float32 src1, float32 src2)
257 {
258 DT0 = float64_mul(float32_to_float64(src1, &env->fp_status),
259 float32_to_float64(src2, &env->fp_status),
260 &env->fp_status);
261 }
262
263 void helper_fdmulq(void)
264 {
265 QT0 = float128_mul(float64_to_float128(DT0, &env->fp_status),
266 float64_to_float128(DT1, &env->fp_status),
267 &env->fp_status);
268 }
269
270 float32 helper_fnegs(float32 src)
271 {
272 return float32_chs(src);
273 }
274
275 #ifdef TARGET_SPARC64
276 F_HELPER(neg, d)
277 {
278 DT0 = float64_chs(DT1);
279 }
280
281 F_HELPER(neg, q)
282 {
283 QT0 = float128_chs(QT1);
284 }
285 #endif
286
287 /* Integer to float conversion. */
288 float32 helper_fitos(int32_t src)
289 {
290 return int32_to_float32(src, &env->fp_status);
291 }
292
293 void helper_fitod(int32_t src)
294 {
295 DT0 = int32_to_float64(src, &env->fp_status);
296 }
297
298 void helper_fitoq(int32_t src)
299 {
300 QT0 = int32_to_float128(src, &env->fp_status);
301 }
302
303 #ifdef TARGET_SPARC64
304 float32 helper_fxtos(void)
305 {
306 return int64_to_float32(*((int64_t *)&DT1), &env->fp_status);
307 }
308
309 F_HELPER(xto, d)
310 {
311 DT0 = int64_to_float64(*((int64_t *)&DT1), &env->fp_status);
312 }
313
314 F_HELPER(xto, q)
315 {
316 QT0 = int64_to_float128(*((int64_t *)&DT1), &env->fp_status);
317 }
318 #endif
319 #undef F_HELPER
320
321 /* floating point conversion */
322 float32 helper_fdtos(void)
323 {
324 return float64_to_float32(DT1, &env->fp_status);
325 }
326
327 void helper_fstod(float32 src)
328 {
329 DT0 = float32_to_float64(src, &env->fp_status);
330 }
331
332 float32 helper_fqtos(void)
333 {
334 return float128_to_float32(QT1, &env->fp_status);
335 }
336
337 void helper_fstoq(float32 src)
338 {
339 QT0 = float32_to_float128(src, &env->fp_status);
340 }
341
342 void helper_fqtod(void)
343 {
344 DT0 = float128_to_float64(QT1, &env->fp_status);
345 }
346
347 void helper_fdtoq(void)
348 {
349 QT0 = float64_to_float128(DT1, &env->fp_status);
350 }
351
352 /* Float to integer conversion. */
353 int32_t helper_fstoi(float32 src)
354 {
355 return float32_to_int32_round_to_zero(src, &env->fp_status);
356 }
357
358 int32_t helper_fdtoi(void)
359 {
360 return float64_to_int32_round_to_zero(DT1, &env->fp_status);
361 }
362
363 int32_t helper_fqtoi(void)
364 {
365 return float128_to_int32_round_to_zero(QT1, &env->fp_status);
366 }
367
368 #ifdef TARGET_SPARC64
369 void helper_fstox(float32 src)
370 {
371 *((int64_t *)&DT0) = float32_to_int64_round_to_zero(src, &env->fp_status);
372 }
373
374 void helper_fdtox(void)
375 {
376 *((int64_t *)&DT0) = float64_to_int64_round_to_zero(DT1, &env->fp_status);
377 }
378
379 void helper_fqtox(void)
380 {
381 *((int64_t *)&DT0) = float128_to_int64_round_to_zero(QT1, &env->fp_status);
382 }
383
384 void helper_faligndata(void)
385 {
386 uint64_t tmp;
387
388 tmp = (*((uint64_t *)&DT0)) << ((env->gsr & 7) * 8);
389 /* on many architectures a shift of 64 does nothing */
390 if ((env->gsr & 7) != 0) {
391 tmp |= (*((uint64_t *)&DT1)) >> (64 - (env->gsr & 7) * 8);
392 }
393 *((uint64_t *)&DT0) = tmp;
394 }
395
396 #ifdef HOST_WORDS_BIGENDIAN
397 #define VIS_B64(n) b[7 - (n)]
398 #define VIS_W64(n) w[3 - (n)]
399 #define VIS_SW64(n) sw[3 - (n)]
400 #define VIS_L64(n) l[1 - (n)]
401 #define VIS_B32(n) b[3 - (n)]
402 #define VIS_W32(n) w[1 - (n)]
403 #else
404 #define VIS_B64(n) b[n]
405 #define VIS_W64(n) w[n]
406 #define VIS_SW64(n) sw[n]
407 #define VIS_L64(n) l[n]
408 #define VIS_B32(n) b[n]
409 #define VIS_W32(n) w[n]
410 #endif
411
412 typedef union {
413 uint8_t b[8];
414 uint16_t w[4];
415 int16_t sw[4];
416 uint32_t l[2];
417 float64 d;
418 } vis64;
419
420 typedef union {
421 uint8_t b[4];
422 uint16_t w[2];
423 uint32_t l;
424 float32 f;
425 } vis32;
426
427 void helper_fpmerge(void)
428 {
429 vis64 s, d;
430
431 s.d = DT0;
432 d.d = DT1;
433
434 // Reverse calculation order to handle overlap
435 d.VIS_B64(7) = s.VIS_B64(3);
436 d.VIS_B64(6) = d.VIS_B64(3);
437 d.VIS_B64(5) = s.VIS_B64(2);
438 d.VIS_B64(4) = d.VIS_B64(2);
439 d.VIS_B64(3) = s.VIS_B64(1);
440 d.VIS_B64(2) = d.VIS_B64(1);
441 d.VIS_B64(1) = s.VIS_B64(0);
442 //d.VIS_B64(0) = d.VIS_B64(0);
443
444 DT0 = d.d;
445 }
446
447 void helper_fmul8x16(void)
448 {
449 vis64 s, d;
450 uint32_t tmp;
451
452 s.d = DT0;
453 d.d = DT1;
454
455 #define PMUL(r) \
456 tmp = (int32_t)d.VIS_SW64(r) * (int32_t)s.VIS_B64(r); \
457 if ((tmp & 0xff) > 0x7f) \
458 tmp += 0x100; \
459 d.VIS_W64(r) = tmp >> 8;
460
461 PMUL(0);
462 PMUL(1);
463 PMUL(2);
464 PMUL(3);
465 #undef PMUL
466
467 DT0 = d.d;
468 }
469
470 void helper_fmul8x16al(void)
471 {
472 vis64 s, d;
473 uint32_t tmp;
474
475 s.d = DT0;
476 d.d = DT1;
477
478 #define PMUL(r) \
479 tmp = (int32_t)d.VIS_SW64(1) * (int32_t)s.VIS_B64(r); \
480 if ((tmp & 0xff) > 0x7f) \
481 tmp += 0x100; \
482 d.VIS_W64(r) = tmp >> 8;
483
484 PMUL(0);
485 PMUL(1);
486 PMUL(2);
487 PMUL(3);
488 #undef PMUL
489
490 DT0 = d.d;
491 }
492
493 void helper_fmul8x16au(void)
494 {
495 vis64 s, d;
496 uint32_t tmp;
497
498 s.d = DT0;
499 d.d = DT1;
500
501 #define PMUL(r) \
502 tmp = (int32_t)d.VIS_SW64(0) * (int32_t)s.VIS_B64(r); \
503 if ((tmp & 0xff) > 0x7f) \
504 tmp += 0x100; \
505 d.VIS_W64(r) = tmp >> 8;
506
507 PMUL(0);
508 PMUL(1);
509 PMUL(2);
510 PMUL(3);
511 #undef PMUL
512
513 DT0 = d.d;
514 }
515
516 void helper_fmul8sux16(void)
517 {
518 vis64 s, d;
519 uint32_t tmp;
520
521 s.d = DT0;
522 d.d = DT1;
523
524 #define PMUL(r) \
525 tmp = (int32_t)d.VIS_SW64(r) * ((int32_t)s.VIS_SW64(r) >> 8); \
526 if ((tmp & 0xff) > 0x7f) \
527 tmp += 0x100; \
528 d.VIS_W64(r) = tmp >> 8;
529
530 PMUL(0);
531 PMUL(1);
532 PMUL(2);
533 PMUL(3);
534 #undef PMUL
535
536 DT0 = d.d;
537 }
538
539 void helper_fmul8ulx16(void)
540 {
541 vis64 s, d;
542 uint32_t tmp;
543
544 s.d = DT0;
545 d.d = DT1;
546
547 #define PMUL(r) \
548 tmp = (int32_t)d.VIS_SW64(r) * ((uint32_t)s.VIS_B64(r * 2)); \
549 if ((tmp & 0xff) > 0x7f) \
550 tmp += 0x100; \
551 d.VIS_W64(r) = tmp >> 8;
552
553 PMUL(0);
554 PMUL(1);
555 PMUL(2);
556 PMUL(3);
557 #undef PMUL
558
559 DT0 = d.d;
560 }
561
562 void helper_fmuld8sux16(void)
563 {
564 vis64 s, d;
565 uint32_t tmp;
566
567 s.d = DT0;
568 d.d = DT1;
569
570 #define PMUL(r) \
571 tmp = (int32_t)d.VIS_SW64(r) * ((int32_t)s.VIS_SW64(r) >> 8); \
572 if ((tmp & 0xff) > 0x7f) \
573 tmp += 0x100; \
574 d.VIS_L64(r) = tmp;
575
576 // Reverse calculation order to handle overlap
577 PMUL(1);
578 PMUL(0);
579 #undef PMUL
580
581 DT0 = d.d;
582 }
583
584 void helper_fmuld8ulx16(void)
585 {
586 vis64 s, d;
587 uint32_t tmp;
588
589 s.d = DT0;
590 d.d = DT1;
591
592 #define PMUL(r) \
593 tmp = (int32_t)d.VIS_SW64(r) * ((uint32_t)s.VIS_B64(r * 2)); \
594 if ((tmp & 0xff) > 0x7f) \
595 tmp += 0x100; \
596 d.VIS_L64(r) = tmp;
597
598 // Reverse calculation order to handle overlap
599 PMUL(1);
600 PMUL(0);
601 #undef PMUL
602
603 DT0 = d.d;
604 }
605
606 void helper_fexpand(void)
607 {
608 vis32 s;
609 vis64 d;
610
611 s.l = (uint32_t)(*(uint64_t *)&DT0 & 0xffffffff);
612 d.d = DT1;
613 d.VIS_W64(0) = s.VIS_B32(0) << 4;
614 d.VIS_W64(1) = s.VIS_B32(1) << 4;
615 d.VIS_W64(2) = s.VIS_B32(2) << 4;
616 d.VIS_W64(3) = s.VIS_B32(3) << 4;
617
618 DT0 = d.d;
619 }
620
621 #define VIS_HELPER(name, F) \
622 void name##16(void) \
623 { \
624 vis64 s, d; \
625 \
626 s.d = DT0; \
627 d.d = DT1; \
628 \
629 d.VIS_W64(0) = F(d.VIS_W64(0), s.VIS_W64(0)); \
630 d.VIS_W64(1) = F(d.VIS_W64(1), s.VIS_W64(1)); \
631 d.VIS_W64(2) = F(d.VIS_W64(2), s.VIS_W64(2)); \
632 d.VIS_W64(3) = F(d.VIS_W64(3), s.VIS_W64(3)); \
633 \
634 DT0 = d.d; \
635 } \
636 \
637 uint32_t name##16s(uint32_t src1, uint32_t src2) \
638 { \
639 vis32 s, d; \
640 \
641 s.l = src1; \
642 d.l = src2; \
643 \
644 d.VIS_W32(0) = F(d.VIS_W32(0), s.VIS_W32(0)); \
645 d.VIS_W32(1) = F(d.VIS_W32(1), s.VIS_W32(1)); \
646 \
647 return d.l; \
648 } \
649 \
650 void name##32(void) \
651 { \
652 vis64 s, d; \
653 \
654 s.d = DT0; \
655 d.d = DT1; \
656 \
657 d.VIS_L64(0) = F(d.VIS_L64(0), s.VIS_L64(0)); \
658 d.VIS_L64(1) = F(d.VIS_L64(1), s.VIS_L64(1)); \
659 \
660 DT0 = d.d; \
661 } \
662 \
663 uint32_t name##32s(uint32_t src1, uint32_t src2) \
664 { \
665 vis32 s, d; \
666 \
667 s.l = src1; \
668 d.l = src2; \
669 \
670 d.l = F(d.l, s.l); \
671 \
672 return d.l; \
673 }
674
675 #define FADD(a, b) ((a) + (b))
676 #define FSUB(a, b) ((a) - (b))
677 VIS_HELPER(helper_fpadd, FADD)
678 VIS_HELPER(helper_fpsub, FSUB)
679
680 #define VIS_CMPHELPER(name, F) \
681 void name##16(void) \
682 { \
683 vis64 s, d; \
684 \
685 s.d = DT0; \
686 d.d = DT1; \
687 \
688 d.VIS_W64(0) = F(d.VIS_W64(0), s.VIS_W64(0))? 1: 0; \
689 d.VIS_W64(0) |= F(d.VIS_W64(1), s.VIS_W64(1))? 2: 0; \
690 d.VIS_W64(0) |= F(d.VIS_W64(2), s.VIS_W64(2))? 4: 0; \
691 d.VIS_W64(0) |= F(d.VIS_W64(3), s.VIS_W64(3))? 8: 0; \
692 \
693 DT0 = d.d; \
694 } \
695 \
696 void name##32(void) \
697 { \
698 vis64 s, d; \
699 \
700 s.d = DT0; \
701 d.d = DT1; \
702 \
703 d.VIS_L64(0) = F(d.VIS_L64(0), s.VIS_L64(0))? 1: 0; \
704 d.VIS_L64(0) |= F(d.VIS_L64(1), s.VIS_L64(1))? 2: 0; \
705 \
706 DT0 = d.d; \
707 }
708
709 #define FCMPGT(a, b) ((a) > (b))
710 #define FCMPEQ(a, b) ((a) == (b))
711 #define FCMPLE(a, b) ((a) <= (b))
712 #define FCMPNE(a, b) ((a) != (b))
713
714 VIS_CMPHELPER(helper_fcmpgt, FCMPGT)
715 VIS_CMPHELPER(helper_fcmpeq, FCMPEQ)
716 VIS_CMPHELPER(helper_fcmple, FCMPLE)
717 VIS_CMPHELPER(helper_fcmpne, FCMPNE)
718 #endif
719
720 void helper_check_ieee_exceptions(void)
721 {
722 target_ulong status;
723
724 status = get_float_exception_flags(&env->fp_status);
725 if (status) {
726 /* Copy IEEE 754 flags into FSR */
727 if (status & float_flag_invalid)
728 env->fsr |= FSR_NVC;
729 if (status & float_flag_overflow)
730 env->fsr |= FSR_OFC;
731 if (status & float_flag_underflow)
732 env->fsr |= FSR_UFC;
733 if (status & float_flag_divbyzero)
734 env->fsr |= FSR_DZC;
735 if (status & float_flag_inexact)
736 env->fsr |= FSR_NXC;
737
738 if ((env->fsr & FSR_CEXC_MASK) & ((env->fsr & FSR_TEM_MASK) >> 23)) {
739 /* Unmasked exception, generate a trap */
740 env->fsr |= FSR_FTT_IEEE_EXCP;
741 raise_exception(TT_FP_EXCP);
742 } else {
743 /* Accumulate exceptions */
744 env->fsr |= (env->fsr & FSR_CEXC_MASK) << 5;
745 }
746 }
747 }
748
749 void helper_clear_float_exceptions(void)
750 {
751 set_float_exception_flags(0, &env->fp_status);
752 }
753
754 float32 helper_fabss(float32 src)
755 {
756 return float32_abs(src);
757 }
758
759 #ifdef TARGET_SPARC64
760 void helper_fabsd(void)
761 {
762 DT0 = float64_abs(DT1);
763 }
764
765 void helper_fabsq(void)
766 {
767 QT0 = float128_abs(QT1);
768 }
769 #endif
770
771 float32 helper_fsqrts(float32 src)
772 {
773 return float32_sqrt(src, &env->fp_status);
774 }
775
776 void helper_fsqrtd(void)
777 {
778 DT0 = float64_sqrt(DT1, &env->fp_status);
779 }
780
781 void helper_fsqrtq(void)
782 {
783 QT0 = float128_sqrt(QT1, &env->fp_status);
784 }
785
786 #define GEN_FCMP(name, size, reg1, reg2, FS, TRAP) \
787 void glue(helper_, name) (void) \
788 { \
789 target_ulong new_fsr; \
790 \
791 env->fsr &= ~((FSR_FCC1 | FSR_FCC0) << FS); \
792 switch (glue(size, _compare) (reg1, reg2, &env->fp_status)) { \
793 case float_relation_unordered: \
794 new_fsr = (FSR_FCC1 | FSR_FCC0) << FS; \
795 if ((env->fsr & FSR_NVM) || TRAP) { \
796 env->fsr |= new_fsr; \
797 env->fsr |= FSR_NVC; \
798 env->fsr |= FSR_FTT_IEEE_EXCP; \
799 raise_exception(TT_FP_EXCP); \
800 } else { \
801 env->fsr |= FSR_NVA; \
802 } \
803 break; \
804 case float_relation_less: \
805 new_fsr = FSR_FCC0 << FS; \
806 break; \
807 case float_relation_greater: \
808 new_fsr = FSR_FCC1 << FS; \
809 break; \
810 default: \
811 new_fsr = 0; \
812 break; \
813 } \
814 env->fsr |= new_fsr; \
815 }
816 #define GEN_FCMPS(name, size, FS, TRAP) \
817 void glue(helper_, name)(float32 src1, float32 src2) \
818 { \
819 target_ulong new_fsr; \
820 \
821 env->fsr &= ~((FSR_FCC1 | FSR_FCC0) << FS); \
822 switch (glue(size, _compare) (src1, src2, &env->fp_status)) { \
823 case float_relation_unordered: \
824 new_fsr = (FSR_FCC1 | FSR_FCC0) << FS; \
825 if ((env->fsr & FSR_NVM) || TRAP) { \
826 env->fsr |= new_fsr; \
827 env->fsr |= FSR_NVC; \
828 env->fsr |= FSR_FTT_IEEE_EXCP; \
829 raise_exception(TT_FP_EXCP); \
830 } else { \
831 env->fsr |= FSR_NVA; \
832 } \
833 break; \
834 case float_relation_less: \
835 new_fsr = FSR_FCC0 << FS; \
836 break; \
837 case float_relation_greater: \
838 new_fsr = FSR_FCC1 << FS; \
839 break; \
840 default: \
841 new_fsr = 0; \
842 break; \
843 } \
844 env->fsr |= new_fsr; \
845 }
846
847 GEN_FCMPS(fcmps, float32, 0, 0);
848 GEN_FCMP(fcmpd, float64, DT0, DT1, 0, 0);
849
850 GEN_FCMPS(fcmpes, float32, 0, 1);
851 GEN_FCMP(fcmped, float64, DT0, DT1, 0, 1);
852
853 GEN_FCMP(fcmpq, float128, QT0, QT1, 0, 0);
854 GEN_FCMP(fcmpeq, float128, QT0, QT1, 0, 1);
855
856 static uint32_t compute_all_flags(void)
857 {
858 return env->psr & PSR_ICC;
859 }
860
861 static uint32_t compute_C_flags(void)
862 {
863 return env->psr & PSR_CARRY;
864 }
865
866 static inline uint32_t get_NZ_icc(target_ulong dst)
867 {
868 uint32_t ret = 0;
869
870 if (!(dst & 0xffffffffULL))
871 ret |= PSR_ZERO;
872 if ((int32_t) (dst & 0xffffffffULL) < 0)
873 ret |= PSR_NEG;
874 return ret;
875 }
876
877 #ifdef TARGET_SPARC64
878 static uint32_t compute_all_flags_xcc(void)
879 {
880 return env->xcc & PSR_ICC;
881 }
882
883 static uint32_t compute_C_flags_xcc(void)
884 {
885 return env->xcc & PSR_CARRY;
886 }
887
888 static inline uint32_t get_NZ_xcc(target_ulong dst)
889 {
890 uint32_t ret = 0;
891
892 if (!dst)
893 ret |= PSR_ZERO;
894 if ((int64_t)dst < 0)
895 ret |= PSR_NEG;
896 return ret;
897 }
898 #endif
899
900 static inline uint32_t get_V_div_icc(target_ulong src2)
901 {
902 uint32_t ret = 0;
903
904 if (src2 != 0)
905 ret |= PSR_OVF;
906 return ret;
907 }
908
909 static uint32_t compute_all_div(void)
910 {
911 uint32_t ret;
912
913 ret = get_NZ_icc(CC_DST);
914 ret |= get_V_div_icc(CC_SRC2);
915 return ret;
916 }
917
918 static uint32_t compute_C_div(void)
919 {
920 return 0;
921 }
922
923 /* carry = (src1[31] & src2[31]) | ( ~dst[31] & (src1[31] | src2[31])) */
924 static inline uint32_t get_C_add_icc(target_ulong dst, target_ulong src1,
925 target_ulong src2)
926 {
927 uint32_t ret = 0;
928
929 if (((src1 & (1ULL << 31)) & (src2 & (1ULL << 31)))
930 | ((~(dst & (1ULL << 31)))
931 & ((src1 & (1ULL << 31)) | (src2 & (1ULL << 31)))))
932 ret |= PSR_CARRY;
933 return ret;
934 }
935
936 static inline uint32_t get_V_add_icc(target_ulong dst, target_ulong src1,
937 target_ulong src2)
938 {
939 uint32_t ret = 0;
940
941 if (((src1 ^ src2 ^ -1) & (src1 ^ dst)) & (1ULL << 31))
942 ret |= PSR_OVF;
943 return ret;
944 }
945
946 #ifdef TARGET_SPARC64
947 static inline uint32_t get_C_add_xcc(target_ulong dst, target_ulong src1)
948 {
949 uint32_t ret = 0;
950
951 if (dst < src1)
952 ret |= PSR_CARRY;
953 return ret;
954 }
955
956 static inline uint32_t get_V_add_xcc(target_ulong dst, target_ulong src1,
957 target_ulong src2)
958 {
959 uint32_t ret = 0;
960
961 if (((src1 ^ src2 ^ -1) & (src1 ^ dst)) & (1ULL << 63))
962 ret |= PSR_OVF;
963 return ret;
964 }
965
966 static uint32_t compute_all_add_xcc(void)
967 {
968 uint32_t ret;
969
970 ret = get_NZ_xcc(CC_DST);
971 ret |= get_C_add_xcc(CC_DST, CC_SRC);
972 ret |= get_V_add_xcc(CC_DST, CC_SRC, CC_SRC2);
973 return ret;
974 }
975
976 static uint32_t compute_C_add_xcc(void)
977 {
978 return get_C_add_xcc(CC_DST, CC_SRC);
979 }
980 #endif
981
982 static uint32_t compute_all_add(void)
983 {
984 uint32_t ret;
985
986 ret = get_NZ_icc(CC_DST);
987 ret |= get_C_add_icc(CC_DST, CC_SRC, CC_SRC2);
988 ret |= get_V_add_icc(CC_DST, CC_SRC, CC_SRC2);
989 return ret;
990 }
991
992 static uint32_t compute_C_add(void)
993 {
994 return get_C_add_icc(CC_DST, CC_SRC, CC_SRC2);
995 }
996
997 #ifdef TARGET_SPARC64
998 static uint32_t compute_all_addx_xcc(void)
999 {
1000 uint32_t ret;
1001
1002 ret = get_NZ_xcc(CC_DST);
1003 ret |= get_C_add_xcc(CC_DST - CC_SRC2, CC_SRC);
1004 ret |= get_C_add_xcc(CC_DST, CC_SRC);
1005 ret |= get_V_add_xcc(CC_DST, CC_SRC, CC_SRC2);
1006 return ret;
1007 }
1008
1009 static uint32_t compute_C_addx_xcc(void)
1010 {
1011 uint32_t ret;
1012
1013 ret = get_C_add_xcc(CC_DST - CC_SRC2, CC_SRC);
1014 ret |= get_C_add_xcc(CC_DST, CC_SRC);
1015 return ret;
1016 }
1017 #endif
1018
1019 static inline uint32_t get_V_tag_icc(target_ulong src1, target_ulong src2)
1020 {
1021 uint32_t ret = 0;
1022
1023 if ((src1 | src2) & 0x3)
1024 ret |= PSR_OVF;
1025 return ret;
1026 }
1027
1028 static uint32_t compute_all_tadd(void)
1029 {
1030 uint32_t ret;
1031
1032 ret = get_NZ_icc(CC_DST);
1033 ret |= get_C_add_icc(CC_DST, CC_SRC, CC_SRC2);
1034 ret |= get_V_add_icc(CC_DST, CC_SRC, CC_SRC2);
1035 ret |= get_V_tag_icc(CC_SRC, CC_SRC2);
1036 return ret;
1037 }
1038
1039 static uint32_t compute_C_tadd(void)
1040 {
1041 return get_C_add_icc(CC_DST, CC_SRC, CC_SRC2);
1042 }
1043
1044 static uint32_t compute_all_taddtv(void)
1045 {
1046 uint32_t ret;
1047
1048 ret = get_NZ_icc(CC_DST);
1049 ret |= get_C_add_icc(CC_DST, CC_SRC, CC_SRC2);
1050 return ret;
1051 }
1052
1053 static uint32_t compute_C_taddtv(void)
1054 {
1055 return get_C_add_icc(CC_DST, CC_SRC, CC_SRC2);
1056 }
1057
1058 /* carry = (~src1[31] & src2[31]) | ( dst[31] & (~src1[31] | src2[31])) */
1059 static inline uint32_t get_C_sub_icc(target_ulong dst, target_ulong src1,
1060 target_ulong src2)
1061 {
1062 uint32_t ret = 0;
1063
1064 if (((~(src1 & (1ULL << 31))) & (src2 & (1ULL << 31)))
1065 | ((dst & (1ULL << 31)) & (( ~(src1 & (1ULL << 31)))
1066 | (src2 & (1ULL << 31)))))
1067 ret |= PSR_CARRY;
1068 return ret;
1069 }
1070
1071 static inline uint32_t get_V_sub_icc(target_ulong dst, target_ulong src1,
1072 target_ulong src2)
1073 {
1074 uint32_t ret = 0;
1075
1076 if (((src1 ^ src2) & (src1 ^ dst)) & (1ULL << 31))
1077 ret |= PSR_OVF;
1078 return ret;
1079 }
1080
1081
1082 #ifdef TARGET_SPARC64
1083 static inline uint32_t get_C_sub_xcc(target_ulong src1, target_ulong src2)
1084 {
1085 uint32_t ret = 0;
1086
1087 if (src1 < src2)
1088 ret |= PSR_CARRY;
1089 return ret;
1090 }
1091
1092 static inline uint32_t get_V_sub_xcc(target_ulong dst, target_ulong src1,
1093 target_ulong src2)
1094 {
1095 uint32_t ret = 0;
1096
1097 if (((src1 ^ src2) & (src1 ^ dst)) & (1ULL << 63))
1098 ret |= PSR_OVF;
1099 return ret;
1100 }
1101
1102 static uint32_t compute_all_sub_xcc(void)
1103 {
1104 uint32_t ret;
1105
1106 ret = get_NZ_xcc(CC_DST);
1107 ret |= get_C_sub_xcc(CC_SRC, CC_SRC2);
1108 ret |= get_V_sub_xcc(CC_DST, CC_SRC, CC_SRC2);
1109 return ret;
1110 }
1111
1112 static uint32_t compute_C_sub_xcc(void)
1113 {
1114 return get_C_sub_xcc(CC_SRC, CC_SRC2);
1115 }
1116 #endif
1117
1118 static uint32_t compute_all_sub(void)
1119 {
1120 uint32_t ret;
1121
1122 ret = get_NZ_icc(CC_DST);
1123 ret |= get_C_sub_icc(CC_DST, CC_SRC, CC_SRC2);
1124 ret |= get_V_sub_icc(CC_DST, CC_SRC, CC_SRC2);
1125 return ret;
1126 }
1127
1128 static uint32_t compute_C_sub(void)
1129 {
1130 return get_C_sub_icc(CC_DST, CC_SRC, CC_SRC2);
1131 }
1132
1133 #ifdef TARGET_SPARC64
1134 static uint32_t compute_all_subx_xcc(void)
1135 {
1136 uint32_t ret;
1137
1138 ret = get_NZ_xcc(CC_DST);
1139 ret |= get_C_sub_xcc(CC_DST - CC_SRC2, CC_SRC);
1140 ret |= get_C_sub_xcc(CC_DST, CC_SRC2);
1141 ret |= get_V_sub_xcc(CC_DST, CC_SRC, CC_SRC2);
1142 return ret;
1143 }
1144
1145 static uint32_t compute_C_subx_xcc(void)
1146 {
1147 uint32_t ret;
1148
1149 ret = get_C_sub_xcc(CC_DST - CC_SRC2, CC_SRC);
1150 ret |= get_C_sub_xcc(CC_DST, CC_SRC2);
1151 return ret;
1152 }
1153 #endif
1154
1155 static uint32_t compute_all_tsub(void)
1156 {
1157 uint32_t ret;
1158
1159 ret = get_NZ_icc(CC_DST);
1160 ret |= get_C_sub_icc(CC_DST, CC_SRC, CC_SRC2);
1161 ret |= get_V_sub_icc(CC_DST, CC_SRC, CC_SRC2);
1162 ret |= get_V_tag_icc(CC_SRC, CC_SRC2);
1163 return ret;
1164 }
1165
1166 static uint32_t compute_C_tsub(void)
1167 {
1168 return get_C_sub_icc(CC_DST, CC_SRC, CC_SRC2);
1169 }
1170
1171 static uint32_t compute_all_tsubtv(void)
1172 {
1173 uint32_t ret;
1174
1175 ret = get_NZ_icc(CC_DST);
1176 ret |= get_C_sub_icc(CC_DST, CC_SRC, CC_SRC2);
1177 return ret;
1178 }
1179
1180 static uint32_t compute_C_tsubtv(void)
1181 {
1182 return get_C_sub_icc(CC_DST, CC_SRC, CC_SRC2);
1183 }
1184
1185 static uint32_t compute_all_logic(void)
1186 {
1187 return get_NZ_icc(CC_DST);
1188 }
1189
1190 static uint32_t compute_C_logic(void)
1191 {
1192 return 0;
1193 }
1194
1195 #ifdef TARGET_SPARC64
1196 static uint32_t compute_all_logic_xcc(void)
1197 {
1198 return get_NZ_xcc(CC_DST);
1199 }
1200 #endif
1201
1202 typedef struct CCTable {
1203 uint32_t (*compute_all)(void); /* return all the flags */
1204 uint32_t (*compute_c)(void); /* return the C flag */
1205 } CCTable;
1206
1207 static const CCTable icc_table[CC_OP_NB] = {
1208 /* CC_OP_DYNAMIC should never happen */
1209 [CC_OP_FLAGS] = { compute_all_flags, compute_C_flags },
1210 [CC_OP_DIV] = { compute_all_div, compute_C_div },
1211 [CC_OP_ADD] = { compute_all_add, compute_C_add },
1212 [CC_OP_ADDX] = { compute_all_add, compute_C_add },
1213 [CC_OP_TADD] = { compute_all_tadd, compute_C_tadd },
1214 [CC_OP_TADDTV] = { compute_all_taddtv, compute_C_taddtv },
1215 [CC_OP_SUB] = { compute_all_sub, compute_C_sub },
1216 [CC_OP_SUBX] = { compute_all_sub, compute_C_sub },
1217 [CC_OP_TSUB] = { compute_all_tsub, compute_C_tsub },
1218 [CC_OP_TSUBTV] = { compute_all_tsubtv, compute_C_tsubtv },
1219 [CC_OP_LOGIC] = { compute_all_logic, compute_C_logic },
1220 };
1221
1222 #ifdef TARGET_SPARC64
1223 static const CCTable xcc_table[CC_OP_NB] = {
1224 /* CC_OP_DYNAMIC should never happen */
1225 [CC_OP_FLAGS] = { compute_all_flags_xcc, compute_C_flags_xcc },
1226 [CC_OP_DIV] = { compute_all_logic_xcc, compute_C_logic },
1227 [CC_OP_ADD] = { compute_all_add_xcc, compute_C_add_xcc },
1228 [CC_OP_ADDX] = { compute_all_addx_xcc, compute_C_addx_xcc },
1229 [CC_OP_TADD] = { compute_all_add_xcc, compute_C_add_xcc },
1230 [CC_OP_TADDTV] = { compute_all_add_xcc, compute_C_add_xcc },
1231 [CC_OP_SUB] = { compute_all_sub_xcc, compute_C_sub_xcc },
1232 [CC_OP_SUBX] = { compute_all_subx_xcc, compute_C_subx_xcc },
1233 [CC_OP_TSUB] = { compute_all_sub_xcc, compute_C_sub_xcc },
1234 [CC_OP_TSUBTV] = { compute_all_sub_xcc, compute_C_sub_xcc },
1235 [CC_OP_LOGIC] = { compute_all_logic_xcc, compute_C_logic },
1236 };
1237 #endif
1238
1239 void helper_compute_psr(void)
1240 {
1241 uint32_t new_psr;
1242
1243 new_psr = icc_table[CC_OP].compute_all();
1244 env->psr = new_psr;
1245 #ifdef TARGET_SPARC64
1246 new_psr = xcc_table[CC_OP].compute_all();
1247 env->xcc = new_psr;
1248 #endif
1249 CC_OP = CC_OP_FLAGS;
1250 }
1251
1252 uint32_t helper_compute_C_icc(void)
1253 {
1254 uint32_t ret;
1255
1256 ret = icc_table[CC_OP].compute_c() >> PSR_CARRY_SHIFT;
1257 return ret;
1258 }
1259
1260 #ifdef TARGET_SPARC64
1261 GEN_FCMPS(fcmps_fcc1, float32, 22, 0);
1262 GEN_FCMP(fcmpd_fcc1, float64, DT0, DT1, 22, 0);
1263 GEN_FCMP(fcmpq_fcc1, float128, QT0, QT1, 22, 0);
1264
1265 GEN_FCMPS(fcmps_fcc2, float32, 24, 0);
1266 GEN_FCMP(fcmpd_fcc2, float64, DT0, DT1, 24, 0);
1267 GEN_FCMP(fcmpq_fcc2, float128, QT0, QT1, 24, 0);
1268
1269 GEN_FCMPS(fcmps_fcc3, float32, 26, 0);
1270 GEN_FCMP(fcmpd_fcc3, float64, DT0, DT1, 26, 0);
1271 GEN_FCMP(fcmpq_fcc3, float128, QT0, QT1, 26, 0);
1272
1273 GEN_FCMPS(fcmpes_fcc1, float32, 22, 1);
1274 GEN_FCMP(fcmped_fcc1, float64, DT0, DT1, 22, 1);
1275 GEN_FCMP(fcmpeq_fcc1, float128, QT0, QT1, 22, 1);
1276
1277 GEN_FCMPS(fcmpes_fcc2, float32, 24, 1);
1278 GEN_FCMP(fcmped_fcc2, float64, DT0, DT1, 24, 1);
1279 GEN_FCMP(fcmpeq_fcc2, float128, QT0, QT1, 24, 1);
1280
1281 GEN_FCMPS(fcmpes_fcc3, float32, 26, 1);
1282 GEN_FCMP(fcmped_fcc3, float64, DT0, DT1, 26, 1);
1283 GEN_FCMP(fcmpeq_fcc3, float128, QT0, QT1, 26, 1);
1284 #endif
1285 #undef GEN_FCMPS
1286
1287 #if !defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY) && \
1288 defined(DEBUG_MXCC)
1289 static void dump_mxcc(CPUState *env)
1290 {
1291 printf("mxccdata: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64
1292 "\n",
1293 env->mxccdata[0], env->mxccdata[1],
1294 env->mxccdata[2], env->mxccdata[3]);
1295 printf("mxccregs: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64
1296 "\n"
1297 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64
1298 "\n",
1299 env->mxccregs[0], env->mxccregs[1],
1300 env->mxccregs[2], env->mxccregs[3],
1301 env->mxccregs[4], env->mxccregs[5],
1302 env->mxccregs[6], env->mxccregs[7]);
1303 }
1304 #endif
1305
1306 #if (defined(TARGET_SPARC64) || !defined(CONFIG_USER_ONLY)) \
1307 && defined(DEBUG_ASI)
1308 static void dump_asi(const char *txt, target_ulong addr, int asi, int size,
1309 uint64_t r1)
1310 {
1311 switch (size)
1312 {
1313 case 1:
1314 DPRINTF_ASI("%s "TARGET_FMT_lx " asi 0x%02x = %02" PRIx64 "\n", txt,
1315 addr, asi, r1 & 0xff);
1316 break;
1317 case 2:
1318 DPRINTF_ASI("%s "TARGET_FMT_lx " asi 0x%02x = %04" PRIx64 "\n", txt,
1319 addr, asi, r1 & 0xffff);
1320 break;
1321 case 4:
1322 DPRINTF_ASI("%s "TARGET_FMT_lx " asi 0x%02x = %08" PRIx64 "\n", txt,
1323 addr, asi, r1 & 0xffffffff);
1324 break;
1325 case 8:
1326 DPRINTF_ASI("%s "TARGET_FMT_lx " asi 0x%02x = %016" PRIx64 "\n", txt,
1327 addr, asi, r1);
1328 break;
1329 }
1330 }
1331 #endif
1332
1333 #ifndef TARGET_SPARC64
1334 #ifndef CONFIG_USER_ONLY
1335 uint64_t helper_ld_asi(target_ulong addr, int asi, int size, int sign)
1336 {
1337 uint64_t ret = 0;
1338 #if defined(DEBUG_MXCC) || defined(DEBUG_ASI)
1339 uint32_t last_addr = addr;
1340 #endif
1341
1342 helper_check_align(addr, size - 1);
1343 switch (asi) {
1344 case 2: /* SuperSparc MXCC registers */
1345 switch (addr) {
1346 case 0x01c00a00: /* MXCC control register */
1347 if (size == 8)
1348 ret = env->mxccregs[3];
1349 else
1350 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1351 size);
1352 break;
1353 case 0x01c00a04: /* MXCC control register */
1354 if (size == 4)
1355 ret = env->mxccregs[3];
1356 else
1357 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1358 size);
1359 break;
1360 case 0x01c00c00: /* Module reset register */
1361 if (size == 8) {
1362 ret = env->mxccregs[5];
1363 // should we do something here?
1364 } else
1365 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1366 size);
1367 break;
1368 case 0x01c00f00: /* MBus port address register */
1369 if (size == 8)
1370 ret = env->mxccregs[7];
1371 else
1372 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1373 size);
1374 break;
1375 default:
1376 DPRINTF_MXCC("%08x: unimplemented address, size: %d\n", addr,
1377 size);
1378 break;
1379 }
1380 DPRINTF_MXCC("asi = %d, size = %d, sign = %d, "
1381 "addr = %08x -> ret = %" PRIx64 ","
1382 "addr = %08x\n", asi, size, sign, last_addr, ret, addr);
1383 #ifdef DEBUG_MXCC
1384 dump_mxcc(env);
1385 #endif
1386 break;
1387 case 3: /* MMU probe */
1388 {
1389 int mmulev;
1390
1391 mmulev = (addr >> 8) & 15;
1392 if (mmulev > 4)
1393 ret = 0;
1394 else
1395 ret = mmu_probe(env, addr, mmulev);
1396 DPRINTF_MMU("mmu_probe: 0x%08x (lev %d) -> 0x%08" PRIx64 "\n",
1397 addr, mmulev, ret);
1398 }
1399 break;
1400 case 4: /* read MMU regs */
1401 {
1402 int reg = (addr >> 8) & 0x1f;
1403
1404 ret = env->mmuregs[reg];
1405 if (reg == 3) /* Fault status cleared on read */
1406 env->mmuregs[3] = 0;
1407 else if (reg == 0x13) /* Fault status read */
1408 ret = env->mmuregs[3];
1409 else if (reg == 0x14) /* Fault address read */
1410 ret = env->mmuregs[4];
1411 DPRINTF_MMU("mmu_read: reg[%d] = 0x%08" PRIx64 "\n", reg, ret);
1412 }
1413 break;
1414 case 5: // Turbosparc ITLB Diagnostic
1415 case 6: // Turbosparc DTLB Diagnostic
1416 case 7: // Turbosparc IOTLB Diagnostic
1417 break;
1418 case 9: /* Supervisor code access */
1419 switch(size) {
1420 case 1:
1421 ret = ldub_code(addr);
1422 break;
1423 case 2:
1424 ret = lduw_code(addr);
1425 break;
1426 default:
1427 case 4:
1428 ret = ldl_code(addr);
1429 break;
1430 case 8:
1431 ret = ldq_code(addr);
1432 break;
1433 }
1434 break;
1435 case 0xa: /* User data access */
1436 switch(size) {
1437 case 1:
1438 ret = ldub_user(addr);
1439 break;
1440 case 2:
1441 ret = lduw_user(addr);
1442 break;
1443 default:
1444 case 4:
1445 ret = ldl_user(addr);
1446 break;
1447 case 8:
1448 ret = ldq_user(addr);
1449 break;
1450 }
1451 break;
1452 case 0xb: /* Supervisor data access */
1453 switch(size) {
1454 case 1:
1455 ret = ldub_kernel(addr);
1456 break;
1457 case 2:
1458 ret = lduw_kernel(addr);
1459 break;
1460 default:
1461 case 4:
1462 ret = ldl_kernel(addr);
1463 break;
1464 case 8:
1465 ret = ldq_kernel(addr);
1466 break;
1467 }
1468 break;
1469 case 0xc: /* I-cache tag */
1470 case 0xd: /* I-cache data */
1471 case 0xe: /* D-cache tag */
1472 case 0xf: /* D-cache data */
1473 break;
1474 case 0x20: /* MMU passthrough */
1475 switch(size) {
1476 case 1:
1477 ret = ldub_phys(addr);
1478 break;
1479 case 2:
1480 ret = lduw_phys(addr);
1481 break;
1482 default:
1483 case 4:
1484 ret = ldl_phys(addr);
1485 break;
1486 case 8:
1487 ret = ldq_phys(addr);
1488 break;
1489 }
1490 break;
1491 case 0x21 ... 0x2f: /* MMU passthrough, 0x100000000 to 0xfffffffff */
1492 switch(size) {
1493 case 1:
1494 ret = ldub_phys((target_phys_addr_t)addr
1495 | ((target_phys_addr_t)(asi & 0xf) << 32));
1496 break;
1497 case 2:
1498 ret = lduw_phys((target_phys_addr_t)addr
1499 | ((target_phys_addr_t)(asi & 0xf) << 32));
1500 break;
1501 default:
1502 case 4:
1503 ret = ldl_phys((target_phys_addr_t)addr
1504 | ((target_phys_addr_t)(asi & 0xf) << 32));
1505 break;
1506 case 8:
1507 ret = ldq_phys((target_phys_addr_t)addr
1508 | ((target_phys_addr_t)(asi & 0xf) << 32));
1509 break;
1510 }
1511 break;
1512 case 0x30: // Turbosparc secondary cache diagnostic
1513 case 0x31: // Turbosparc RAM snoop
1514 case 0x32: // Turbosparc page table descriptor diagnostic
1515 case 0x39: /* data cache diagnostic register */
1516 ret = 0;
1517 break;
1518 case 0x38: /* SuperSPARC MMU Breakpoint Control Registers */
1519 {
1520 int reg = (addr >> 8) & 3;
1521
1522 switch(reg) {
1523 case 0: /* Breakpoint Value (Addr) */
1524 ret = env->mmubpregs[reg];
1525 break;
1526 case 1: /* Breakpoint Mask */
1527 ret = env->mmubpregs[reg];
1528 break;
1529 case 2: /* Breakpoint Control */
1530 ret = env->mmubpregs[reg];
1531 break;
1532 case 3: /* Breakpoint Status */
1533 ret = env->mmubpregs[reg];
1534 env->mmubpregs[reg] = 0ULL;
1535 break;
1536 }
1537 DPRINTF_MMU("read breakpoint reg[%d] 0x%016" PRIx64 "\n", reg,
1538 ret);
1539 }
1540 break;
1541 case 8: /* User code access, XXX */
1542 default:
1543 do_unassigned_access(addr, 0, 0, asi, size);
1544 ret = 0;
1545 break;
1546 }
1547 if (sign) {
1548 switch(size) {
1549 case 1:
1550 ret = (int8_t) ret;
1551 break;
1552 case 2:
1553 ret = (int16_t) ret;
1554 break;
1555 case 4:
1556 ret = (int32_t) ret;
1557 break;
1558 default:
1559 break;
1560 }
1561 }
1562 #ifdef DEBUG_ASI
1563 dump_asi("read ", last_addr, asi, size, ret);
1564 #endif
1565 return ret;
1566 }
1567
1568 void helper_st_asi(target_ulong addr, uint64_t val, int asi, int size)
1569 {
1570 helper_check_align(addr, size - 1);
1571 switch(asi) {
1572 case 2: /* SuperSparc MXCC registers */
1573 switch (addr) {
1574 case 0x01c00000: /* MXCC stream data register 0 */
1575 if (size == 8)
1576 env->mxccdata[0] = val;
1577 else
1578 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1579 size);
1580 break;
1581 case 0x01c00008: /* MXCC stream data register 1 */
1582 if (size == 8)
1583 env->mxccdata[1] = val;
1584 else
1585 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1586 size);
1587 break;
1588 case 0x01c00010: /* MXCC stream data register 2 */
1589 if (size == 8)
1590 env->mxccdata[2] = val;
1591 else
1592 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1593 size);
1594 break;
1595 case 0x01c00018: /* MXCC stream data register 3 */
1596 if (size == 8)
1597 env->mxccdata[3] = val;
1598 else
1599 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1600 size);
1601 break;
1602 case 0x01c00100: /* MXCC stream source */
1603 if (size == 8)
1604 env->mxccregs[0] = val;
1605 else
1606 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1607 size);
1608 env->mxccdata[0] = ldq_phys((env->mxccregs[0] & 0xffffffffULL) +
1609 0);
1610 env->mxccdata[1] = ldq_phys((env->mxccregs[0] & 0xffffffffULL) +
1611 8);
1612 env->mxccdata[2] = ldq_phys((env->mxccregs[0] & 0xffffffffULL) +
1613 16);
1614 env->mxccdata[3] = ldq_phys((env->mxccregs[0] & 0xffffffffULL) +
1615 24);
1616 break;
1617 case 0x01c00200: /* MXCC stream destination */
1618 if (size == 8)
1619 env->mxccregs[1] = val;
1620 else
1621 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1622 size);
1623 stq_phys((env->mxccregs[1] & 0xffffffffULL) + 0,
1624 env->mxccdata[0]);
1625 stq_phys((env->mxccregs[1] & 0xffffffffULL) + 8,
1626 env->mxccdata[1]);
1627 stq_phys((env->mxccregs[1] & 0xffffffffULL) + 16,
1628 env->mxccdata[2]);
1629 stq_phys((env->mxccregs[1] & 0xffffffffULL) + 24,
1630 env->mxccdata[3]);
1631 break;
1632 case 0x01c00a00: /* MXCC control register */
1633 if (size == 8)
1634 env->mxccregs[3] = val;
1635 else
1636 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1637 size);
1638 break;
1639 case 0x01c00a04: /* MXCC control register */
1640 if (size == 4)
1641 env->mxccregs[3] = (env->mxccregs[3] & 0xffffffff00000000ULL)
1642 | val;
1643 else
1644 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1645 size);
1646 break;
1647 case 0x01c00e00: /* MXCC error register */
1648 // writing a 1 bit clears the error
1649 if (size == 8)
1650 env->mxccregs[6] &= ~val;
1651 else
1652 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1653 size);
1654 break;
1655 case 0x01c00f00: /* MBus port address register */
1656 if (size == 8)
1657 env->mxccregs[7] = val;
1658 else
1659 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
1660 size);
1661 break;
1662 default:
1663 DPRINTF_MXCC("%08x: unimplemented address, size: %d\n", addr,
1664 size);
1665 break;
1666 }
1667 DPRINTF_MXCC("asi = %d, size = %d, addr = %08x, val = %" PRIx64 "\n",
1668 asi, size, addr, val);
1669 #ifdef DEBUG_MXCC
1670 dump_mxcc(env);
1671 #endif
1672 break;
1673 case 3: /* MMU flush */
1674 {
1675 int mmulev;
1676
1677 mmulev = (addr >> 8) & 15;
1678 DPRINTF_MMU("mmu flush level %d\n", mmulev);
1679 switch (mmulev) {
1680 case 0: // flush page
1681 tlb_flush_page(env, addr & 0xfffff000);
1682 break;
1683 case 1: // flush segment (256k)
1684 case 2: // flush region (16M)
1685 case 3: // flush context (4G)
1686 case 4: // flush entire
1687 tlb_flush(env, 1);
1688 break;
1689 default:
1690 break;
1691 }
1692 #ifdef DEBUG_MMU
1693 dump_mmu(env);
1694 #endif
1695 }
1696 break;
1697 case 4: /* write MMU regs */
1698 {
1699 int reg = (addr >> 8) & 0x1f;
1700 uint32_t oldreg;
1701
1702 oldreg = env->mmuregs[reg];
1703 switch(reg) {
1704 case 0: // Control Register
1705 env->mmuregs[reg] = (env->mmuregs[reg] & 0xff000000) |
1706 (val & 0x00ffffff);
1707 // Mappings generated during no-fault mode or MMU
1708 // disabled mode are invalid in normal mode
1709 if ((oldreg & (MMU_E | MMU_NF | env->def->mmu_bm)) !=
1710 (env->mmuregs[reg] & (MMU_E | MMU_NF | env->def->mmu_bm)))
1711 tlb_flush(env, 1);
1712 break;
1713 case 1: // Context Table Pointer Register
1714 env->mmuregs[reg] = val & env->def->mmu_ctpr_mask;
1715 break;
1716 case 2: // Context Register
1717 env->mmuregs[reg] = val & env->def->mmu_cxr_mask;
1718 if (oldreg != env->mmuregs[reg]) {
1719 /* we flush when the MMU context changes because
1720 QEMU has no MMU context support */
1721 tlb_flush(env, 1);
1722 }
1723 break;
1724 case 3: // Synchronous Fault Status Register with Clear
1725 case 4: // Synchronous Fault Address Register
1726 break;
1727 case 0x10: // TLB Replacement Control Register
1728 env->mmuregs[reg] = val & env->def->mmu_trcr_mask;
1729 break;
1730 case 0x13: // Synchronous Fault Status Register with Read and Clear
1731 env->mmuregs[3] = val & env->def->mmu_sfsr_mask;
1732 break;
1733 case 0x14: // Synchronous Fault Address Register
1734 env->mmuregs[4] = val;
1735 break;
1736 default:
1737 env->mmuregs[reg] = val;
1738 break;
1739 }
1740 if (oldreg != env->mmuregs[reg]) {
1741 DPRINTF_MMU("mmu change reg[%d]: 0x%08x -> 0x%08x\n",
1742 reg, oldreg, env->mmuregs[reg]);
1743 }
1744 #ifdef DEBUG_MMU
1745 dump_mmu(env);
1746 #endif
1747 }
1748 break;
1749 case 5: // Turbosparc ITLB Diagnostic
1750 case 6: // Turbosparc DTLB Diagnostic
1751 case 7: // Turbosparc IOTLB Diagnostic
1752 break;
1753 case 0xa: /* User data access */
1754 switch(size) {
1755 case 1:
1756 stb_user(addr, val);
1757 break;
1758 case 2:
1759 stw_user(addr, val);
1760 break;
1761 default:
1762 case 4:
1763 stl_user(addr, val);
1764 break;
1765 case 8:
1766 stq_user(addr, val);
1767 break;
1768 }
1769 break;
1770 case 0xb: /* Supervisor data access */
1771 switch(size) {
1772 case 1:
1773 stb_kernel(addr, val);
1774 break;
1775 case 2:
1776 stw_kernel(addr, val);
1777 break;
1778 default:
1779 case 4:
1780 stl_kernel(addr, val);
1781 break;
1782 case 8:
1783 stq_kernel(addr, val);
1784 break;
1785 }
1786 break;
1787 case 0xc: /* I-cache tag */
1788 case 0xd: /* I-cache data */
1789 case 0xe: /* D-cache tag */
1790 case 0xf: /* D-cache data */
1791 case 0x10: /* I/D-cache flush page */
1792 case 0x11: /* I/D-cache flush segment */
1793 case 0x12: /* I/D-cache flush region */
1794 case 0x13: /* I/D-cache flush context */
1795 case 0x14: /* I/D-cache flush user */
1796 break;
1797 case 0x17: /* Block copy, sta access */
1798 {
1799 // val = src
1800 // addr = dst
1801 // copy 32 bytes
1802 unsigned int i;
1803 uint32_t src = val & ~3, dst = addr & ~3, temp;
1804
1805 for (i = 0; i < 32; i += 4, src += 4, dst += 4) {
1806 temp = ldl_kernel(src);
1807 stl_kernel(dst, temp);
1808 }
1809 }
1810 break;
1811 case 0x1f: /* Block fill, stda access */
1812 {
1813 // addr = dst
1814 // fill 32 bytes with val
1815 unsigned int i;
1816 uint32_t dst = addr & 7;
1817
1818 for (i = 0; i < 32; i += 8, dst += 8)
1819 stq_kernel(dst, val);
1820 }
1821 break;
1822 case 0x20: /* MMU passthrough */
1823 {
1824 switch(size) {
1825 case 1:
1826 stb_phys(addr, val);
1827 break;
1828 case 2:
1829 stw_phys(addr, val);
1830 break;
1831 case 4:
1832 default:
1833 stl_phys(addr, val);
1834 break;
1835 case 8:
1836 stq_phys(addr, val);
1837 break;
1838 }
1839 }
1840 break;
1841 case 0x21 ... 0x2f: /* MMU passthrough, 0x100000000 to 0xfffffffff */
1842 {
1843 switch(size) {
1844 case 1:
1845 stb_phys((target_phys_addr_t)addr
1846 | ((target_phys_addr_t)(asi & 0xf) << 32), val);
1847 break;
1848 case 2:
1849 stw_phys((target_phys_addr_t)addr
1850 | ((target_phys_addr_t)(asi & 0xf) << 32), val);
1851 break;
1852 case 4:
1853 default:
1854 stl_phys((target_phys_addr_t)addr
1855 | ((target_phys_addr_t)(asi & 0xf) << 32), val);
1856 break;
1857 case 8:
1858 stq_phys((target_phys_addr_t)addr
1859 | ((target_phys_addr_t)(asi & 0xf) << 32), val);
1860 break;
1861 }
1862 }
1863 break;
1864 case 0x30: // store buffer tags or Turbosparc secondary cache diagnostic
1865 case 0x31: // store buffer data, Ross RT620 I-cache flush or
1866 // Turbosparc snoop RAM
1867 case 0x32: // store buffer control or Turbosparc page table
1868 // descriptor diagnostic
1869 case 0x36: /* I-cache flash clear */
1870 case 0x37: /* D-cache flash clear */
1871 case 0x4c: /* breakpoint action */
1872 break;
1873 case 0x38: /* SuperSPARC MMU Breakpoint Control Registers*/
1874 {
1875 int reg = (addr >> 8) & 3;
1876
1877 switch(reg) {
1878 case 0: /* Breakpoint Value (Addr) */
1879 env->mmubpregs[reg] = (val & 0xfffffffffULL);
1880 break;
1881 case 1: /* Breakpoint Mask */
1882 env->mmubpregs[reg] = (val & 0xfffffffffULL);
1883 break;
1884 case 2: /* Breakpoint Control */
1885 env->mmubpregs[reg] = (val & 0x7fULL);
1886 break;
1887 case 3: /* Breakpoint Status */
1888 env->mmubpregs[reg] = (val & 0xfULL);
1889 break;
1890 }
1891 DPRINTF_MMU("write breakpoint reg[%d] 0x%016x\n", reg,
1892 env->mmuregs[reg]);
1893 }
1894 break;
1895 case 8: /* User code access, XXX */
1896 case 9: /* Supervisor code access, XXX */
1897 default:
1898 do_unassigned_access(addr, 1, 0, asi, size);
1899 break;
1900 }
1901 #ifdef DEBUG_ASI
1902 dump_asi("write", addr, asi, size, val);
1903 #endif
1904 }
1905
1906 #endif /* CONFIG_USER_ONLY */
1907 #else /* TARGET_SPARC64 */
1908
1909 #ifdef CONFIG_USER_ONLY
1910 uint64_t helper_ld_asi(target_ulong addr, int asi, int size, int sign)
1911 {
1912 uint64_t ret = 0;
1913 #if defined(DEBUG_ASI)
1914 target_ulong last_addr = addr;
1915 #endif
1916
1917 if (asi < 0x80)
1918 raise_exception(TT_PRIV_ACT);
1919
1920 helper_check_align(addr, size - 1);
1921 address_mask(env, &addr);
1922
1923 switch (asi) {
1924 case 0x82: // Primary no-fault
1925 case 0x8a: // Primary no-fault LE
1926 if (page_check_range(addr, size, PAGE_READ) == -1) {
1927 #ifdef DEBUG_ASI
1928 dump_asi("read ", last_addr, asi, size, ret);
1929 #endif
1930 return 0;
1931 }
1932 // Fall through
1933 case 0x80: // Primary
1934 case 0x88: // Primary LE
1935 {
1936 switch(size) {
1937 case 1:
1938 ret = ldub_raw(addr);
1939 break;
1940 case 2:
1941 ret = lduw_raw(addr);
1942 break;
1943 case 4:
1944 ret = ldl_raw(addr);
1945 break;
1946 default:
1947 case 8:
1948 ret = ldq_raw(addr);
1949 break;
1950 }
1951 }
1952 break;
1953 case 0x83: // Secondary no-fault
1954 case 0x8b: // Secondary no-fault LE
1955 if (page_check_range(addr, size, PAGE_READ) == -1) {
1956 #ifdef DEBUG_ASI
1957 dump_asi("read ", last_addr, asi, size, ret);
1958 #endif
1959 return 0;
1960 }
1961 // Fall through
1962 case 0x81: // Secondary
1963 case 0x89: // Secondary LE
1964 // XXX
1965 break;
1966 default:
1967 break;
1968 }
1969
1970 /* Convert from little endian */
1971 switch (asi) {
1972 case 0x88: // Primary LE
1973 case 0x89: // Secondary LE
1974 case 0x8a: // Primary no-fault LE
1975 case 0x8b: // Secondary no-fault LE
1976 switch(size) {
1977 case 2:
1978 ret = bswap16(ret);
1979 break;
1980 case 4:
1981 ret = bswap32(ret);
1982 break;
1983 case 8:
1984 ret = bswap64(ret);
1985 break;
1986 default:
1987 break;
1988 }
1989 default:
1990 break;
1991 }
1992
1993 /* Convert to signed number */
1994 if (sign) {
1995 switch(size) {
1996 case 1:
1997 ret = (int8_t) ret;
1998 break;
1999 case 2:
2000 ret = (int16_t) ret;
2001 break;
2002 case 4:
2003 ret = (int32_t) ret;
2004 break;
2005 default:
2006 break;
2007 }
2008 }
2009 #ifdef DEBUG_ASI
2010 dump_asi("read ", last_addr, asi, size, ret);
2011 #endif
2012 return ret;
2013 }
2014
2015 void helper_st_asi(target_ulong addr, target_ulong val, int asi, int size)
2016 {
2017 #ifdef DEBUG_ASI
2018 dump_asi("write", addr, asi, size, val);
2019 #endif
2020 if (asi < 0x80)
2021 raise_exception(TT_PRIV_ACT);
2022
2023 helper_check_align(addr, size - 1);
2024 address_mask(env, &addr);
2025
2026 /* Convert to little endian */
2027 switch (asi) {
2028 case 0x88: // Primary LE
2029 case 0x89: // Secondary LE
2030 switch(size) {
2031 case 2:
2032 val = bswap16(val);
2033 break;
2034 case 4:
2035 val = bswap32(val);
2036 break;
2037 case 8:
2038 val = bswap64(val);
2039 break;
2040 default:
2041 break;
2042 }
2043 default:
2044 break;
2045 }
2046
2047 switch(asi) {
2048 case 0x80: // Primary
2049 case 0x88: // Primary LE
2050 {
2051 switch(size) {
2052 case 1:
2053 stb_raw(addr, val);
2054 break;
2055 case 2:
2056 stw_raw(addr, val);
2057 break;
2058 case 4:
2059 stl_raw(addr, val);
2060 break;
2061 case 8:
2062 default:
2063 stq_raw(addr, val);
2064 break;
2065 }
2066 }
2067 break;
2068 case 0x81: // Secondary
2069 case 0x89: // Secondary LE
2070 // XXX
2071 return;
2072
2073 case 0x82: // Primary no-fault, RO
2074 case 0x83: // Secondary no-fault, RO
2075 case 0x8a: // Primary no-fault LE, RO
2076 case 0x8b: // Secondary no-fault LE, RO
2077 default:
2078 do_unassigned_access(addr, 1, 0, 1, size);
2079 return;
2080 }
2081 }
2082
2083 #else /* CONFIG_USER_ONLY */
2084
2085 uint64_t helper_ld_asi(target_ulong addr, int asi, int size, int sign)
2086 {
2087 uint64_t ret = 0;
2088 #if defined(DEBUG_ASI)
2089 target_ulong last_addr = addr;
2090 #endif
2091
2092 asi &= 0xff;
2093
2094 if ((asi < 0x80 && (env->pstate & PS_PRIV) == 0)
2095 || ((env->def->features & CPU_FEATURE_HYPV)
2096 && asi >= 0x30 && asi < 0x80
2097 && !(env->hpstate & HS_PRIV)))
2098 raise_exception(TT_PRIV_ACT);
2099
2100 helper_check_align(addr, size - 1);
2101 switch (asi) {
2102 case 0x82: // Primary no-fault
2103 case 0x8a: // Primary no-fault LE
2104 if (cpu_get_phys_page_debug(env, addr) == -1ULL) {
2105 #ifdef DEBUG_ASI
2106 dump_asi("read ", last_addr, asi, size, ret);
2107 #endif
2108 return 0;
2109 }
2110 // Fall through
2111 case 0x10: // As if user primary
2112 case 0x18: // As if user primary LE
2113 case 0x80: // Primary
2114 case 0x88: // Primary LE
2115 case 0xe2: // UA2007 Primary block init
2116 case 0xe3: // UA2007 Secondary block init
2117 if ((asi & 0x80) && (env->pstate & PS_PRIV)) {
2118 if ((env->def->features & CPU_FEATURE_HYPV)
2119 && env->hpstate & HS_PRIV) {
2120 switch(size) {
2121 case 1:
2122 ret = ldub_hypv(addr);
2123 break;
2124 case 2:
2125 ret = lduw_hypv(addr);
2126 break;
2127 case 4:
2128 ret = ldl_hypv(addr);
2129 break;
2130 default:
2131 case 8:
2132 ret = ldq_hypv(addr);
2133 break;
2134 }
2135 } else {
2136 switch(size) {
2137 case 1:
2138 ret = ldub_kernel(addr);
2139 break;
2140 case 2:
2141 ret = lduw_kernel(addr);
2142 break;
2143 case 4:
2144 ret = ldl_kernel(addr);
2145 break;
2146 default:
2147 case 8:
2148 ret = ldq_kernel(addr);
2149 break;
2150 }
2151 }
2152 } else {
2153 switch(size) {
2154 case 1:
2155 ret = ldub_user(addr);
2156 break;
2157 case 2:
2158 ret = lduw_user(addr);
2159 break;
2160 case 4:
2161 ret = ldl_user(addr);
2162 break;
2163 default:
2164 case 8:
2165 ret = ldq_user(addr);
2166 break;
2167 }
2168 }
2169 break;
2170 case 0x14: // Bypass
2171 case 0x15: // Bypass, non-cacheable
2172 case 0x1c: // Bypass LE
2173 case 0x1d: // Bypass, non-cacheable LE
2174 {
2175 switch(size) {
2176 case 1:
2177 ret = ldub_phys(addr);
2178 break;
2179 case 2:
2180 ret = lduw_phys(addr);
2181 break;
2182 case 4:
2183 ret = ldl_phys(addr);
2184 break;
2185 default:
2186 case 8:
2187 ret = ldq_phys(addr);
2188 break;
2189 }
2190 break;
2191 }
2192 case 0x24: // Nucleus quad LDD 128 bit atomic
2193 case 0x2c: // Nucleus quad LDD 128 bit atomic LE
2194 // Only ldda allowed
2195 raise_exception(TT_ILL_INSN);
2196 return 0;
2197 case 0x83: // Secondary no-fault
2198 case 0x8b: // Secondary no-fault LE
2199 if (cpu_get_phys_page_debug(env, addr) == -1ULL) {
2200 #ifdef DEBUG_ASI
2201 dump_asi("read ", last_addr, asi, size, ret);
2202 #endif
2203 return 0;
2204 }
2205 // Fall through
2206 case 0x04: // Nucleus
2207 case 0x0c: // Nucleus Little Endian (LE)
2208 case 0x11: // As if user secondary
2209 case 0x19: // As if user secondary LE
2210 case 0x4a: // UPA config
2211 case 0x81: // Secondary
2212 case 0x89: // Secondary LE
2213 // XXX
2214 break;
2215 case 0x45: // LSU
2216 ret = env->lsu;
2217 break;
2218 case 0x50: // I-MMU regs
2219 {
2220 int reg = (addr >> 3) & 0xf;
2221
2222 if (reg == 0) {
2223 // I-TSB Tag Target register
2224 ret = ultrasparc_tag_target(env->immu.tag_access);
2225 } else {
2226 ret = env->immuregs[reg];
2227 }
2228
2229 break;
2230 }
2231 case 0x51: // I-MMU 8k TSB pointer
2232 {
2233 // env->immuregs[5] holds I-MMU TSB register value
2234 // env->immuregs[6] holds I-MMU Tag Access register value
2235 ret = ultrasparc_tsb_pointer(env->immu.tsb, env->immu.tag_access,
2236 8*1024);
2237 break;
2238 }
2239 case 0x52: // I-MMU 64k TSB pointer
2240 {
2241 // env->immuregs[5] holds I-MMU TSB register value
2242 // env->immuregs[6] holds I-MMU Tag Access register value
2243 ret = ultrasparc_tsb_pointer(env->immu.tsb, env->immu.tag_access,
2244 64*1024);
2245 break;
2246 }
2247 case 0x55: // I-MMU data access
2248 {
2249 int reg = (addr >> 3) & 0x3f;
2250
2251 ret = env->itlb[reg].tte;
2252 break;
2253 }
2254 case 0x56: // I-MMU tag read
2255 {
2256 int reg = (addr >> 3) & 0x3f;
2257
2258 ret = env->itlb[reg].tag;
2259 break;
2260 }
2261 case 0x58: // D-MMU regs
2262 {
2263 int reg = (addr >> 3) & 0xf;
2264
2265 if (reg == 0) {
2266 // D-TSB Tag Target register
2267 ret = ultrasparc_tag_target(env->dmmu.tag_access);
2268 } else {
2269 ret = env->dmmuregs[reg];
2270 }
2271 break;
2272 }
2273 case 0x59: // D-MMU 8k TSB pointer
2274 {
2275 // env->dmmuregs[5] holds D-MMU TSB register value
2276 // env->dmmuregs[6] holds D-MMU Tag Access register value
2277 ret = ultrasparc_tsb_pointer(env->dmmu.tsb, env->dmmu.tag_access,
2278 8*1024);
2279 break;
2280 }
2281 case 0x5a: // D-MMU 64k TSB pointer
2282 {
2283 // env->dmmuregs[5] holds D-MMU TSB register value
2284 // env->dmmuregs[6] holds D-MMU Tag Access register value
2285 ret = ultrasparc_tsb_pointer(env->dmmu.tsb, env->dmmu.tag_access,
2286 64*1024);
2287 break;
2288 }
2289 case 0x5d: // D-MMU data access
2290 {
2291 int reg = (addr >> 3) & 0x3f;
2292
2293 ret = env->dtlb[reg].tte;
2294 break;
2295 }
2296 case 0x5e: // D-MMU tag read
2297 {
2298 int reg = (addr >> 3) & 0x3f;
2299
2300 ret = env->dtlb[reg].tag;
2301 break;
2302 }
2303 case 0x46: // D-cache data
2304 case 0x47: // D-cache tag access
2305 case 0x4b: // E-cache error enable
2306 case 0x4c: // E-cache asynchronous fault status
2307 case 0x4d: // E-cache asynchronous fault address
2308 case 0x4e: // E-cache tag data
2309 case 0x66: // I-cache instruction access
2310 case 0x67: // I-cache tag access
2311 case 0x6e: // I-cache predecode
2312 case 0x6f: // I-cache LRU etc.
2313 case 0x76: // E-cache tag
2314 case 0x7e: // E-cache tag
2315 break;
2316 case 0x5b: // D-MMU data pointer
2317 case 0x48: // Interrupt dispatch, RO
2318 case 0x49: // Interrupt data receive
2319 case 0x7f: // Incoming interrupt vector, RO
2320 // XXX
2321 break;
2322 case 0x54: // I-MMU data in, WO
2323 case 0x57: // I-MMU demap, WO
2324 case 0x5c: // D-MMU data in, WO
2325 case 0x5f: // D-MMU demap, WO
2326 case 0x77: // Interrupt vector, WO
2327 default:
2328 do_unassigned_access(addr, 0, 0, 1, size);
2329 ret = 0;
2330 break;
2331 }
2332
2333 /* Convert from little endian */
2334 switch (asi) {
2335 case 0x0c: // Nucleus Little Endian (LE)
2336 case 0x18: // As if user primary LE
2337 case 0x19: // As if user secondary LE
2338 case 0x1c: // Bypass LE
2339 case 0x1d: // Bypass, non-cacheable LE
2340 case 0x88: // Primary LE
2341 case 0x89: // Secondary LE
2342 case 0x8a: // Primary no-fault LE
2343 case 0x8b: // Secondary no-fault LE
2344 switch(size) {
2345 case 2:
2346 ret = bswap16(ret);
2347 break;
2348 case 4:
2349 ret = bswap32(ret);
2350 break;
2351 case 8:
2352 ret = bswap64(ret);
2353 break;
2354 default:
2355 break;
2356 }
2357 default:
2358 break;
2359 }
2360
2361 /* Convert to signed number */
2362 if (sign) {
2363 switch(size) {
2364 case 1:
2365 ret = (int8_t) ret;
2366 break;
2367 case 2:
2368 ret = (int16_t) ret;
2369 break;
2370 case 4:
2371 ret = (int32_t) ret;
2372 break;
2373 default:
2374 break;
2375 }
2376 }
2377 #ifdef DEBUG_ASI
2378 dump_asi("read ", last_addr, asi, size, ret);
2379 #endif
2380 return ret;
2381 }
2382
2383 void helper_st_asi(target_ulong addr, target_ulong val, int asi, int size)
2384 {
2385 #ifdef DEBUG_ASI
2386 dump_asi("write", addr, asi, size, val);
2387 #endif
2388
2389 asi &= 0xff;
2390
2391 if ((asi < 0x80 && (env->pstate & PS_PRIV) == 0)
2392 || ((env->def->features & CPU_FEATURE_HYPV)
2393 && asi >= 0x30 && asi < 0x80
2394 && !(env->hpstate & HS_PRIV)))
2395 raise_exception(TT_PRIV_ACT);
2396
2397 helper_check_align(addr, size - 1);
2398 /* Convert to little endian */
2399 switch (asi) {
2400 case 0x0c: // Nucleus Little Endian (LE)
2401 case 0x18: // As if user primary LE
2402 case 0x19: // As if user secondary LE
2403 case 0x1c: // Bypass LE
2404 case 0x1d: // Bypass, non-cacheable LE
2405 case 0x88: // Primary LE
2406 case 0x89: // Secondary LE
2407 switch(size) {
2408 case 2:
2409 val = bswap16(val);
2410 break;
2411 case 4:
2412 val = bswap32(val);
2413 break;
2414 case 8:
2415 val = bswap64(val);
2416 break;
2417 default:
2418 break;
2419 }
2420 default:
2421 break;
2422 }
2423
2424 switch(asi) {
2425 case 0x10: // As if user primary
2426 case 0x18: // As if user primary LE
2427 case 0x80: // Primary
2428 case 0x88: // Primary LE
2429 case 0xe2: // UA2007 Primary block init
2430 case 0xe3: // UA2007 Secondary block init
2431 if ((asi & 0x80) && (env->pstate & PS_PRIV)) {
2432 if ((env->def->features & CPU_FEATURE_HYPV)
2433 && env->hpstate & HS_PRIV) {
2434 switch(size) {
2435 case 1:
2436 stb_hypv(addr, val);
2437 break;
2438 case 2:
2439 stw_hypv(addr, val);
2440 break;
2441 case 4:
2442 stl_hypv(addr, val);
2443 break;
2444 case 8:
2445 default:
2446 stq_hypv(addr, val);
2447 break;
2448 }
2449 } else {
2450 switch(size) {
2451 case 1:
2452 stb_kernel(addr, val);
2453 break;
2454 case 2:
2455 stw_kernel(addr, val);
2456 break;
2457 case 4:
2458 stl_kernel(addr, val);
2459 break;
2460 case 8:
2461 default:
2462 stq_kernel(addr, val);
2463 break;
2464 }
2465 }
2466 } else {
2467 switch(size) {
2468 case 1:
2469 stb_user(addr, val);
2470 break;
2471 case 2:
2472 stw_user(addr, val);
2473 break;
2474 case 4:
2475 stl_user(addr, val);
2476 break;
2477 case 8:
2478 default:
2479 stq_user(addr, val);
2480 break;
2481 }
2482 }
2483 break;
2484 case 0x14: // Bypass
2485 case 0x15: // Bypass, non-cacheable
2486 case 0x1c: // Bypass LE
2487 case 0x1d: // Bypass, non-cacheable LE
2488 {
2489 switch(size) {
2490 case 1:
2491 stb_phys(addr, val);
2492 break;
2493 case 2:
2494 stw_phys(addr, val);
2495 break;
2496 case 4:
2497 stl_phys(addr, val);
2498 break;
2499 case 8:
2500 default:
2501 stq_phys(addr, val);
2502 break;
2503 }
2504 }
2505 return;
2506 case 0x24: // Nucleus quad LDD 128 bit atomic
2507 case 0x2c: // Nucleus quad LDD 128 bit atomic LE
2508 // Only ldda allowed
2509 raise_exception(TT_ILL_INSN);
2510 return;
2511 case 0x04: // Nucleus
2512 case 0x0c: // Nucleus Little Endian (LE)
2513 case 0x11: // As if user secondary
2514 case 0x19: // As if user secondary LE
2515 case 0x4a: // UPA config
2516 case 0x81: // Secondary
2517 case 0x89: // Secondary LE
2518 // XXX
2519 return;
2520 case 0x45: // LSU
2521 {
2522 uint64_t oldreg;
2523
2524 oldreg = env->lsu;
2525 env->lsu = val & (DMMU_E | IMMU_E);
2526 // Mappings generated during D/I MMU disabled mode are
2527 // invalid in normal mode
2528 if (oldreg != env->lsu) {
2529 DPRINTF_MMU("LSU change: 0x%" PRIx64 " -> 0x%" PRIx64 "\n",
2530 oldreg, env->lsu);
2531 #ifdef DEBUG_MMU
2532 dump_mmu(env);
2533 #endif
2534 tlb_flush(env, 1);
2535 }
2536 return;
2537 }
2538 case 0x50: // I-MMU regs
2539 {
2540 int reg = (addr >> 3) & 0xf;
2541 uint64_t oldreg;
2542
2543 oldreg = env->immuregs[reg];
2544 switch(reg) {
2545 case 0: // RO
2546 return;
2547 case 1: // Not in I-MMU
2548 case 2:
2549 return;
2550 case 3: // SFSR
2551 if ((val & 1) == 0)
2552 val = 0; // Clear SFSR
2553 env->immu.sfsr = val;
2554 break;
2555 case 4: // RO
2556 return;
2557 case 5: // TSB access
2558 DPRINTF_MMU("immu TSB write: 0x%016" PRIx64 " -> 0x%016"
2559 PRIx64 "\n", env->immu.tsb, val);
2560 env->immu.tsb = val;
2561 break;
2562 case 6: // Tag access
2563 env->immu.tag_access = val;
2564 break;
2565 case 7:
2566 case 8:
2567 return;
2568 default:
2569 break;
2570 }
2571
2572 if (oldreg != env->immuregs[reg]) {
2573 DPRINTF_MMU("immu change reg[%d]: 0x%016" PRIx64 " -> 0x%016"
2574 PRIx64 "\n", reg, oldreg, env->immuregs[reg]);
2575 }
2576 #ifdef DEBUG_MMU
2577 dump_mmu(env);
2578 #endif
2579 return;
2580 }
2581 case 0x54: // I-MMU data in
2582 replace_tlb_1bit_lru(env->itlb, env->immu.tag_access, val, "immu", env);
2583 return;
2584 case 0x55: // I-MMU data access
2585 {
2586 // TODO: auto demap
2587
2588 unsigned int i = (addr >> 3) & 0x3f;
2589
2590 replace_tlb_entry(&env->itlb[i], env->immu.tag_access, val, env);
2591
2592 #ifdef DEBUG_MMU
2593 DPRINTF_MMU("immu data access replaced entry [%i]\n", i);
2594 dump_mmu(env);
2595 #endif
2596 return;
2597 }
2598 case 0x57: // I-MMU demap
2599 demap_tlb(env->itlb, val, "immu", env);
2600 return;
2601 case 0x58: // D-MMU regs
2602 {
2603 int reg = (addr >> 3) & 0xf;
2604 uint64_t oldreg;
2605
2606 oldreg = env->dmmuregs[reg];
2607 switch(reg) {
2608 case 0: // RO
2609 case 4:
2610 return;
2611 case 3: // SFSR
2612 if ((val & 1) == 0) {
2613 val = 0; // Clear SFSR, Fault address
2614 env->dmmu.sfar = 0;
2615 }
2616 env->dmmu.sfsr = val;
2617 break;
2618 case 1: // Primary context
2619 env->dmmu.mmu_primary_context = val;
2620 break;
2621 case 2: // Secondary context
2622 env->dmmu.mmu_secondary_context = val;
2623 break;
2624 case 5: // TSB access
2625 DPRINTF_MMU("dmmu TSB write: 0x%016" PRIx64 " -> 0x%016"
2626 PRIx64 "\n", env->dmmu.tsb, val);
2627 env->dmmu.tsb = val;
2628 break;
2629 case 6: // Tag access
2630 env->dmmu.tag_access = val;
2631 break;
2632 case 7: // Virtual Watchpoint
2633 case 8: // Physical Watchpoint
2634 default:
2635 env->dmmuregs[reg] = val;
2636 break;
2637 }
2638
2639 if (oldreg != env->dmmuregs[reg]) {
2640 DPRINTF_MMU("dmmu change reg[%d]: 0x%016" PRIx64 " -> 0x%016"
2641 PRIx64 "\n", reg, oldreg, env->dmmuregs[reg]);
2642 }
2643 #ifdef DEBUG_MMU
2644 dump_mmu(env);
2645 #endif
2646 return;
2647 }
2648 case 0x5c: // D-MMU data in
2649 replace_tlb_1bit_lru(env->dtlb, env->dmmu.tag_access, val, "dmmu", env);
2650 return;
2651 case 0x5d: // D-MMU data access
2652 {
2653 unsigned int i = (addr >> 3) & 0x3f;
2654
2655 replace_tlb_entry(&env->dtlb[i], env->dmmu.tag_access, val, env);
2656
2657 #ifdef DEBUG_MMU
2658 DPRINTF_MMU("dmmu data access replaced entry [%i]\n", i);
2659 dump_mmu(env);
2660 #endif
2661 return;
2662 }
2663 case 0x5f: // D-MMU demap
2664 demap_tlb(env->dtlb, val, "dmmu", env);
2665 return;
2666 case 0x49: // Interrupt data receive
2667 // XXX
2668 return;
2669 case 0x46: // D-cache data
2670 case 0x47: // D-cache tag access
2671 case 0x4b: // E-cache error enable
2672 case 0x4c: // E-cache asynchronous fault status
2673 case 0x4d: // E-cache asynchronous fault address
2674 case 0x4e: // E-cache tag data
2675 case 0x66: // I-cache instruction access
2676 case 0x67: // I-cache tag access
2677 case 0x6e: // I-cache predecode
2678 case 0x6f: // I-cache LRU etc.
2679 case 0x76: // E-cache tag
2680 case 0x7e: // E-cache tag
2681 return;
2682 case 0x51: // I-MMU 8k TSB pointer, RO
2683 case 0x52: // I-MMU 64k TSB pointer, RO
2684 case 0x56: // I-MMU tag read, RO
2685 case 0x59: // D-MMU 8k TSB pointer, RO
2686 case 0x5a: // D-MMU 64k TSB pointer, RO
2687 case 0x5b: // D-MMU data pointer, RO
2688 case 0x5e: // D-MMU tag read, RO
2689 case 0x48: // Interrupt dispatch, RO
2690 case 0x7f: // Incoming interrupt vector, RO
2691 case 0x82: // Primary no-fault, RO
2692 case 0x83: // Secondary no-fault, RO
2693 case 0x8a: // Primary no-fault LE, RO
2694 case 0x8b: // Secondary no-fault LE, RO
2695 default:
2696 do_unassigned_access(addr, 1, 0, 1, size);
2697 return;
2698 }
2699 }
2700 #endif /* CONFIG_USER_ONLY */
2701
2702 void helper_ldda_asi(target_ulong addr, int asi, int rd)
2703 {
2704 if ((asi < 0x80 && (env->pstate & PS_PRIV) == 0)
2705 || ((env->def->features & CPU_FEATURE_HYPV)
2706 && asi >= 0x30 && asi < 0x80
2707 && !(env->hpstate & HS_PRIV)))
2708 raise_exception(TT_PRIV_ACT);
2709
2710 switch (asi) {
2711 case 0x24: // Nucleus quad LDD 128 bit atomic
2712 case 0x2c: // Nucleus quad LDD 128 bit atomic LE
2713 helper_check_align(addr, 0xf);
2714 if (rd == 0) {
2715 env->gregs[1] = ldq_kernel(addr + 8);
2716 if (asi == 0x2c)
2717 bswap64s(&env->gregs[1]);
2718 } else if (rd < 8) {
2719 env->gregs[rd] = ldq_kernel(addr);
2720 env->gregs[rd + 1] = ldq_kernel(addr + 8);
2721 if (asi == 0x2c) {
2722 bswap64s(&env->gregs[rd]);
2723 bswap64s(&env->gregs[rd + 1]);
2724 }
2725 } else {
2726 env->regwptr[rd] = ldq_kernel(addr);
2727 env->regwptr[rd + 1] = ldq_kernel(addr + 8);
2728 if (asi == 0x2c) {
2729 bswap64s(&env->regwptr[rd]);
2730 bswap64s(&env->regwptr[rd + 1]);
2731 }
2732 }
2733 break;
2734 default:
2735 helper_check_align(addr, 0x3);
2736 if (rd == 0)
2737 env->gregs[1] = helper_ld_asi(addr + 4, asi, 4, 0);
2738 else if (rd < 8) {
2739 env->gregs[rd] = helper_ld_asi(addr, asi, 4, 0);
2740 env->gregs[rd + 1] = helper_ld_asi(addr + 4, asi, 4, 0);
2741 } else {
2742 env->regwptr[rd] = helper_ld_asi(addr, asi, 4, 0);
2743 env->regwptr[rd + 1] = helper_ld_asi(addr + 4, asi, 4, 0);
2744 }
2745 break;
2746 }
2747 }
2748
2749 void helper_ldf_asi(target_ulong addr, int asi, int size, int rd)
2750 {
2751 unsigned int i;
2752 target_ulong val;
2753
2754 helper_check_align(addr, 3);
2755 switch (asi) {
2756 case 0xf0: // Block load primary
2757 case 0xf1: // Block load secondary
2758 case 0xf8: // Block load primary LE
2759 case 0xf9: // Block load secondary LE
2760 if (rd & 7) {
2761 raise_exception(TT_ILL_INSN);
2762 return;
2763 }
2764 helper_check_align(addr, 0x3f);
2765 for (i = 0; i < 16; i++) {
2766 *(uint32_t *)&env->fpr[rd++] = helper_ld_asi(addr, asi & 0x8f, 4,
2767 0);
2768 addr += 4;
2769 }
2770
2771 return;
2772 default:
2773 break;
2774 }
2775
2776 val = helper_ld_asi(addr, asi, size, 0);
2777 switch(size) {
2778 default:
2779 case 4:
2780 *((uint32_t *)&env->fpr[rd]) = val;
2781 break;
2782 case 8:
2783 *((int64_t *)&DT0) = val;
2784 break;
2785 case 16:
2786 // XXX
2787 break;
2788 }
2789 }
2790
2791 void helper_stf_asi(target_ulong addr, int asi, int size, int rd)
2792 {
2793 unsigned int i;
2794 target_ulong val = 0;
2795
2796 helper_check_align(addr, 3);
2797 switch (asi) {
2798 case 0xe0: // UA2007 Block commit store primary (cache flush)
2799 case 0xe1: // UA2007 Block commit store secondary (cache flush)
2800 case 0xf0: // Block store primary
2801 case 0xf1: // Block store secondary
2802 case 0xf8: // Block store primary LE
2803 case 0xf9: // Block store secondary LE
2804 if (rd & 7) {
2805 raise_exception(TT_ILL_INSN);
2806 return;
2807 }
2808 helper_check_align(addr, 0x3f);
2809 for (i = 0; i < 16; i++) {
2810 val = *(uint32_t *)&env->fpr[rd++];
2811 helper_st_asi(addr, val, asi & 0x8f, 4);
2812 addr += 4;
2813 }
2814
2815 return;
2816 default:
2817 break;
2818 }
2819
2820 switch(size) {
2821 default:
2822 case 4:
2823 val = *((uint32_t *)&env->fpr[rd]);
2824 break;
2825 case 8:
2826 val = *((int64_t *)&DT0);
2827 break;
2828 case 16:
2829 // XXX
2830 break;
2831 }
2832 helper_st_asi(addr, val, asi, size);
2833 }
2834
2835 target_ulong helper_cas_asi(target_ulong addr, target_ulong val1,
2836 target_ulong val2, uint32_t asi)
2837 {
2838 target_ulong ret;
2839
2840 val2 &= 0xffffffffUL;
2841 ret = helper_ld_asi(addr, asi, 4, 0);
2842 ret &= 0xffffffffUL;
2843 if (val2 == ret)
2844 helper_st_asi(addr, val1 & 0xffffffffUL, asi, 4);
2845 return ret;
2846 }
2847
2848 target_ulong helper_casx_asi(target_ulong addr, target_ulong val1,
2849 target_ulong val2, uint32_t asi)
2850 {
2851 target_ulong ret;
2852
2853 ret = helper_ld_asi(addr, asi, 8, 0);
2854 if (val2 == ret)
2855 helper_st_asi(addr, val1, asi, 8);
2856 return ret;
2857 }
2858 #endif /* TARGET_SPARC64 */
2859
2860 #ifndef TARGET_SPARC64
2861 void helper_rett(void)
2862 {
2863 unsigned int cwp;
2864
2865 if (env->psret == 1)
2866 raise_exception(TT_ILL_INSN);
2867
2868 env->psret = 1;
2869 cwp = cpu_cwp_inc(env, env->cwp + 1) ;
2870 if (env->wim & (1 << cwp)) {
2871 raise_exception(TT_WIN_UNF);
2872 }
2873 set_cwp(cwp);
2874 env->psrs = env->psrps;
2875 }
2876 #endif
2877
2878 target_ulong helper_udiv(target_ulong a, target_ulong b)
2879 {
2880 uint64_t x0;
2881 uint32_t x1;
2882
2883 x0 = (a & 0xffffffff) | ((int64_t) (env->y) << 32);
2884 x1 = b;
2885
2886 if (x1 == 0) {
2887 raise_exception(TT_DIV_ZERO);
2888 }
2889
2890 x0 = x0 / x1;
2891 if (x0 > 0xffffffff) {
2892 env->cc_src2 = 1;
2893 return 0xffffffff;
2894 } else {
2895 env->cc_src2 = 0;
2896 return x0;
2897 }
2898 }
2899
2900 target_ulong helper_sdiv(target_ulong a, target_ulong b)
2901 {
2902 int64_t x0;
2903 int32_t x1;
2904
2905 x0 = (a & 0xffffffff) | ((int64_t) (env->y) << 32);
2906 x1 = b;
2907
2908 if (x1 == 0) {
2909 raise_exception(TT_DIV_ZERO);
2910 }
2911
2912 x0 = x0 / x1;
2913 if ((int32_t) x0 != x0) {
2914 env->cc_src2 = 1;
2915 return x0 < 0? 0x80000000: 0x7fffffff;
2916 } else {
2917 env->cc_src2 = 0;
2918 return x0;
2919 }
2920 }
2921
2922 void helper_stdf(target_ulong addr, int mem_idx)
2923 {
2924 helper_check_align(addr, 7);
2925 #if !defined(CONFIG_USER_ONLY)
2926 switch (mem_idx) {
2927 case 0:
2928 stfq_user(addr, DT0);
2929 break;
2930 case 1:
2931 stfq_kernel(addr, DT0);
2932 break;
2933 #ifdef TARGET_SPARC64
2934 case 2:
2935 stfq_hypv(addr, DT0);
2936 break;
2937 #endif
2938 default:
2939 break;
2940 }
2941 #else
2942 address_mask(env, &addr);
2943 stfq_raw(addr, DT0);
2944 #endif
2945 }
2946
2947 void helper_lddf(target_ulong addr, int mem_idx)
2948 {
2949 helper_check_align(addr, 7);
2950 #if !defined(CONFIG_USER_ONLY)
2951 switch (mem_idx) {
2952 case 0:
2953 DT0 = ldfq_user(addr);
2954 break;
2955 case 1:
2956 DT0 = ldfq_kernel(addr);
2957 break;
2958 #ifdef TARGET_SPARC64
2959 case 2:
2960 DT0 = ldfq_hypv(addr);
2961 break;
2962 #endif
2963 default:
2964 break;
2965 }
2966 #else
2967 address_mask(env, &addr);
2968 DT0 = ldfq_raw(addr);
2969 #endif
2970 }
2971
2972 void helper_ldqf(target_ulong addr, int mem_idx)
2973 {
2974 // XXX add 128 bit load
2975 CPU_QuadU u;
2976
2977 helper_check_align(addr, 7);
2978 #if !defined(CONFIG_USER_ONLY)
2979 switch (mem_idx) {
2980 case 0:
2981 u.ll.upper = ldq_user(addr);
2982 u.ll.lower = ldq_user(addr + 8);
2983 QT0 = u.q;
2984 break;
2985 case 1:
2986 u.ll.upper = ldq_kernel(addr);
2987 u.ll.lower = ldq_kernel(addr + 8);
2988 QT0 = u.q;
2989 break;
2990 #ifdef TARGET_SPARC64
2991 case 2:
2992 u.ll.upper = ldq_hypv(addr);
2993 u.ll.lower = ldq_hypv(addr + 8);
2994 QT0 = u.q;
2995 break;
2996 #endif
2997 default:
2998 break;
2999 }
3000 #else
3001 address_mask(env, &addr);
3002 u.ll.upper = ldq_raw(addr);
3003 u.ll.lower = ldq_raw((addr + 8) & 0xffffffffULL);
3004 QT0 = u.q;
3005 #endif
3006 }
3007
3008 void helper_stqf(target_ulong addr, int mem_idx)
3009 {
3010 // XXX add 128 bit store
3011 CPU_QuadU u;
3012
3013 helper_check_align(addr, 7);
3014 #if !defined(CONFIG_USER_ONLY)
3015 switch (mem_idx) {
3016 case 0:
3017 u.q = QT0;
3018 stq_user(addr, u.ll.upper);
3019 stq_user(addr + 8, u.ll.lower);
3020 break;
3021 case 1:
3022 u.q = QT0;
3023 stq_kernel(addr, u.ll.upper);
3024 stq_kernel(addr + 8, u.ll.lower);
3025 break;
3026 #ifdef TARGET_SPARC64
3027 case 2:
3028 u.q = QT0;
3029 stq_hypv(addr, u.ll.upper);
3030 stq_hypv(addr + 8, u.ll.lower);
3031 break;
3032 #endif
3033 default:
3034 break;
3035 }
3036 #else
3037 u.q = QT0;
3038 address_mask(env, &addr);
3039 stq_raw(addr, u.ll.upper);
3040 stq_raw((addr + 8) & 0xffffffffULL, u.ll.lower);
3041 #endif
3042 }
3043
3044 static inline void set_fsr(void)
3045 {
3046 int rnd_mode;
3047
3048 switch (env->fsr & FSR_RD_MASK) {
3049 case FSR_RD_NEAREST:
3050 rnd_mode = float_round_nearest_even;
3051 break;
3052 default:
3053 case FSR_RD_ZERO:
3054 rnd_mode = float_round_to_zero;
3055 break;
3056 case FSR_RD_POS:
3057 rnd_mode = float_round_up;
3058 break;
3059 case FSR_RD_NEG:
3060 rnd_mode = float_round_down;
3061 break;
3062 }
3063 set_float_rounding_mode(rnd_mode, &env->fp_status);
3064 }
3065
3066 void helper_ldfsr(uint32_t new_fsr)
3067 {
3068 env->fsr = (new_fsr & FSR_LDFSR_MASK) | (env->fsr & FSR_LDFSR_OLDMASK);
3069 set_fsr();
3070 }
3071
3072 #ifdef TARGET_SPARC64
3073 void helper_ldxfsr(uint64_t new_fsr)
3074 {
3075 env->fsr = (new_fsr & FSR_LDXFSR_MASK) | (env->fsr & FSR_LDXFSR_OLDMASK);
3076 set_fsr();
3077 }
3078 #endif
3079
3080 void helper_debug(void)
3081 {
3082 env->exception_index = EXCP_DEBUG;
3083 cpu_loop_exit();
3084 }
3085
3086 #ifndef TARGET_SPARC64
3087 /* XXX: use another pointer for %iN registers to avoid slow wrapping
3088 handling ? */
3089 void helper_save(void)
3090 {
3091 uint32_t cwp;
3092
3093 cwp = cpu_cwp_dec(env, env->cwp - 1);
3094 if (env->wim & (1 << cwp)) {
3095 raise_exception(TT_WIN_OVF);
3096 }
3097 set_cwp(cwp);
3098 }
3099
3100 void helper_restore(void)
3101 {
3102 uint32_t cwp;
3103
3104 cwp = cpu_cwp_inc(env, env->cwp + 1);
3105 if (env->wim & (1 << cwp)) {
3106 raise_exception(TT_WIN_UNF);
3107 }
3108 set_cwp(cwp);
3109 }
3110
3111 void helper_wrpsr(target_ulong new_psr)
3112 {
3113 if ((new_psr & PSR_CWP) >= env->nwindows)
3114 raise_exception(TT_ILL_INSN);
3115 else
3116 PUT_PSR(env, new_psr);
3117 }
3118
3119 target_ulong helper_rdpsr(void)
3120 {
3121 return GET_PSR(env);
3122 }
3123
3124 #else
3125 /* XXX: use another pointer for %iN registers to avoid slow wrapping
3126 handling ? */
3127 void helper_save(void)
3128 {
3129 uint32_t cwp;
3130
3131 cwp = cpu_cwp_dec(env, env->cwp - 1);
3132 if (env->cansave == 0) {
3133 raise_exception(TT_SPILL | (env->otherwin != 0 ?
3134 (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
3135 ((env->wstate & 0x7) << 2)));
3136 } else {
3137 if (env->cleanwin - env->canrestore == 0) {
3138 // XXX Clean windows without trap
3139 raise_exception(TT_CLRWIN);
3140 } else {
3141 env->cansave--;
3142 env->canrestore++;
3143 set_cwp(cwp);
3144 }
3145 }
3146 }
3147
3148 void helper_restore(void)
3149 {
3150 uint32_t cwp;
3151
3152 cwp = cpu_cwp_inc(env, env->cwp + 1);
3153 if (env->canrestore == 0) {
3154 raise_exception(TT_FILL | (env->otherwin != 0 ?
3155 (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
3156 ((env->wstate & 0x7) << 2)));
3157 } else {
3158 env->cansave++;
3159 env->canrestore--;
3160 set_cwp(cwp);
3161 }
3162 }
3163
3164 void helper_flushw(void)
3165 {
3166 if (env->cansave != env->nwindows - 2) {
3167 raise_exception(TT_SPILL | (env->otherwin != 0 ?
3168 (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
3169 ((env->wstate & 0x7) << 2)));
3170 }
3171 }
3172
3173 void helper_saved(void)
3174 {
3175 env->cansave++;
3176 if (env->otherwin == 0)
3177 env->canrestore--;
3178 else
3179 env->otherwin--;
3180 }
3181
3182 void helper_restored(void)
3183 {
3184 env->canrestore++;
3185 if (env->cleanwin < env->nwindows - 1)
3186 env->cleanwin++;
3187 if (env->otherwin == 0)
3188 env->cansave--;
3189 else
3190 env->otherwin--;
3191 }
3192
3193 target_ulong helper_rdccr(void)
3194 {
3195 return GET_CCR(env);
3196 }
3197
3198 void helper_wrccr(target_ulong new_ccr)
3199 {
3200 PUT_CCR(env, new_ccr);
3201 }
3202
3203 // CWP handling is reversed in V9, but we still use the V8 register
3204 // order.
3205 target_ulong helper_rdcwp(void)
3206 {
3207 return GET_CWP64(env);
3208 }
3209
3210 void helper_wrcwp(target_ulong new_cwp)
3211 {
3212 PUT_CWP64(env, new_cwp);
3213 }
3214
3215 // This function uses non-native bit order
3216 #define GET_FIELD(X, FROM, TO) \
3217 ((X) >> (63 - (TO)) & ((1ULL << ((TO) - (FROM) + 1)) - 1))
3218
3219 // This function uses the order in the manuals, i.e. bit 0 is 2^0
3220 #define GET_FIELD_SP(X, FROM, TO) \
3221 GET_FIELD(X, 63 - (TO), 63 - (FROM))
3222
3223 target_ulong helper_array8(target_ulong pixel_addr, target_ulong cubesize)
3224 {
3225 return (GET_FIELD_SP(pixel_addr, 60, 63) << (17 + 2 * cubesize)) |
3226 (GET_FIELD_SP(pixel_addr, 39, 39 + cubesize - 1) << (17 + cubesize)) |
3227 (GET_FIELD_SP(pixel_addr, 17 + cubesize - 1, 17) << 17) |
3228 (GET_FIELD_SP(pixel_addr, 56, 59) << 13) |
3229 (GET_FIELD_SP(pixel_addr, 35, 38) << 9) |
3230 (GET_FIELD_SP(pixel_addr, 13, 16) << 5) |
3231 (((pixel_addr >> 55) & 1) << 4) |
3232 (GET_FIELD_SP(pixel_addr, 33, 34) << 2) |
3233 GET_FIELD_SP(pixel_addr, 11, 12);
3234 }
3235
3236 target_ulong helper_alignaddr(target_ulong addr, target_ulong offset)
3237 {
3238 uint64_t tmp;
3239
3240 tmp = addr + offset;
3241 env->gsr &= ~7ULL;
3242 env->gsr |= tmp & 7ULL;
3243 return tmp & ~7ULL;
3244 }
3245
3246 target_ulong helper_popc(target_ulong val)
3247 {
3248 return ctpop64(val);
3249 }
3250
3251 static inline uint64_t *get_gregset(uint32_t pstate)
3252 {
3253 switch (pstate) {
3254 default:
3255 DPRINTF_PSTATE("ERROR in get_gregset: active pstate bits=%x%s%s%s\n",
3256 pstate,
3257 (pstate & PS_IG) ? " IG" : "",
3258 (pstate & PS_MG) ? " MG" : "",
3259 (pstate & PS_AG) ? " AG" : "");
3260 /* pass through to normal set of global registers */
3261 case 0:
3262 return env->bgregs;
3263 case PS_AG:
3264 return env->agregs;
3265 case PS_MG:
3266 return env->mgregs;
3267 case PS_IG:
3268 return env->igregs;
3269 }
3270 }
3271
3272 static inline void change_pstate(uint32_t new_pstate)
3273 {
3274 uint32_t pstate_regs, new_pstate_regs;
3275 uint64_t *src, *dst;
3276
3277 if (env->def->features & CPU_FEATURE_GL) {
3278 // PS_AG is not implemented in this case
3279 new_pstate &= ~PS_AG;
3280 }
3281
3282 pstate_regs = env->pstate & 0xc01;
3283 new_pstate_regs = new_pstate & 0xc01;
3284
3285 if (new_pstate_regs != pstate_regs) {
3286 DPRINTF_PSTATE("change_pstate: switching regs old=%x new=%x\n",
3287 pstate_regs, new_pstate_regs);
3288 // Switch global register bank
3289 src = get_gregset(new_pstate_regs);
3290 dst = get_gregset(pstate_regs);
3291 memcpy32(dst, env->gregs);
3292 memcpy32(env->gregs, src);
3293 }
3294 else {
3295 DPRINTF_PSTATE("change_pstate: regs new=%x (unchanged)\n",
3296 new_pstate_regs);
3297 }
3298 env->pstate = new_pstate;
3299 }
3300
3301 void helper_wrpstate(target_ulong new_state)
3302 {
3303 change_pstate(new_state & 0xf3f);
3304
3305 #if !defined(CONFIG_USER_ONLY)
3306 if (cpu_interrupts_enabled(env)) {
3307 cpu_check_irqs(env);
3308 }
3309 #endif
3310 }
3311
3312 void helper_wrpil(target_ulong new_pil)
3313 {
3314 #if !defined(CONFIG_USER_ONLY)
3315 DPRINTF_PSTATE("helper_wrpil old=%x new=%x\n",
3316 env->psrpil, (uint32_t)new_pil);
3317
3318 env->psrpil = new_pil;
3319
3320 if (cpu_interrupts_enabled(env)) {
3321 cpu_check_irqs(env);
3322 }
3323 #endif
3324 }
3325
3326 void helper_done(void)
3327 {
3328 trap_state* tsptr = cpu_tsptr(env);
3329
3330 env->pc = tsptr->tnpc;
3331 env->npc = tsptr->tnpc + 4;
3332 PUT_CCR(env, tsptr->tstate >> 32);
3333 env->asi = (tsptr->tstate >> 24) & 0xff;
3334 change_pstate((tsptr->tstate >> 8) & 0xf3f);
3335 PUT_CWP64(env, tsptr->tstate & 0xff);
3336 env->tl--;
3337
3338 DPRINTF_PSTATE("... helper_done tl=%d\n", env->tl);
3339
3340 #if !defined(CONFIG_USER_ONLY)
3341 if (cpu_interrupts_enabled(env)) {
3342 cpu_check_irqs(env);
3343 }
3344 #endif
3345 }
3346
3347 void helper_retry(void)
3348 {
3349 trap_state* tsptr = cpu_tsptr(env);
3350
3351 env->pc = tsptr->tpc;
3352 env->npc = tsptr->tnpc;
3353 PUT_CCR(env, tsptr->tstate >> 32);
3354 env->asi = (tsptr->tstate >> 24) & 0xff;
3355 change_pstate((tsptr->tstate >> 8) & 0xf3f);
3356 PUT_CWP64(env, tsptr->tstate & 0xff);
3357 env->tl--;
3358
3359 DPRINTF_PSTATE("... helper_retry tl=%d\n", env->tl);
3360
3361 #if !defined(CONFIG_USER_ONLY)
3362 if (cpu_interrupts_enabled(env)) {
3363 cpu_check_irqs(env);
3364 }
3365 #endif
3366 }
3367
3368 static void do_modify_softint(const char* operation, uint32_t value)
3369 {
3370 if (env->softint != value) {
3371 env->softint = value;
3372 DPRINTF_PSTATE(": %s new %08x\n", operation, env->softint);
3373 #if !defined(CONFIG_USER_ONLY)
3374 if (cpu_interrupts_enabled(env)) {
3375 cpu_check_irqs(env);
3376 }
3377 #endif
3378 }
3379 }
3380
3381 void helper_set_softint(uint64_t value)
3382 {
3383 do_modify_softint("helper_set_softint", env->softint | (uint32_t)value);
3384 }
3385
3386 void helper_clear_softint(uint64_t value)
3387 {
3388 do_modify_softint("helper_clear_softint", env->softint & (uint32_t)~value);
3389 }
3390
3391 void helper_write_softint(uint64_t value)
3392 {
3393 do_modify_softint("helper_write_softint", (uint32_t)value);
3394 }
3395 #endif
3396
3397 void helper_flush(target_ulong addr)
3398 {
3399 addr &= ~7;
3400 tb_invalidate_page_range(addr, addr + 8);
3401 }
3402
3403 #ifdef TARGET_SPARC64
3404 #ifdef DEBUG_PCALL
3405 static const char * const excp_names[0x80] = {
3406 [TT_TFAULT] = "Instruction Access Fault",
3407 [TT_TMISS] = "Instruction Access MMU Miss",
3408 [TT_CODE_ACCESS] = "Instruction Access Error",
3409 [TT_ILL_INSN] = "Illegal Instruction",
3410 [TT_PRIV_INSN] = "Privileged Instruction",
3411 [TT_NFPU_INSN] = "FPU Disabled",
3412 [TT_FP_EXCP] = "FPU Exception",
3413 [TT_TOVF] = "Tag Overflow",
3414 [TT_CLRWIN] = "Clean Windows",
3415 [TT_DIV_ZERO] = "Division By Zero",
3416 [TT_DFAULT] = "Data Access Fault",
3417 [TT_DMISS] = "Data Access MMU Miss",
3418 [TT_DATA_ACCESS] = "Data Access Error",
3419 [TT_DPROT] = "Data Protection Error",
3420 [TT_UNALIGNED] = "Unaligned Memory Access",
3421 [TT_PRIV_ACT] = "Privileged Action",
3422 [TT_EXTINT | 0x1] = "External Interrupt 1",
3423 [TT_EXTINT | 0x2] = "External Interrupt 2",
3424 [TT_EXTINT | 0x3] = "External Interrupt 3",
3425 [TT_EXTINT | 0x4] = "External Interrupt 4",
3426 [TT_EXTINT | 0x5] = "External Interrupt 5",
3427 [TT_EXTINT | 0x6] = "External Interrupt 6",
3428 [TT_EXTINT | 0x7] = "External Interrupt 7",
3429 [TT_EXTINT | 0x8] = "External Interrupt 8",
3430 [TT_EXTINT | 0x9] = "External Interrupt 9",
3431 [TT_EXTINT | 0xa] = "External Interrupt 10",
3432 [TT_EXTINT | 0xb] = "External Interrupt 11",
3433 [TT_EXTINT | 0xc] = "External Interrupt 12",
3434 [TT_EXTINT | 0xd] = "External Interrupt 13",
3435 [TT_EXTINT | 0xe] = "External Interrupt 14",
3436 [TT_EXTINT | 0xf] = "External Interrupt 15",
3437 };
3438 #endif
3439
3440 trap_state* cpu_tsptr(CPUState* env)
3441 {
3442 return &env->ts[env->tl & MAXTL_MASK];
3443 }
3444
3445 void do_interrupt(CPUState *env)
3446 {
3447 int intno = env->exception_index;
3448 trap_state* tsptr;
3449
3450 #ifdef DEBUG_PCALL
3451 if (qemu_loglevel_mask(CPU_LOG_INT)) {
3452 static int count;
3453 const char *name;
3454
3455 if (intno < 0 || intno >= 0x180)
3456 name = "Unknown";
3457 else if (intno >= 0x100)
3458 name = "Trap Instruction";
3459 else if (intno >= 0xc0)
3460 name = "Window Fill";
3461 else if (intno >= 0x80)
3462 name = "Window Spill";
3463 else {
3464 name = excp_names[intno];
3465 if (!name)
3466 name = "Unknown";
3467 }
3468
3469 qemu_log("%6d: %s (v=%04x) pc=%016" PRIx64 " npc=%016" PRIx64
3470 " SP=%016" PRIx64 "\n",
3471 count, name, intno,
3472 env->pc,
3473 env->npc, env->regwptr[6]);
3474 log_cpu_state(env, 0);
3475 #if 0
3476 {
3477 int i;
3478 uint8_t *ptr;
3479
3480 qemu_log(" code=");
3481 ptr = (uint8_t *)env->pc;
3482 for(i = 0; i < 16; i++) {
3483 qemu_log(" %02x", ldub(ptr + i));
3484 }
3485 qemu_log("\n");
3486 }
3487 #endif
3488 count++;
3489 }
3490 #endif
3491 #if !defined(CONFIG_USER_ONLY)
3492 if (env->tl >= env->maxtl) {
3493 cpu_abort(env, "Trap 0x%04x while trap level (%d) >= MAXTL (%d),"
3494 " Error state", env->exception_index, env->tl, env->maxtl);
3495 return;
3496 }
3497 #endif
3498 if (env->tl < env->maxtl - 1) {
3499 env->tl++;
3500 } else {
3501 env->pstate |= PS_RED;
3502 if (env->tl < env->maxtl)
3503 env->tl++;
3504 }
3505 tsptr = cpu_tsptr(env);
3506
3507 tsptr->tstate = ((uint64_t)GET_CCR(env) << 32) |
3508 ((env->asi & 0xff) << 24) | ((env->pstate & 0xf3f) << 8) |
3509 GET_CWP64(env);
3510 tsptr->tpc = env->pc;
3511 tsptr->tnpc = env->npc;
3512 tsptr->tt = intno;
3513
3514 switch (intno) {
3515 case TT_IVEC:
3516 change_pstate(PS_PEF | PS_PRIV | PS_IG);
3517 break;
3518 case TT_TFAULT:
3519 case TT_DFAULT:
3520 case TT_TMISS ... TT_TMISS + 3:
3521 case TT_DMISS ... TT_DMISS + 3:
3522 case TT_DPROT ... TT_DPROT + 3:
3523 change_pstate(PS_PEF | PS_PRIV | PS_MG);
3524 break;
3525 default:
3526 change_pstate(PS_PEF | PS_PRIV | PS_AG);
3527 break;
3528 }
3529
3530 if (intno == TT_CLRWIN)
3531 cpu_set_cwp(env, cpu_cwp_dec(env, env->cwp - 1));
3532 else if ((intno & 0x1c0) == TT_SPILL)
3533 cpu_set_cwp(env, cpu_cwp_dec(env, env->cwp - env->cansave - 2));
3534 else if ((intno & 0x1c0) == TT_FILL)
3535 cpu_set_cwp(env, cpu_cwp_inc(env, env->cwp + 1));
3536 env->tbr &= ~0x7fffULL;
3537 env->tbr |= ((env->tl > 1) ? 1 << 14 : 0) | (intno << 5);
3538 env->pc = env->tbr;
3539 env->npc = env->pc + 4;
3540 env->exception_index = -1;
3541 }
3542 #else
3543 #ifdef DEBUG_PCALL
3544 static const char * const excp_names[0x80] = {
3545 [TT_TFAULT] = "Instruction Access Fault",
3546 [TT_ILL_INSN] = "Illegal Instruction",
3547 [TT_PRIV_INSN] = "Privileged Instruction",
3548 [TT_NFPU_INSN] = "FPU Disabled",
3549 [TT_WIN_OVF] = "Window Overflow",
3550 [TT_WIN_UNF] = "Window Underflow",
3551 [TT_UNALIGNED] = "Unaligned Memory Access",
3552 [TT_FP_EXCP] = "FPU Exception",
3553 [TT_DFAULT] = "Data Access Fault",
3554 [TT_TOVF] = "Tag Overflow",
3555 [TT_EXTINT | 0x1] = "External Interrupt 1",
3556 [TT_EXTINT | 0x2] = "External Interrupt 2",
3557 [TT_EXTINT | 0x3] = "External Interrupt 3",
3558 [TT_EXTINT | 0x4] = "External Interrupt 4",
3559 [TT_EXTINT | 0x5] = "External Interrupt 5",
3560 [TT_EXTINT | 0x6] = "External Interrupt 6",
3561 [TT_EXTINT | 0x7] = "External Interrupt 7",
3562 [TT_EXTINT | 0x8] = "External Interrupt 8",
3563 [TT_EXTINT | 0x9] = "External Interrupt 9",
3564 [TT_EXTINT | 0xa] = "External Interrupt 10",
3565 [TT_EXTINT | 0xb] = "External Interrupt 11",
3566 [TT_EXTINT | 0xc] = "External Interrupt 12",
3567 [TT_EXTINT | 0xd] = "External Interrupt 13",
3568 [TT_EXTINT | 0xe] = "External Interrupt 14",
3569 [TT_EXTINT | 0xf] = "External Interrupt 15",
3570 [TT_TOVF] = "Tag Overflow",
3571 [TT_CODE_ACCESS] = "Instruction Access Error",
3572 [TT_DATA_ACCESS] = "Data Access Error",
3573 [TT_DIV_ZERO] = "Division By Zero",
3574 [TT_NCP_INSN] = "Coprocessor Disabled",
3575 };
3576 #endif
3577
3578 void do_interrupt(CPUState *env)
3579 {
3580 int cwp, intno = env->exception_index;
3581
3582 #ifdef DEBUG_PCALL
3583 if (qemu_loglevel_mask(CPU_LOG_INT)) {
3584 static int count;
3585 const char *name;
3586
3587 if (intno < 0 || intno >= 0x100)
3588 name = "Unknown";
3589 else if (intno >= 0x80)
3590 name = "Trap Instruction";
3591 else {
3592 name = excp_names[intno];
3593 if (!name)
3594 name = "Unknown";
3595 }
3596
3597 qemu_log("%6d: %s (v=%02x) pc=%08x npc=%08x SP=%08x\n",
3598 count, name, intno,
3599 env->pc,
3600 env->npc, env->regwptr[6]);
3601 log_cpu_state(env, 0);
3602 #if 0
3603 {
3604 int i;
3605 uint8_t *ptr;
3606
3607 qemu_log(" code=");
3608 ptr = (uint8_t *)env->pc;
3609 for(i = 0; i < 16; i++) {
3610 qemu_log(" %02x", ldub(ptr + i));
3611 }
3612 qemu_log("\n");
3613 }
3614 #endif
3615 count++;
3616 }
3617 #endif
3618 #if !defined(CONFIG_USER_ONLY)
3619 if (env->psret == 0) {
3620 cpu_abort(env, "Trap 0x%02x while interrupts disabled, Error state",
3621 env->exception_index);
3622 return;
3623 }
3624 #endif
3625 env->psret = 0;
3626 cwp = cpu_cwp_dec(env, env->cwp - 1);
3627 cpu_set_cwp(env, cwp);
3628 env->regwptr[9] = env->pc;
3629 env->regwptr[10] = env->npc;
3630 env->psrps = env->psrs;
3631 env->psrs = 1;
3632 env->tbr = (env->tbr & TBR_BASE_MASK) | (intno << 4);
3633 env->pc = env->tbr;
3634 env->npc = env->pc + 4;
3635 env->exception_index = -1;
3636 }
3637 #endif
3638
3639 #if !defined(CONFIG_USER_ONLY)
3640
3641 static void do_unaligned_access(target_ulong addr, int is_write, int is_user,
3642 void *retaddr);
3643
3644 #define MMUSUFFIX _mmu
3645 #define ALIGNED_ONLY
3646
3647 #define SHIFT 0
3648 #include "softmmu_template.h"
3649
3650 #define SHIFT 1
3651 #include "softmmu_template.h"
3652
3653 #define SHIFT 2
3654 #include "softmmu_template.h"
3655
3656 #define SHIFT 3
3657 #include "softmmu_template.h"
3658
3659 /* XXX: make it generic ? */
3660 static void cpu_restore_state2(void *retaddr)
3661 {
3662 TranslationBlock *tb;
3663 unsigned long pc;
3664
3665 if (retaddr) {
3666 /* now we have a real cpu fault */
3667 pc = (unsigned long)retaddr;
3668 tb = tb_find_pc(pc);
3669 if (tb) {
3670 /* the PC is inside the translated code. It means that we have
3671 a virtual CPU fault */
3672 cpu_restore_state(tb, env, pc, (void *)(long)env->cond);
3673 }
3674 }
3675 }
3676
3677 static void do_unaligned_access(target_ulong addr, int is_write, int is_user,
3678 void *retaddr)
3679 {
3680 #ifdef DEBUG_UNALIGNED
3681 printf("Unaligned access to 0x" TARGET_FMT_lx " from 0x" TARGET_FMT_lx
3682 "\n", addr, env->pc);
3683 #endif
3684 cpu_restore_state2(retaddr);
3685 raise_exception(TT_UNALIGNED);
3686 }
3687
3688 /* try to fill the TLB and return an exception if error. If retaddr is
3689 NULL, it means that the function was called in C code (i.e. not
3690 from generated code or from helper.c) */
3691 /* XXX: fix it to restore all registers */
3692 void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
3693 {
3694 int ret;
3695 CPUState *saved_env;
3696
3697 /* XXX: hack to restore env in all cases, even if not called from
3698 generated code */
3699 saved_env = env;
3700 env = cpu_single_env;
3701
3702 ret = cpu_sparc_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
3703 if (ret) {
3704 cpu_restore_state2(retaddr);
3705 cpu_loop_exit();
3706 }
3707 env = saved_env;
3708 }
3709
3710 #endif
3711
3712 #ifndef TARGET_SPARC64
3713 void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,
3714 int is_asi, int size)
3715 {
3716 CPUState *saved_env;
3717 int fault_type;
3718
3719 /* XXX: hack to restore env in all cases, even if not called from
3720 generated code */
3721 saved_env = env;
3722 env = cpu_single_env;
3723 #ifdef DEBUG_UNASSIGNED
3724 if (is_asi)
3725 printf("Unassigned mem %s access of %d byte%s to " TARGET_FMT_plx
3726 " asi 0x%02x from " TARGET_FMT_lx "\n",
3727 is_exec ? "exec" : is_write ? "write" : "read", size,
3728 size == 1 ? "" : "s", addr, is_asi, env->pc);
3729 else
3730 printf("Unassigned mem %s access of %d byte%s to " TARGET_FMT_plx
3731 " from " TARGET_FMT_lx "\n",
3732 is_exec ? "exec" : is_write ? "write" : "read", size,
3733 size == 1 ? "" : "s", addr, env->pc);
3734 #endif
3735 /* Don't overwrite translation and access faults */
3736 fault_type = (env->mmuregs[3] & 0x1c) >> 2;
3737 if ((fault_type > 4) || (fault_type == 0)) {
3738 env->mmuregs[3] = 0; /* Fault status register */
3739 if (is_asi)
3740 env->mmuregs[3] |= 1 << 16;
3741 if (env->psrs)
3742 env->mmuregs[3] |= 1 << 5;
3743 if (is_exec)
3744 env->mmuregs[3] |= 1 << 6;
3745 if (is_write)
3746 env->mmuregs[3] |= 1 << 7;
3747 env->mmuregs[3] |= (5 << 2) | 2;
3748 /* SuperSPARC will never place instruction fault addresses in the FAR */
3749 if (!is_exec) {
3750 env->mmuregs[4] = addr; /* Fault address register */
3751 }
3752 }
3753 /* overflow (same type fault was not read before another fault) */
3754 if (fault_type == ((env->mmuregs[3] & 0x1c)) >> 2) {
3755 env->mmuregs[3] |= 1;
3756 }
3757
3758 if ((env->mmuregs[0] & MMU_E) && !(env->mmuregs[0] & MMU_NF)) {
3759 if (is_exec)
3760 raise_exception(TT_CODE_ACCESS);
3761 else
3762 raise_exception(TT_DATA_ACCESS);
3763 }
3764
3765 /* flush neverland mappings created during no-fault mode,
3766 so the sequential MMU faults report proper fault types */
3767 if (env->mmuregs[0] & MMU_NF) {
3768 tlb_flush(env, 1);
3769 }
3770
3771 env = saved_env;
3772 }
3773 #else
3774 void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,
3775 int is_asi, int size)
3776 {
3777 CPUState *saved_env;
3778
3779 /* XXX: hack to restore env in all cases, even if not called from
3780 generated code */
3781 saved_env = env;
3782 env = cpu_single_env;
3783
3784 #ifdef DEBUG_UNASSIGNED
3785 printf("Unassigned mem access to " TARGET_FMT_plx " from " TARGET_FMT_lx
3786 "\n", addr, env->pc);
3787 #endif
3788
3789 if (is_exec)
3790 raise_exception(TT_CODE_ACCESS);
3791 else
3792 raise_exception(TT_DATA_ACCESS);
3793
3794 env = saved_env;
3795 }
3796 #endif
3797
3798 #ifdef TARGET_SPARC64
3799 void helper_tick_set_count(void *opaque, uint64_t count)
3800 {
3801 #if !defined(CONFIG_USER_ONLY)
3802 cpu_tick_set_count(opaque, count);
3803 #endif
3804 }
3805
3806 uint64_t helper_tick_get_count(void *opaque)
3807 {
3808 #if !defined(CONFIG_USER_ONLY)
3809 return cpu_tick_get_count(opaque);
3810 #else
3811 return 0;
3812 #endif
3813 }
3814
3815 void helper_tick_set_limit(void *opaque, uint64_t limit)
3816 {
3817 #if !defined(CONFIG_USER_ONLY)
3818 cpu_tick_set_limit(opaque, limit);
3819 #endif
3820 }
3821 #endif
QEmu