← Back to branch summary

~fboudra/qemu-linaro/new-upstream-release-1.2.0-2012.09-0ubuntu1

« back to all changes in this revision

Viewing changes to target-sparc/ldst_helper.c

  • Committer: Fathi Boudra
  • Author(s): Fathi Boudra
  • Date: 2012-08-21 06:47:11 UTC
  • mfrom: (0.1.16)
  • Revision ID: fathi.boudra@linaro.org-20120821064711-7yxmubp2v8a44xce
Tags: 1.1.50-2012.08-0ubuntu1
https://launchpad.net/bugs/1030588
https://launchpad.net/bugs/1030594
* New upstream release.
  - support emulated systems with more than 2G of memory. (LP: #1030588)
* Drop powerpc-missing-include.patch - merged upstream.
* Update debian/control: 
  - drop perl build dependency.
  - add libfdt-dev build dependency.
* Update debian/qemu-keymaps.install file.
* Update debian/rules:
  - update QEMU_CPU for ARM architecture: armv4l -> armv7l.
  - update conf_audio_drv: default to PulseAudio since PA is the default on
    Ubuntu.
  - enable KVM on ARM architecture.
  - enable flat device tree support (--enable-fdt). (LP: #1030594)

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-sparc/ldst_helper.c
18
18
 */
19
19
 
20
20
#include "cpu.h"
21
 
#include "dyngen-exec.h"
22
21
#include "helper.h"
23
22
 
24
 
#if !defined(CONFIG_USER_ONLY)
25
 
#include "softmmu_exec.h"
26
 
#endif
27
 
 
28
23
//#define DEBUG_MMU
29
24
//#define DEBUG_MXCC
30
25
//#define DEBUG_UNALIGNED
70
65
#define QT1 (env->qt1)
71
66
 
72
67
#if !defined(CONFIG_USER_ONLY)
73
 
static void do_unassigned_access(target_phys_addr_t addr, int is_write,
74
 
                                 int is_exec, int is_asi, int size);
75
 
#else
76
 
#ifdef TARGET_SPARC64
77
 
static void do_unassigned_access(target_ulong addr, int is_write, int is_exec,
78
 
                                 int is_asi, int size);
79
 
#endif
 
68
#include "softmmu_exec.h"
 
69
#define MMUSUFFIX _mmu
 
70
#define ALIGNED_ONLY
 
71
 
 
72
#define SHIFT 0
 
73
#include "softmmu_template.h"
 
74
 
 
75
#define SHIFT 1
 
76
#include "softmmu_template.h"
 
77
 
 
78
#define SHIFT 2
 
79
#include "softmmu_template.h"
 
80
 
 
81
#define SHIFT 3
 
82
#include "softmmu_template.h"
80
83
#endif
81
84
 
82
85
#if defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY)
129
132
 
130
133
static void replace_tlb_entry(SparcTLBEntry *tlb,
131
134
                              uint64_t tlb_tag, uint64_t tlb_tte,
132
 
                              CPUState *env1)
 
135
                              CPUSPARCState *env1)
133
136
{
134
137
    target_ulong mask, size, va, offset;
135
138
 
152
155
}
153
156
 
154
157
static void demap_tlb(SparcTLBEntry *tlb, target_ulong demap_addr,
155
 
                      const char *strmmu, CPUState *env1)
 
158
                      const char *strmmu, CPUSPARCState *env1)
156
159
{
157
160
    unsigned int i;
158
161
    target_ulong mask;
213
216
 
214
217
static void replace_tlb_1bit_lru(SparcTLBEntry *tlb,
215
218
                                 uint64_t tlb_tag, uint64_t tlb_tte,
216
 
                                 const char *strmmu, CPUState *env1)
 
219
                                 const char *strmmu, CPUSPARCState *env1)
217
220
{
218
221
    unsigned int i, replace_used;
219
222
 
263
266
 
264
267
#endif
265
268
 
266
 
static inline target_ulong address_mask(CPUState *env1, target_ulong addr)
 
269
static inline target_ulong address_mask(CPUSPARCState *env1, target_ulong addr)
267
270
{
268
271
#ifdef TARGET_SPARC64
269
272
    if (AM_CHECK(env1)) {
300
303
#endif
301
304
}
302
305
 
303
 
static inline target_ulong asi_address_mask(CPUState *env1,
 
306
static inline target_ulong asi_address_mask(CPUSPARCState *env,
304
307
                                            int asi, target_ulong addr)
305
308
{
306
309
    if (is_translating_asi(asi)) {
310
313
    }
311
314
}
312
315
 
313
 
void helper_check_align(target_ulong addr, uint32_t align)
 
316
void helper_check_align(CPUSPARCState *env, target_ulong addr, uint32_t align)
314
317
{
315
318
    if (addr & align) {
316
319
#ifdef DEBUG_UNALIGNED
323
326
 
324
327
#if !defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY) &&   \
325
328
    defined(DEBUG_MXCC)
326
 
static void dump_mxcc(CPUState *env)
 
329
static void dump_mxcc(CPUSPARCState *env)
327
330
{
328
331
    printf("mxccdata: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" PRIx64
329
332
           "\n",
372
375
 
373
376
/* Leon3 cache control */
374
377
 
375
 
static void leon3_cache_control_st(target_ulong addr, uint64_t val, int size)
 
378
static void leon3_cache_control_st(CPUSPARCState *env, target_ulong addr,
 
379
                                   uint64_t val, int size)
376
380
{
377
381
    DPRINTF_CACHE_CONTROL("st addr:%08x, val:%" PRIx64 ", size:%d\n",
378
382
                          addr, val, size);
404
408
    };
405
409
}
406
410
 
407
 
static uint64_t leon3_cache_control_ld(target_ulong addr, int size)
 
411
static uint64_t leon3_cache_control_ld(CPUSPARCState *env, target_ulong addr,
 
412
                                       int size)
408
413
{
409
414
    uint64_t ret = 0;
410
415
 
436
441
    return ret;
437
442
}
438
443
 
439
 
uint64_t helper_ld_asi(target_ulong addr, int asi, int size, int sign)
 
444
uint64_t helper_ld_asi(CPUSPARCState *env, target_ulong addr, int asi, int size,
 
445
                       int sign)
440
446
{
441
447
    uint64_t ret = 0;
442
448
#if defined(DEBUG_MXCC) || defined(DEBUG_ASI)
443
449
    uint32_t last_addr = addr;
444
450
#endif
445
451
 
446
 
    helper_check_align(addr, size - 1);
 
452
    helper_check_align(env, addr, size - 1);
447
453
    switch (asi) {
448
454
    case 2: /* SuperSparc MXCC registers and Leon3 cache control */
449
455
        switch (addr) {
451
457
        case 0x08:          /* Leon3 Instruction Cache config */
452
458
        case 0x0C:          /* Leon3 Date Cache config */
453
459
            if (env->def->features & CPU_FEATURE_CACHE_CTRL) {
454
 
                ret = leon3_cache_control_ld(addr, size);
 
460
                ret = leon3_cache_control_ld(env, addr, size);
455
461
            }
456
462
            break;
457
463
        case 0x01c00a00: /* MXCC control register */
458
464
            if (size == 8) {
459
465
                ret = env->mxccregs[3];
460
466
            } else {
461
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
462
 
                             size);
 
467
                qemu_log_mask(LOG_UNIMP,
 
468
                              "%08x: unimplemented access size: %d\n", addr,
 
469
                              size);
463
470
            }
464
471
            break;
465
472
        case 0x01c00a04: /* MXCC control register */
466
473
            if (size == 4) {
467
474
                ret = env->mxccregs[3];
468
475
            } else {
469
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
470
 
                             size);
 
476
                qemu_log_mask(LOG_UNIMP,
 
477
                              "%08x: unimplemented access size: %d\n", addr,
 
478
                              size);
471
479
            }
472
480
            break;
473
481
        case 0x01c00c00: /* Module reset register */
475
483
                ret = env->mxccregs[5];
476
484
                /* should we do something here? */
477
485
            } else {
478
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
479
 
                             size);
 
486
                qemu_log_mask(LOG_UNIMP,
 
487
                              "%08x: unimplemented access size: %d\n", addr,
 
488
                              size);
480
489
            }
481
490
            break;
482
491
        case 0x01c00f00: /* MBus port address register */
483
492
            if (size == 8) {
484
493
                ret = env->mxccregs[7];
485
494
            } else {
486
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
487
 
                             size);
 
495
                qemu_log_mask(LOG_UNIMP,
 
496
                              "%08x: unimplemented access size: %d\n", addr,
 
497
                              size);
488
498
            }
489
499
            break;
490
500
        default:
491
 
            DPRINTF_MXCC("%08x: unimplemented address, size: %d\n", addr,
492
 
                         size);
 
501
            qemu_log_mask(LOG_UNIMP,
 
502
                          "%08x: unimplemented address, size: %d\n", addr,
 
503
                          size);
493
504
            break;
494
505
        }
495
506
        DPRINTF_MXCC("asi = %d, size = %d, sign = %d, "
535
546
    case 9: /* Supervisor code access */
536
547
        switch (size) {
537
548
        case 1:
538
 
            ret = ldub_code(addr);
 
549
            ret = cpu_ldub_code(env, addr);
539
550
            break;
540
551
        case 2:
541
 
            ret = lduw_code(addr);
 
552
            ret = cpu_lduw_code(env, addr);
542
553
            break;
543
554
        default:
544
555
        case 4:
545
 
            ret = ldl_code(addr);
 
556
            ret = cpu_ldl_code(env, addr);
546
557
            break;
547
558
        case 8:
548
 
            ret = ldq_code(addr);
 
559
            ret = cpu_ldq_code(env, addr);
549
560
            break;
550
561
        }
551
562
        break;
552
563
    case 0xa: /* User data access */
553
564
        switch (size) {
554
565
        case 1:
555
 
            ret = ldub_user(addr);
 
566
            ret = cpu_ldub_user(env, addr);
556
567
            break;
557
568
        case 2:
558
 
            ret = lduw_user(addr);
 
569
            ret = cpu_lduw_user(env, addr);
559
570
            break;
560
571
        default:
561
572
        case 4:
562
 
            ret = ldl_user(addr);
 
573
            ret = cpu_ldl_user(env, addr);
563
574
            break;
564
575
        case 8:
565
 
            ret = ldq_user(addr);
 
576
            ret = cpu_ldq_user(env, addr);
566
577
            break;
567
578
        }
568
579
        break;
569
580
    case 0xb: /* Supervisor data access */
570
581
        switch (size) {
571
582
        case 1:
572
 
            ret = ldub_kernel(addr);
 
583
            ret = cpu_ldub_kernel(env, addr);
573
584
            break;
574
585
        case 2:
575
 
            ret = lduw_kernel(addr);
 
586
            ret = cpu_lduw_kernel(env, addr);
576
587
            break;
577
588
        default:
578
589
        case 4:
579
 
            ret = ldl_kernel(addr);
 
590
            ret = cpu_ldl_kernel(env, addr);
580
591
            break;
581
592
        case 8:
582
 
            ret = ldq_kernel(addr);
 
593
            ret = cpu_ldq_kernel(env, addr);
583
594
            break;
584
595
        }
585
596
        break;
669
680
        break;
670
681
    case 8: /* User code access, XXX */
671
682
    default:
672
 
        do_unassigned_access(addr, 0, 0, asi, size);
 
683
        cpu_unassigned_access(env, addr, 0, 0, asi, size);
673
684
        ret = 0;
674
685
        break;
675
686
    }
694
705
    return ret;
695
706
}
696
707
 
697
 
void helper_st_asi(target_ulong addr, uint64_t val, int asi, int size)
 
708
void helper_st_asi(CPUSPARCState *env, target_ulong addr, uint64_t val, int asi,
 
709
                   int size)
698
710
{
699
 
    helper_check_align(addr, size - 1);
 
711
    helper_check_align(env, addr, size - 1);
700
712
    switch (asi) {
701
713
    case 2: /* SuperSparc MXCC registers and Leon3 cache control */
702
714
        switch (addr) {
704
716
        case 0x08:          /* Leon3 Instruction Cache config */
705
717
        case 0x0C:          /* Leon3 Date Cache config */
706
718
            if (env->def->features & CPU_FEATURE_CACHE_CTRL) {
707
 
                leon3_cache_control_st(addr, val, size);
 
719
                leon3_cache_control_st(env, addr, val, size);
708
720
            }
709
721
            break;
710
722
 
712
724
            if (size == 8) {
713
725
                env->mxccdata[0] = val;
714
726
            } else {
715
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
716
 
                             size);
 
727
                qemu_log_mask(LOG_UNIMP,
 
728
                              "%08x: unimplemented access size: %d\n", addr,
 
729
                              size);
717
730
            }
718
731
            break;
719
732
        case 0x01c00008: /* MXCC stream data register 1 */
720
733
            if (size == 8) {
721
734
                env->mxccdata[1] = val;
722
735
            } else {
723
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
724
 
                             size);
 
736
                qemu_log_mask(LOG_UNIMP,
 
737
                              "%08x: unimplemented access size: %d\n", addr,
 
738
                              size);
725
739
            }
726
740
            break;
727
741
        case 0x01c00010: /* MXCC stream data register 2 */
728
742
            if (size == 8) {
729
743
                env->mxccdata[2] = val;
730
744
            } else {
731
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
732
 
                             size);
 
745
                qemu_log_mask(LOG_UNIMP,
 
746
                              "%08x: unimplemented access size: %d\n", addr,
 
747
                              size);
733
748
            }
734
749
            break;
735
750
        case 0x01c00018: /* MXCC stream data register 3 */
736
751
            if (size == 8) {
737
752
                env->mxccdata[3] = val;
738
753
            } else {
739
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
740
 
                             size);
 
754
                qemu_log_mask(LOG_UNIMP,
 
755
                              "%08x: unimplemented access size: %d\n", addr,
 
756
                              size);
741
757
            }
742
758
            break;
743
759
        case 0x01c00100: /* MXCC stream source */
744
760
            if (size == 8) {
745
761
                env->mxccregs[0] = val;
746
762
            } else {
747
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
748
 
                             size);
 
763
                qemu_log_mask(LOG_UNIMP,
 
764
                              "%08x: unimplemented access size: %d\n", addr,
 
765
                              size);
749
766
            }
750
767
            env->mxccdata[0] = ldq_phys((env->mxccregs[0] & 0xffffffffULL) +
751
768
                                        0);
760
777
            if (size == 8) {
761
778
                env->mxccregs[1] = val;
762
779
            } else {
763
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
764
 
                             size);
 
780
                qemu_log_mask(LOG_UNIMP,
 
781
                              "%08x: unimplemented access size: %d\n", addr,
 
782
                              size);
765
783
            }
766
784
            stq_phys((env->mxccregs[1] & 0xffffffffULL) +  0,
767
785
                     env->mxccdata[0]);
776
794
            if (size == 8) {
777
795
                env->mxccregs[3] = val;
778
796
            } else {
779
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
780
 
                             size);
 
797
                qemu_log_mask(LOG_UNIMP,
 
798
                              "%08x: unimplemented access size: %d\n", addr,
 
799
                              size);
781
800
            }
782
801
            break;
783
802
        case 0x01c00a04: /* MXCC control register */
785
804
                env->mxccregs[3] = (env->mxccregs[3] & 0xffffffff00000000ULL)
786
805
                    | val;
787
806
            } else {
788
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
789
 
                             size);
 
807
                qemu_log_mask(LOG_UNIMP,
 
808
                              "%08x: unimplemented access size: %d\n", addr,
 
809
                              size);
790
810
            }
791
811
            break;
792
812
        case 0x01c00e00: /* MXCC error register  */
794
814
            if (size == 8) {
795
815
                env->mxccregs[6] &= ~val;
796
816
            } else {
797
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
798
 
                             size);
 
817
                qemu_log_mask(LOG_UNIMP,
 
818
                              "%08x: unimplemented access size: %d\n", addr,
 
819
                              size);
799
820
            }
800
821
            break;
801
822
        case 0x01c00f00: /* MBus port address register */
802
823
            if (size == 8) {
803
824
                env->mxccregs[7] = val;
804
825
            } else {
805
 
                DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr,
806
 
                             size);
 
826
                qemu_log_mask(LOG_UNIMP,
 
827
                              "%08x: unimplemented access size: %d\n", addr,
 
828
                              size);
807
829
            }
808
830
            break;
809
831
        default:
810
 
            DPRINTF_MXCC("%08x: unimplemented address, size: %d\n", addr,
811
 
                         size);
 
832
            qemu_log_mask(LOG_UNIMP,
 
833
                          "%08x: unimplemented address, size: %d\n", addr,
 
834
                          size);
812
835
            break;
813
836
        }
814
837
        DPRINTF_MXCC("asi = %d, size = %d, addr = %08x, val = %" PRIx64 "\n",
902
925
    case 0xa: /* User data access */
903
926
        switch (size) {
904
927
        case 1:
905
 
            stb_user(addr, val);
 
928
            cpu_stb_user(env, addr, val);
906
929
            break;
907
930
        case 2:
908
 
            stw_user(addr, val);
 
931
            cpu_stw_user(env, addr, val);
909
932
            break;
910
933
        default:
911
934
        case 4:
912
 
            stl_user(addr, val);
 
935
            cpu_stl_user(env, addr, val);
913
936
            break;
914
937
        case 8:
915
 
            stq_user(addr, val);
 
938
            cpu_stq_user(env, addr, val);
916
939
            break;
917
940
        }
918
941
        break;
919
942
    case 0xb: /* Supervisor data access */
920
943
        switch (size) {
921
944
        case 1:
922
 
            stb_kernel(addr, val);
 
945
            cpu_stb_kernel(env, addr, val);
923
946
            break;
924
947
        case 2:
925
 
            stw_kernel(addr, val);
 
948
            cpu_stw_kernel(env, addr, val);
926
949
            break;
927
950
        default:
928
951
        case 4:
929
 
            stl_kernel(addr, val);
 
952
            cpu_stl_kernel(env, addr, val);
930
953
            break;
931
954
        case 8:
932
 
            stq_kernel(addr, val);
 
955
            cpu_stq_kernel(env, addr, val);
933
956
            break;
934
957
        }
935
958
        break;
952
975
            uint32_t src = val & ~3, dst = addr & ~3, temp;
953
976
 
954
977
            for (i = 0; i < 32; i += 4, src += 4, dst += 4) {
955
 
                temp = ldl_kernel(src);
956
 
                stl_kernel(dst, temp);
 
978
                temp = cpu_ldl_kernel(env, src);
 
979
                cpu_stl_kernel(env, dst, temp);
957
980
            }
958
981
        }
959
982
        break;
965
988
            uint32_t dst = addr & 7;
966
989
 
967
990
            for (i = 0; i < 32; i += 8, dst += 8) {
968
 
                stq_kernel(dst, val);
 
991
                cpu_stq_kernel(env, dst, val);
969
992
            }
970
993
        }
971
994
        break;
1056
1079
    case 8: /* User code access, XXX */
1057
1080
    case 9: /* Supervisor code access, XXX */
1058
1081
    default:
1059
 
        do_unassigned_access(addr, 1, 0, asi, size);
 
1082
        cpu_unassigned_access(env, addr, 1, 0, asi, size);
1060
1083
        break;
1061
1084
    }
1062
1085
#ifdef DEBUG_ASI
1068
1091
#else /* TARGET_SPARC64 */
1069
1092
 
1070
1093
#ifdef CONFIG_USER_ONLY
1071
 
uint64_t helper_ld_asi(target_ulong addr, int asi, int size, int sign)
 
1094
uint64_t helper_ld_asi(CPUSPARCState *env, target_ulong addr, int asi, int size,
 
1095
                       int sign)
1072
1096
{
1073
1097
    uint64_t ret = 0;
1074
1098
#if defined(DEBUG_ASI)
1079
1103
        helper_raise_exception(env, TT_PRIV_ACT);
1080
1104
    }
1081
1105
 
1082
 
    helper_check_align(addr, size - 1);
 
1106
    helper_check_align(env, addr, size - 1);
1083
1107
    addr = asi_address_mask(env, asi, addr);
1084
1108
 
1085
1109
    switch (asi) {
1174
1198
    return ret;
1175
1199
}
1176
1200
 
1177
 
void helper_st_asi(target_ulong addr, target_ulong val, int asi, int size)
 
1201
void helper_st_asi(CPUSPARCState *env, target_ulong addr, target_ulong val,
 
1202
                   int asi, int size)
1178
1203
{
1179
1204
#ifdef DEBUG_ASI
1180
1205
    dump_asi("write", addr, asi, size, val);
1183
1208
        helper_raise_exception(env, TT_PRIV_ACT);
1184
1209
    }
1185
1210
 
1186
 
    helper_check_align(addr, size - 1);
 
1211
    helper_check_align(env, addr, size - 1);
1187
1212
    addr = asi_address_mask(env, asi, addr);
1188
1213
 
1189
1214
    /* Convert to little endian */
1238
1263
    case 0x8a: /* Primary no-fault LE, RO */
1239
1264
    case 0x8b: /* Secondary no-fault LE, RO */
1240
1265
    default:
1241
 
        do_unassigned_access(addr, 1, 0, 1, size);
 
1266
        helper_raise_exception(env, TT_DATA_ACCESS);
1242
1267
        return;
1243
1268
    }
1244
1269
}
1245
1270
 
1246
1271
#else /* CONFIG_USER_ONLY */
1247
1272
 
1248
 
uint64_t helper_ld_asi(target_ulong addr, int asi, int size, int sign)
 
1273
uint64_t helper_ld_asi(CPUSPARCState *env, target_ulong addr, int asi, int size,
 
1274
                       int sign)
1249
1275
{
1250
1276
    uint64_t ret = 0;
1251
1277
#if defined(DEBUG_ASI)
1261
1287
        helper_raise_exception(env, TT_PRIV_ACT);
1262
1288
    }
1263
1289
 
1264
 
    helper_check_align(addr, size - 1);
 
1290
    helper_check_align(env, addr, size - 1);
1265
1291
    addr = asi_address_mask(env, asi, addr);
1266
1292
 
1267
1293
    /* process nonfaulting loads first */
1302
1328
            if (cpu_hypervisor_mode(env)) {
1303
1329
                switch (size) {
1304
1330
                case 1:
1305
 
                    ret = ldub_hypv(addr);
 
1331
                    ret = cpu_ldub_hypv(env, addr);
1306
1332
                    break;
1307
1333
                case 2:
1308
 
                    ret = lduw_hypv(addr);
 
1334
                    ret = cpu_lduw_hypv(env, addr);
1309
1335
                    break;
1310
1336
                case 4:
1311
 
                    ret = ldl_hypv(addr);
 
1337
                    ret = cpu_ldl_hypv(env, addr);
1312
1338
                    break;
1313
1339
                default:
1314
1340
                case 8:
1315
 
                    ret = ldq_hypv(addr);
 
1341
                    ret = cpu_ldq_hypv(env, addr);
1316
1342
                    break;
1317
1343
                }
1318
1344
            } else {
1320
1346
                if (asi & 1) {
1321
1347
                    switch (size) {
1322
1348
                    case 1:
1323
 
                        ret = ldub_kernel_secondary(addr);
 
1349
                        ret = cpu_ldub_kernel_secondary(env, addr);
1324
1350
                        break;
1325
1351
                    case 2:
1326
 
                        ret = lduw_kernel_secondary(addr);
 
1352
                        ret = cpu_lduw_kernel_secondary(env, addr);
1327
1353
                        break;
1328
1354
                    case 4:
1329
 
                        ret = ldl_kernel_secondary(addr);
 
1355
                        ret = cpu_ldl_kernel_secondary(env, addr);
1330
1356
                        break;
1331
1357
                    default:
1332
1358
                    case 8:
1333
 
                        ret = ldq_kernel_secondary(addr);
 
1359
                        ret = cpu_ldq_kernel_secondary(env, addr);
1334
1360
                        break;
1335
1361
                    }
1336
1362
                } else {
1337
1363
                    switch (size) {
1338
1364
                    case 1:
1339
 
                        ret = ldub_kernel(addr);
 
1365
                        ret = cpu_ldub_kernel(env, addr);
1340
1366
                        break;
1341
1367
                    case 2:
1342
 
                        ret = lduw_kernel(addr);
 
1368
                        ret = cpu_lduw_kernel(env, addr);
1343
1369
                        break;
1344
1370
                    case 4:
1345
 
                        ret = ldl_kernel(addr);
 
1371
                        ret = cpu_ldl_kernel(env, addr);
1346
1372
                        break;
1347
1373
                    default:
1348
1374
                    case 8:
1349
 
                        ret = ldq_kernel(addr);
 
1375
                        ret = cpu_ldq_kernel(env, addr);
1350
1376
                        break;
1351
1377
                    }
1352
1378
                }
1356
1382
            if (asi & 1) {
1357
1383
                switch (size) {
1358
1384
                case 1:
1359
 
                    ret = ldub_user_secondary(addr);
 
1385
                    ret = cpu_ldub_user_secondary(env, addr);
1360
1386
                    break;
1361
1387
                case 2:
1362
 
                    ret = lduw_user_secondary(addr);
 
1388
                    ret = cpu_lduw_user_secondary(env, addr);
1363
1389
                    break;
1364
1390
                case 4:
1365
 
                    ret = ldl_user_secondary(addr);
 
1391
                    ret = cpu_ldl_user_secondary(env, addr);
1366
1392
                    break;
1367
1393
                default:
1368
1394
                case 8:
1369
 
                    ret = ldq_user_secondary(addr);
 
1395
                    ret = cpu_ldq_user_secondary(env, addr);
1370
1396
                    break;
1371
1397
                }
1372
1398
            } else {
1373
1399
                switch (size) {
1374
1400
                case 1:
1375
 
                    ret = ldub_user(addr);
 
1401
                    ret = cpu_ldub_user(env, addr);
1376
1402
                    break;
1377
1403
                case 2:
1378
 
                    ret = lduw_user(addr);
 
1404
                    ret = cpu_lduw_user(env, addr);
1379
1405
                    break;
1380
1406
                case 4:
1381
 
                    ret = ldl_user(addr);
 
1407
                    ret = cpu_ldl_user(env, addr);
1382
1408
                    break;
1383
1409
                default:
1384
1410
                case 8:
1385
 
                    ret = ldq_user(addr);
 
1411
                    ret = cpu_ldq_user(env, addr);
1386
1412
                    break;
1387
1413
                }
1388
1414
            }
1420
1446
        {
1421
1447
            switch (size) {
1422
1448
            case 1:
1423
 
                ret = ldub_nucleus(addr);
 
1449
                ret = cpu_ldub_nucleus(env, addr);
1424
1450
                break;
1425
1451
            case 2:
1426
 
                ret = lduw_nucleus(addr);
 
1452
                ret = cpu_lduw_nucleus(env, addr);
1427
1453
                break;
1428
1454
            case 4:
1429
 
                ret = ldl_nucleus(addr);
 
1455
                ret = cpu_ldl_nucleus(env, addr);
1430
1456
                break;
1431
1457
            default:
1432
1458
            case 8:
1433
 
                ret = ldq_nucleus(addr);
 
1459
                ret = cpu_ldq_nucleus(env, addr);
1434
1460
                break;
1435
1461
            }
1436
1462
            break;
1526
1552
            ret = env->dtlb[reg].tag;
1527
1553
            break;
1528
1554
        }
 
1555
    case 0x48: /* Interrupt dispatch, RO */
 
1556
        break;
 
1557
    case 0x49: /* Interrupt data receive */
 
1558
        ret = env->ivec_status;
 
1559
        break;
 
1560
    case 0x7f: /* Incoming interrupt vector, RO */
 
1561
        {
 
1562
            int reg = (addr >> 4) & 0x3;
 
1563
            if (reg < 3) {
 
1564
                ret = env->ivec_data[reg];
 
1565
            }
 
1566
            break;
 
1567
        }
1529
1568
    case 0x46: /* D-cache data */
1530
1569
    case 0x47: /* D-cache tag access */
1531
1570
    case 0x4b: /* E-cache error enable */
1540
1579
    case 0x7e: /* E-cache tag */
1541
1580
        break;
1542
1581
    case 0x5b: /* D-MMU data pointer */
1543
 
    case 0x48: /* Interrupt dispatch, RO */
1544
 
    case 0x49: /* Interrupt data receive */
1545
 
    case 0x7f: /* Incoming interrupt vector, RO */
1546
 
        /* XXX */
1547
 
        break;
1548
1582
    case 0x54: /* I-MMU data in, WO */
1549
1583
    case 0x57: /* I-MMU demap, WO */
1550
1584
    case 0x5c: /* D-MMU data in, WO */
1551
1585
    case 0x5f: /* D-MMU demap, WO */
1552
1586
    case 0x77: /* Interrupt vector, WO */
1553
1587
    default:
1554
 
        do_unassigned_access(addr, 0, 0, 1, size);
 
1588
        cpu_unassigned_access(env, addr, 0, 0, 1, size);
1555
1589
        ret = 0;
1556
1590
        break;
1557
1591
    }
1604
1638
    return ret;
1605
1639
}
1606
1640
 
1607
 
void helper_st_asi(target_ulong addr, target_ulong val, int asi, int size)
 
1641
void helper_st_asi(CPUSPARCState *env, target_ulong addr, target_ulong val,
 
1642
                   int asi, int size)
1608
1643
{
1609
1644
#ifdef DEBUG_ASI
1610
1645
    dump_asi("write", addr, asi, size, val);
1619
1654
        helper_raise_exception(env, TT_PRIV_ACT);
1620
1655
    }
1621
1656
 
1622
 
    helper_check_align(addr, size - 1);
 
1657
    helper_check_align(env, addr, size - 1);
1623
1658
    addr = asi_address_mask(env, asi, addr);
1624
1659
 
1625
1660
    /* Convert to little endian */
1663
1698
            if (cpu_hypervisor_mode(env)) {
1664
1699
                switch (size) {
1665
1700
                case 1:
1666
 
                    stb_hypv(addr, val);
 
1701
                    cpu_stb_hypv(env, addr, val);
1667
1702
                    break;
1668
1703
                case 2:
1669
 
                    stw_hypv(addr, val);
 
1704
                    cpu_stw_hypv(env, addr, val);
1670
1705
                    break;
1671
1706
                case 4:
1672
 
                    stl_hypv(addr, val);
 
1707
                    cpu_stl_hypv(env, addr, val);
1673
1708
                    break;
1674
1709
                case 8:
1675
1710
                default:
1676
 
                    stq_hypv(addr, val);
 
1711
                    cpu_stq_hypv(env, addr, val);
1677
1712
                    break;
1678
1713
                }
1679
1714
            } else {
1681
1716
                if (asi & 1) {
1682
1717
                    switch (size) {
1683
1718
                    case 1:
1684
 
                        stb_kernel_secondary(addr, val);
 
1719
                        cpu_stb_kernel_secondary(env, addr, val);
1685
1720
                        break;
1686
1721
                    case 2:
1687
 
                        stw_kernel_secondary(addr, val);
 
1722
                        cpu_stw_kernel_secondary(env, addr, val);
1688
1723
                        break;
1689
1724
                    case 4:
1690
 
                        stl_kernel_secondary(addr, val);
 
1725
                        cpu_stl_kernel_secondary(env, addr, val);
1691
1726
                        break;
1692
1727
                    case 8:
1693
1728
                    default:
1694
 
                        stq_kernel_secondary(addr, val);
 
1729
                        cpu_stq_kernel_secondary(env, addr, val);
1695
1730
                        break;
1696
1731
                    }
1697
1732
                } else {
1698
1733
                    switch (size) {
1699
1734
                    case 1:
1700
 
                        stb_kernel(addr, val);
 
1735
                        cpu_stb_kernel(env, addr, val);
1701
1736
                        break;
1702
1737
                    case 2:
1703
 
                        stw_kernel(addr, val);
 
1738
                        cpu_stw_kernel(env, addr, val);
1704
1739
                        break;
1705
1740
                    case 4:
1706
 
                        stl_kernel(addr, val);
 
1741
                        cpu_stl_kernel(env, addr, val);
1707
1742
                        break;
1708
1743
                    case 8:
1709
1744
                    default:
1710
 
                        stq_kernel(addr, val);
 
1745
                        cpu_stq_kernel(env, addr, val);
1711
1746
                        break;
1712
1747
                    }
1713
1748
                }
1717
1752
            if (asi & 1) {
1718
1753
                switch (size) {
1719
1754
                case 1:
1720
 
                    stb_user_secondary(addr, val);
 
1755
                    cpu_stb_user_secondary(env, addr, val);
1721
1756
                    break;
1722
1757
                case 2:
1723
 
                    stw_user_secondary(addr, val);
 
1758
                    cpu_stw_user_secondary(env, addr, val);
1724
1759
                    break;
1725
1760
                case 4:
1726
 
                    stl_user_secondary(addr, val);
 
1761
                    cpu_stl_user_secondary(env, addr, val);
1727
1762
                    break;
1728
1763
                case 8:
1729
1764
                default:
1730
 
                    stq_user_secondary(addr, val);
 
1765
                    cpu_stq_user_secondary(env, addr, val);
1731
1766
                    break;
1732
1767
                }
1733
1768
            } else {
1734
1769
                switch (size) {
1735
1770
                case 1:
1736
 
                    stb_user(addr, val);
 
1771
                    cpu_stb_user(env, addr, val);
1737
1772
                    break;
1738
1773
                case 2:
1739
 
                    stw_user(addr, val);
 
1774
                    cpu_stw_user(env, addr, val);
1740
1775
                    break;
1741
1776
                case 4:
1742
 
                    stl_user(addr, val);
 
1777
                    cpu_stl_user(env, addr, val);
1743
1778
                    break;
1744
1779
                case 8:
1745
1780
                default:
1746
 
                    stq_user(addr, val);
 
1781
                    cpu_stq_user(env, addr, val);
1747
1782
                    break;
1748
1783
                }
1749
1784
            }
1781
1816
        {
1782
1817
            switch (size) {
1783
1818
            case 1:
1784
 
                stb_nucleus(addr, val);
 
1819
                cpu_stb_nucleus(env, addr, val);
1785
1820
                break;
1786
1821
            case 2:
1787
 
                stw_nucleus(addr, val);
 
1822
                cpu_stw_nucleus(env, addr, val);
1788
1823
                break;
1789
1824
            case 4:
1790
 
                stl_nucleus(addr, val);
 
1825
                cpu_stl_nucleus(env, addr, val);
1791
1826
                break;
1792
1827
            default:
1793
1828
            case 8:
1794
 
                stq_nucleus(addr, val);
 
1829
                cpu_stq_nucleus(env, addr, val);
1795
1830
                break;
1796
1831
            }
1797
1832
            break;
1954
1989
        demap_tlb(env->dtlb, addr, "dmmu", env);
1955
1990
        return;
1956
1991
    case 0x49: /* Interrupt data receive */
1957
 
        /* XXX */
 
1992
        env->ivec_status = val & 0x20;
1958
1993
        return;
1959
1994
    case 0x46: /* D-cache data */
1960
1995
    case 0x47: /* D-cache tag access */
1983
2018
    case 0x8a: /* Primary no-fault LE, RO */
1984
2019
    case 0x8b: /* Secondary no-fault LE, RO */
1985
2020
    default:
1986
 
        do_unassigned_access(addr, 1, 0, 1, size);
 
2021
        cpu_unassigned_access(env, addr, 1, 0, 1, size);
1987
2022
        return;
1988
2023
    }
1989
2024
}
1990
2025
#endif /* CONFIG_USER_ONLY */
1991
2026
 
1992
 
void helper_ldda_asi(target_ulong addr, int asi, int rd)
 
2027
void helper_ldda_asi(CPUSPARCState *env, target_ulong addr, int asi, int rd)
1993
2028
{
1994
2029
    if ((asi < 0x80 && (env->pstate & PS_PRIV) == 0)
1995
2030
        || (cpu_has_hypervisor(env)
2004
2039
#if !defined(CONFIG_USER_ONLY)
2005
2040
    case 0x24: /* Nucleus quad LDD 128 bit atomic */
2006
2041
    case 0x2c: /* Nucleus quad LDD 128 bit atomic LE */
2007
 
        helper_check_align(addr, 0xf);
 
2042
        helper_check_align(env, addr, 0xf);
2008
2043
        if (rd == 0) {
2009
 
            env->gregs[1] = ldq_nucleus(addr + 8);
 
2044
            env->gregs[1] = cpu_ldq_nucleus(env, addr + 8);
2010
2045
            if (asi == 0x2c) {
2011
2046
                bswap64s(&env->gregs[1]);
2012
2047
            }
2013
2048
        } else if (rd < 8) {
2014
 
            env->gregs[rd] = ldq_nucleus(addr);
2015
 
            env->gregs[rd + 1] = ldq_nucleus(addr + 8);
 
2049
            env->gregs[rd] = cpu_ldq_nucleus(env, addr);
 
2050
            env->gregs[rd + 1] = cpu_ldq_nucleus(env, addr + 8);
2016
2051
            if (asi == 0x2c) {
2017
2052
                bswap64s(&env->gregs[rd]);
2018
2053
                bswap64s(&env->gregs[rd + 1]);
2019
2054
            }
2020
2055
        } else {
2021
 
            env->regwptr[rd] = ldq_nucleus(addr);
2022
 
            env->regwptr[rd + 1] = ldq_nucleus(addr + 8);
 
2056
            env->regwptr[rd] = cpu_ldq_nucleus(env, addr);
 
2057
            env->regwptr[rd + 1] = cpu_ldq_nucleus(env, addr + 8);
2023
2058
            if (asi == 0x2c) {
2024
2059
                bswap64s(&env->regwptr[rd]);
2025
2060
                bswap64s(&env->regwptr[rd + 1]);
2028
2063
        break;
2029
2064
#endif
2030
2065
    default:
2031
 
        helper_check_align(addr, 0x3);
 
2066
        helper_check_align(env, addr, 0x3);
2032
2067
        if (rd == 0) {
2033
 
            env->gregs[1] = helper_ld_asi(addr + 4, asi, 4, 0);
 
2068
            env->gregs[1] = helper_ld_asi(env, addr + 4, asi, 4, 0);
2034
2069
        } else if (rd < 8) {
2035
 
            env->gregs[rd] = helper_ld_asi(addr, asi, 4, 0);
2036
 
            env->gregs[rd + 1] = helper_ld_asi(addr + 4, asi, 4, 0);
 
2070
            env->gregs[rd] = helper_ld_asi(env, addr, asi, 4, 0);
 
2071
            env->gregs[rd + 1] = helper_ld_asi(env, addr + 4, asi, 4, 0);
2037
2072
        } else {
2038
 
            env->regwptr[rd] = helper_ld_asi(addr, asi, 4, 0);
2039
 
            env->regwptr[rd + 1] = helper_ld_asi(addr + 4, asi, 4, 0);
 
2073
            env->regwptr[rd] = helper_ld_asi(env, addr, asi, 4, 0);
 
2074
            env->regwptr[rd + 1] = helper_ld_asi(env, addr + 4, asi, 4, 0);
2040
2075
        }
2041
2076
        break;
2042
2077
    }
2043
2078
}
2044
2079
 
2045
 
void helper_ldf_asi(target_ulong addr, int asi, int size, int rd)
 
2080
void helper_ldf_asi(CPUSPARCState *env, target_ulong addr, int asi, int size,
 
2081
                    int rd)
2046
2082
{
2047
2083
    unsigned int i;
2048
2084
    target_ulong val;
2049
2085
 
2050
 
    helper_check_align(addr, 3);
 
2086
    helper_check_align(env, addr, 3);
2051
2087
    addr = asi_address_mask(env, asi, addr);
2052
2088
 
2053
2089
    switch (asi) {
2059
2095
            helper_raise_exception(env, TT_ILL_INSN);
2060
2096
            return;
2061
2097
        }
2062
 
        helper_check_align(addr, 0x3f);
 
2098
        helper_check_align(env, addr, 0x3f);
2063
2099
        for (i = 0; i < 8; i++, rd += 2, addr += 8) {
2064
 
            env->fpr[rd/2].ll = helper_ld_asi(addr, asi & 0x8f, 8, 0);
 
2100
            env->fpr[rd / 2].ll = helper_ld_asi(env, addr, asi & 0x8f, 8, 0);
2065
2101
        }
2066
2102
        return;
2067
2103
 
2077
2113
            helper_raise_exception(env, TT_ILL_INSN);
2078
2114
            return;
2079
2115
        }
2080
 
        helper_check_align(addr, 0x3f);
2081
 
        for (i = 0; i < 8; i++, rd += 2, addr += 4) {
2082
 
            env->fpr[rd/2].ll = helper_ld_asi(addr, asi & 0x19, 8, 0);
 
2116
        helper_check_align(env, addr, 0x3f);
 
2117
        for (i = 0; i < 8; i++, rd += 2, addr += 8) {
 
2118
            env->fpr[rd / 2].ll = helper_ld_asi(env, addr, asi & 0x19, 8, 0);
2083
2119
        }
2084
2120
        return;
2085
2121
 
2090
2126
    switch (size) {
2091
2127
    default:
2092
2128
    case 4:
2093
 
        val = helper_ld_asi(addr, asi, size, 0);
 
2129
        val = helper_ld_asi(env, addr, asi, size, 0);
2094
2130
        if (rd & 1) {
2095
 
            env->fpr[rd/2].l.lower = val;
 
2131
            env->fpr[rd / 2].l.lower = val;
2096
2132
        } else {
2097
 
            env->fpr[rd/2].l.upper = val;
 
2133
            env->fpr[rd / 2].l.upper = val;
2098
2134
        }
2099
2135
        break;
2100
2136
    case 8:
2101
 
        env->fpr[rd/2].ll = helper_ld_asi(addr, asi, size, 0);
 
2137
        env->fpr[rd / 2].ll = helper_ld_asi(env, addr, asi, size, 0);
2102
2138
        break;
2103
2139
    case 16:
2104
 
        env->fpr[rd/2].ll = helper_ld_asi(addr, asi, 8, 0);
2105
 
        env->fpr[rd/2 + 1].ll = helper_ld_asi(addr + 8, asi, 8, 0);
 
2140
        env->fpr[rd / 2].ll = helper_ld_asi(env, addr, asi, 8, 0);
 
2141
        env->fpr[rd / 2 + 1].ll = helper_ld_asi(env, addr + 8, asi, 8, 0);
2106
2142
        break;
2107
2143
    }
2108
2144
}
2109
2145
 
2110
 
void helper_stf_asi(target_ulong addr, int asi, int size, int rd)
 
2146
void helper_stf_asi(CPUSPARCState *env, target_ulong addr, int asi, int size,
 
2147
                    int rd)
2111
2148
{
2112
2149
    unsigned int i;
2113
2150
    target_ulong val;
2114
2151
 
2115
 
    helper_check_align(addr, 3);
 
2152
    helper_check_align(env, addr, 3);
2116
2153
    addr = asi_address_mask(env, asi, addr);
2117
2154
 
2118
2155
    switch (asi) {
2126
2163
            helper_raise_exception(env, TT_ILL_INSN);
2127
2164
            return;
2128
2165
        }
2129
 
        helper_check_align(addr, 0x3f);
 
2166
        helper_check_align(env, addr, 0x3f);
2130
2167
        for (i = 0; i < 8; i++, rd += 2, addr += 8) {
2131
 
            helper_st_asi(addr, env->fpr[rd/2].ll, asi & 0x8f, 8);
 
2168
            helper_st_asi(env, addr, env->fpr[rd / 2].ll, asi & 0x8f, 8);
2132
2169
        }
2133
2170
 
2134
2171
        return;
2144
2181
            helper_raise_exception(env, TT_ILL_INSN);
2145
2182
            return;
2146
2183
        }
2147
 
        helper_check_align(addr, 0x3f);
 
2184
        helper_check_align(env, addr, 0x3f);
2148
2185
        for (i = 0; i < 8; i++, rd += 2, addr += 8) {
2149
 
            helper_st_asi(addr, env->fpr[rd/2].ll, asi & 0x19, 8);
 
2186
            helper_st_asi(env, addr, env->fpr[rd / 2].ll, asi & 0x19, 8);
2150
2187
        }
2151
2188
 
2152
2189
        return;
2158
2195
    default:
2159
2196
    case 4:
2160
2197
        if (rd & 1) {
2161
 
            val = env->fpr[rd/2].l.lower;
 
2198
            val = env->fpr[rd / 2].l.lower;
2162
2199
        } else {
2163
 
            val = env->fpr[rd/2].l.upper;
 
2200
            val = env->fpr[rd / 2].l.upper;
2164
2201
        }
2165
 
        helper_st_asi(addr, val, asi, size);
 
2202
        helper_st_asi(env, addr, val, asi, size);
2166
2203
        break;
2167
2204
    case 8:
2168
 
        helper_st_asi(addr, env->fpr[rd/2].ll, asi, size);
 
2205
        helper_st_asi(env, addr, env->fpr[rd / 2].ll, asi, size);
2169
2206
        break;
2170
2207
    case 16:
2171
 
        helper_st_asi(addr, env->fpr[rd/2].ll, asi, 8);
2172
 
        helper_st_asi(addr + 8, env->fpr[rd/2 + 1].ll, asi, 8);
 
2208
        helper_st_asi(env, addr, env->fpr[rd / 2].ll, asi, 8);
 
2209
        helper_st_asi(env, addr + 8, env->fpr[rd / 2 + 1].ll, asi, 8);
2173
2210
        break;
2174
2211
    }
2175
2212
}
2176
2213
 
2177
 
target_ulong helper_cas_asi(target_ulong addr, target_ulong val1,
2178
 
                            target_ulong val2, uint32_t asi)
 
2214
target_ulong helper_cas_asi(CPUSPARCState *env, target_ulong addr,
 
2215
                            target_ulong val1, target_ulong val2, uint32_t asi)
2179
2216
{
2180
2217
    target_ulong ret;
2181
2218
 
2182
2219
    val2 &= 0xffffffffUL;
2183
 
    ret = helper_ld_asi(addr, asi, 4, 0);
 
2220
    ret = helper_ld_asi(env, addr, asi, 4, 0);
2184
2221
    ret &= 0xffffffffUL;
2185
2222
    if (val2 == ret) {
2186
 
        helper_st_asi(addr, val1 & 0xffffffffUL, asi, 4);
 
2223
        helper_st_asi(env, addr, val1 & 0xffffffffUL, asi, 4);
2187
2224
    }
2188
2225
    return ret;
2189
2226
}
2190
2227
 
2191
 
target_ulong helper_casx_asi(target_ulong addr, target_ulong val1,
2192
 
                             target_ulong val2, uint32_t asi)
 
2228
target_ulong helper_casx_asi(CPUSPARCState *env, target_ulong addr,
 
2229
                             target_ulong val1, target_ulong val2,
 
2230
                             uint32_t asi)
2193
2231
{
2194
2232
    target_ulong ret;
2195
2233
 
2196
 
    ret = helper_ld_asi(addr, asi, 8, 0);
 
2234
    ret = helper_ld_asi(env, addr, asi, 8, 0);
2197
2235
    if (val2 == ret) {
2198
 
        helper_st_asi(addr, val1, asi, 8);
 
2236
        helper_st_asi(env, addr, val1, asi, 8);
2199
2237
    }
2200
2238
    return ret;
2201
2239
}
2202
2240
#endif /* TARGET_SPARC64 */
2203
2241
 
2204
 
void helper_ldqf(target_ulong addr, int mem_idx)
 
2242
void helper_ldqf(CPUSPARCState *env, target_ulong addr, int mem_idx)
2205
2243
{
2206
2244
    /* XXX add 128 bit load */
2207
2245
    CPU_QuadU u;
2208
2246
 
2209
 
    helper_check_align(addr, 7);
 
2247
    helper_check_align(env, addr, 7);
2210
2248
#if !defined(CONFIG_USER_ONLY)
2211
2249
    switch (mem_idx) {
2212
2250
    case MMU_USER_IDX:
2213
 
        u.ll.upper = ldq_user(addr);
2214
 
        u.ll.lower = ldq_user(addr + 8);
 
2251
        u.ll.upper = cpu_ldq_user(env, addr);
 
2252
        u.ll.lower = cpu_ldq_user(env, addr + 8);
2215
2253
        QT0 = u.q;
2216
2254
        break;
2217
2255
    case MMU_KERNEL_IDX:
2218
 
        u.ll.upper = ldq_kernel(addr);
2219
 
        u.ll.lower = ldq_kernel(addr + 8);
 
2256
        u.ll.upper = cpu_ldq_kernel(env, addr);
 
2257
        u.ll.lower = cpu_ldq_kernel(env, addr + 8);
2220
2258
        QT0 = u.q;
2221
2259
        break;
2222
2260
#ifdef TARGET_SPARC64
2223
2261
    case MMU_HYPV_IDX:
2224
 
        u.ll.upper = ldq_hypv(addr);
2225
 
        u.ll.lower = ldq_hypv(addr + 8);
 
2262
        u.ll.upper = cpu_ldq_hypv(env, addr);
 
2263
        u.ll.lower = cpu_ldq_hypv(env, addr + 8);
2226
2264
        QT0 = u.q;
2227
2265
        break;
2228
2266
#endif
2237
2275
#endif
2238
2276
}
2239
2277
 
2240
 
void helper_stqf(target_ulong addr, int mem_idx)
 
2278
void helper_stqf(CPUSPARCState *env, target_ulong addr, int mem_idx)
2241
2279
{
2242
2280
    /* XXX add 128 bit store */
2243
2281
    CPU_QuadU u;
2244
2282
 
2245
 
    helper_check_align(addr, 7);
 
2283
    helper_check_align(env, addr, 7);
2246
2284
#if !defined(CONFIG_USER_ONLY)
2247
2285
    switch (mem_idx) {
2248
2286
    case MMU_USER_IDX:
2249
2287
        u.q = QT0;
2250
 
        stq_user(addr, u.ll.upper);
2251
 
        stq_user(addr + 8, u.ll.lower);
 
2288
        cpu_stq_user(env, addr, u.ll.upper);
 
2289
        cpu_stq_user(env, addr + 8, u.ll.lower);
2252
2290
        break;
2253
2291
    case MMU_KERNEL_IDX:
2254
2292
        u.q = QT0;
2255
 
        stq_kernel(addr, u.ll.upper);
2256
 
        stq_kernel(addr + 8, u.ll.lower);
 
2293
        cpu_stq_kernel(env, addr, u.ll.upper);
 
2294
        cpu_stq_kernel(env, addr + 8, u.ll.lower);
2257
2295
        break;
2258
2296
#ifdef TARGET_SPARC64
2259
2297
    case MMU_HYPV_IDX:
2260
2298
        u.q = QT0;
2261
 
        stq_hypv(addr, u.ll.upper);
2262
 
        stq_hypv(addr + 8, u.ll.lower);
 
2299
        cpu_stq_hypv(env, addr, u.ll.upper);
 
2300
        cpu_stq_hypv(env, addr + 8, u.ll.lower);
2263
2301
        break;
2264
2302
#endif
2265
2303
    default:
2273
2311
#endif
2274
2312
}
2275
2313
 
 
2314
#if !defined(CONFIG_USER_ONLY)
2276
2315
#ifndef TARGET_SPARC64
2277
 
#if !defined(CONFIG_USER_ONLY)
2278
 
static void do_unassigned_access(target_phys_addr_t addr, int is_write,
2279
 
                                 int is_exec, int is_asi, int size)
 
2316
void cpu_unassigned_access(CPUSPARCState *env, target_phys_addr_t addr,
 
2317
                           int is_write, int is_exec, int is_asi, int size)
2280
2318
{
2281
2319
    int fault_type;
2282
2320
 
2334
2372
        tlb_flush(env, 1);
2335
2373
    }
2336
2374
}
2337
 
#endif
2338
 
#else
2339
 
#if defined(CONFIG_USER_ONLY)
2340
 
static void do_unassigned_access(target_ulong addr, int is_write, int is_exec,
2341
 
                                 int is_asi, int size)
2342
 
#else
2343
 
static void do_unassigned_access(target_phys_addr_t addr, int is_write,
2344
 
                                 int is_exec, int is_asi, int size)
2345
 
#endif
 
2375
#else
 
2376
void cpu_unassigned_access(CPUSPARCState *env, target_phys_addr_t addr,
 
2377
                           int is_write, int is_exec, int is_asi, int size)
2346
2378
{
2347
2379
#ifdef DEBUG_UNASSIGNED
2348
2380
    printf("Unassigned mem access to " TARGET_FMT_plx " from " TARGET_FMT_lx
2356
2388
    }
2357
2389
}
2358
2390
#endif
 
2391
#endif
2359
2392
 
2360
2393
#if !defined(CONFIG_USER_ONLY)
2361
 
void cpu_unassigned_access(CPUState *env1, target_phys_addr_t addr,
2362
 
                           int is_write, int is_exec, int is_asi, int size)
2363
 
{
2364
 
    CPUState *saved_env;
2365
 
 
2366
 
    saved_env = env;
2367
 
    env = env1;
2368
 
    do_unassigned_access(addr, is_write, is_exec, is_asi, size);
2369
 
    env = saved_env;
 
2394
/* XXX: make it generic ? */
 
2395
static void cpu_restore_state2(CPUSPARCState *env, uintptr_t retaddr)
 
2396
{
 
2397
    TranslationBlock *tb;
 
2398
 
 
2399
    if (retaddr) {
 
2400
        /* now we have a real cpu fault */
 
2401
        tb = tb_find_pc(retaddr);
 
2402
        if (tb) {
 
2403
            /* the PC is inside the translated code. It means that we have
 
2404
               a virtual CPU fault */
 
2405
            cpu_restore_state(tb, env, retaddr);
 
2406
        }
 
2407
    }
 
2408
}
 
2409
 
 
2410
void do_unaligned_access(CPUSPARCState *env, target_ulong addr, int is_write,
 
2411
                         int is_user, uintptr_t retaddr)
 
2412
{
 
2413
#ifdef DEBUG_UNALIGNED
 
2414
    printf("Unaligned access to 0x" TARGET_FMT_lx " from 0x" TARGET_FMT_lx
 
2415
           "\n", addr, env->pc);
 
2416
#endif
 
2417
    cpu_restore_state2(env, retaddr);
 
2418
    helper_raise_exception(env, TT_UNALIGNED);
 
2419
}
 
2420
 
 
2421
/* try to fill the TLB and return an exception if error. If retaddr is
 
2422
   NULL, it means that the function was called in C code (i.e. not
 
2423
   from generated code or from helper.c) */
 
2424
/* XXX: fix it to restore all registers */
 
2425
void tlb_fill(CPUSPARCState *env, target_ulong addr, int is_write, int mmu_idx,
 
2426
              uintptr_t retaddr)
 
2427
{
 
2428
    int ret;
 
2429
 
 
2430
    ret = cpu_sparc_handle_mmu_fault(env, addr, is_write, mmu_idx);
 
2431
    if (ret) {
 
2432
        cpu_restore_state2(env, retaddr);
 
2433
        cpu_loop_exit(env);
 
2434
    }
2370
2435
}
2371
2436
#endif