← Back to branch summary

~ubuntu-branches/ubuntu/saucy/qemu/saucy-proposed

« back to all changes in this revision

Viewing changes to target-arm/machine.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-05-28 08:18:30 UTC
  • mfrom: (1.8.2) (10.1.37 sid)
  • Revision ID: package-import@ubuntu.com-20130528081830-87xl2z9fq516a814
Tags: 1.5.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.5.0+dfs-2 from debian unstable.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - Dropped patches:
    * 0001-fix-wrong-output-with-info-chardev-for-tcp-socket.patch
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * gridcentric patch - updated
    * linaro arm patches from qemu-linaro rebasing branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-arm/machine.c
1
1
#include "hw/hw.h"
2
2
#include "hw/boards.h"
3
3
 
4
 
void cpu_save(QEMUFile *f, void *opaque)
5
 
{
6
 
    int i;
7
 
    CPUARMState *env = (CPUARMState *)opaque;
8
 
 
9
 
    for (i = 0; i < 16; i++) {
10
 
        qemu_put_be32(f, env->regs[i]);
11
 
    }
12
 
    qemu_put_be32(f, cpsr_read(env));
13
 
    qemu_put_be32(f, env->spsr);
14
 
    for (i = 0; i < 6; i++) {
15
 
        qemu_put_be32(f, env->banked_spsr[i]);
16
 
        qemu_put_be32(f, env->banked_r13[i]);
17
 
        qemu_put_be32(f, env->banked_r14[i]);
18
 
    }
19
 
    for (i = 0; i < 5; i++) {
20
 
        qemu_put_be32(f, env->usr_regs[i]);
21
 
        qemu_put_be32(f, env->fiq_regs[i]);
22
 
    }
23
 
    qemu_put_be32(f, env->cp15.c0_cpuid);
24
 
    qemu_put_be32(f, env->cp15.c0_cssel);
25
 
    qemu_put_be32(f, env->cp15.c1_sys);
26
 
    qemu_put_be32(f, env->cp15.c1_coproc);
27
 
    qemu_put_be32(f, env->cp15.c1_xscaleauxcr);
28
 
    qemu_put_be32(f, env->cp15.c1_scr);
29
 
    qemu_put_be32(f, env->cp15.c1_sedbg);
30
 
    qemu_put_be32(f, env->cp15.c1_nseac);
31
 
    qemu_put_be32(f, env->cp15.c2_base0);
32
 
    qemu_put_be32(f, env->cp15.c2_base0_hi);
33
 
    qemu_put_be32(f, env->cp15.c2_base1);
34
 
    qemu_put_be32(f, env->cp15.c2_base1_hi);
35
 
    qemu_put_be32(f, env->cp15.c2_control);
36
 
    qemu_put_be32(f, env->cp15.c2_mask);
37
 
    qemu_put_be32(f, env->cp15.c2_base_mask);
38
 
    qemu_put_be32(f, env->cp15.c2_data);
39
 
    qemu_put_be32(f, env->cp15.c2_insn);
40
 
    qemu_put_be32(f, env->cp15.c3);
41
 
    qemu_put_be32(f, env->cp15.c5_insn);
42
 
    qemu_put_be32(f, env->cp15.c5_data);
43
 
    for (i = 0; i < 8; i++) {
44
 
        qemu_put_be32(f, env->cp15.c6_region[i]);
45
 
    }
46
 
    qemu_put_be32(f, env->cp15.c6_insn);
47
 
    qemu_put_be32(f, env->cp15.c6_data);
48
 
    qemu_put_be32(f, env->cp15.c7_par);
49
 
    qemu_put_be32(f, env->cp15.c7_par_hi);
50
 
    qemu_put_be32(f, env->cp15.c9_insn);
51
 
    qemu_put_be32(f, env->cp15.c9_data);
52
 
    qemu_put_be32(f, env->cp15.c9_pmcr);
53
 
    qemu_put_be32(f, env->cp15.c9_pmcnten);
54
 
    qemu_put_be32(f, env->cp15.c9_pmovsr);
55
 
    qemu_put_be32(f, env->cp15.c9_pmxevtyper);
56
 
    qemu_put_be32(f, env->cp15.c9_pmuserenr);
57
 
    qemu_put_be32(f, env->cp15.c9_pminten);
58
 
    qemu_put_be32(f, env->cp15.c13_fcse);
59
 
    qemu_put_be32(f, env->cp15.c13_context);
60
 
    qemu_put_be32(f, env->cp15.c13_tls1);
61
 
    qemu_put_be32(f, env->cp15.c13_tls2);
62
 
    qemu_put_be32(f, env->cp15.c13_tls3);
63
 
    qemu_put_be32(f, env->cp15.c15_cpar);
64
 
    qemu_put_be32(f, env->cp15.c15_power_control);
65
 
    qemu_put_be32(f, env->cp15.c15_diagnostic);
66
 
    qemu_put_be32(f, env->cp15.c15_power_diagnostic);
67
 
 
68
 
    qemu_put_be64(f, env->features);
69
 
 
70
 
    if (arm_feature(env, ARM_FEATURE_VFP)) {
71
 
        for (i = 0;  i < 16; i++) {
72
 
            CPU_DoubleU u;
73
 
            u.d = env->vfp.regs[i];
74
 
            qemu_put_be32(f, u.l.upper);
75
 
            qemu_put_be32(f, u.l.lower);
76
 
        }
77
 
        for (i = 0; i < 16; i++) {
78
 
            qemu_put_be32(f, env->vfp.xregs[i]);
79
 
        }
80
 
 
81
 
        /* TODO: Should use proper FPSCR access functions.  */
82
 
        qemu_put_be32(f, env->vfp.vec_len);
83
 
        qemu_put_be32(f, env->vfp.vec_stride);
84
 
 
85
 
        if (arm_feature(env, ARM_FEATURE_VFP3)) {
86
 
            for (i = 16;  i < 32; i++) {
87
 
                CPU_DoubleU u;
88
 
                u.d = env->vfp.regs[i];
89
 
                qemu_put_be32(f, u.l.upper);
90
 
                qemu_put_be32(f, u.l.lower);
91
 
            }
92
 
        }
93
 
    }
94
 
 
95
 
    if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
96
 
        for (i = 0; i < 16; i++) {
97
 
            qemu_put_be64(f, env->iwmmxt.regs[i]);
98
 
        }
99
 
        for (i = 0; i < 16; i++) {
100
 
            qemu_put_be32(f, env->iwmmxt.cregs[i]);
101
 
        }
102
 
    }
103
 
 
104
 
    if (arm_feature(env, ARM_FEATURE_M)) {
105
 
        qemu_put_be32(f, env->v7m.other_sp);
106
 
        qemu_put_be32(f, env->v7m.vecbase);
107
 
        qemu_put_be32(f, env->v7m.basepri);
108
 
        qemu_put_be32(f, env->v7m.control);
109
 
        qemu_put_be32(f, env->v7m.current_sp);
110
 
        qemu_put_be32(f, env->v7m.exception);
111
 
    }
112
 
 
113
 
    if (arm_feature(env, ARM_FEATURE_THUMB2EE)) {
114
 
        qemu_put_be32(f, env->teecr);
115
 
        qemu_put_be32(f, env->teehbr);
116
 
    }
117
 
}
118
 
 
119
 
int cpu_load(QEMUFile *f, void *opaque, int version_id)
120
 
{
121
 
    CPUARMState *env = (CPUARMState *)opaque;
122
 
    int i;
123
 
    uint32_t val;
124
 
 
125
 
    if (version_id != CPU_SAVE_VERSION)
126
 
        return -EINVAL;
127
 
 
128
 
    for (i = 0; i < 16; i++) {
129
 
        env->regs[i] = qemu_get_be32(f);
130
 
    }
131
 
    val = qemu_get_be32(f);
132
 
    /* Avoid mode switch when restoring CPSR.  */
 
4
static bool vfp_needed(void *opaque)
 
5
{
 
6
    ARMCPU *cpu = opaque;
 
7
    CPUARMState *env = &cpu->env;
 
8
 
 
9
    return arm_feature(env, ARM_FEATURE_VFP);
 
10
}
 
11
 
 
12
static int get_fpscr(QEMUFile *f, void *opaque, size_t size)
 
13
{
 
14
    ARMCPU *cpu = opaque;
 
15
    CPUARMState *env = &cpu->env;
 
16
    uint32_t val = qemu_get_be32(f);
 
17
 
 
18
    vfp_set_fpscr(env, val);
 
19
    return 0;
 
20
}
 
21
 
 
22
static void put_fpscr(QEMUFile *f, void *opaque, size_t size)
 
23
{
 
24
    ARMCPU *cpu = opaque;
 
25
    CPUARMState *env = &cpu->env;
 
26
 
 
27
    qemu_put_be32(f, vfp_get_fpscr(env));
 
28
}
 
29
 
 
30
static const VMStateInfo vmstate_fpscr = {
 
31
    .name = "fpscr",
 
32
    .get = get_fpscr,
 
33
    .put = put_fpscr,
 
34
};
 
35
 
 
36
static const VMStateDescription vmstate_vfp = {
 
37
    .name = "cpu/vfp",
 
38
    .version_id = 2,
 
39
    .minimum_version_id = 2,
 
40
    .minimum_version_id_old = 2,
 
41
    .fields = (VMStateField[]) {
 
42
        VMSTATE_FLOAT64_ARRAY(env.vfp.regs, ARMCPU, 32),
 
43
        /* The xregs array is a little awkward because element 1 (FPSCR)
 
44
         * requires a specific accessor, so we have to split it up in
 
45
         * the vmstate:
 
46
         */
 
47
        VMSTATE_UINT32(env.vfp.xregs[0], ARMCPU),
 
48
        VMSTATE_UINT32_SUB_ARRAY(env.vfp.xregs, ARMCPU, 2, 14),
 
49
        {
 
50
            .name = "fpscr",
 
51
            .version_id = 0,
 
52
            .size = sizeof(uint32_t),
 
53
            .info = &vmstate_fpscr,
 
54
            .flags = VMS_SINGLE,
 
55
            .offset = 0,
 
56
        },
 
57
        VMSTATE_END_OF_LIST()
 
58
    }
 
59
};
 
60
 
 
61
static bool iwmmxt_needed(void *opaque)
 
62
{
 
63
    ARMCPU *cpu = opaque;
 
64
    CPUARMState *env = &cpu->env;
 
65
 
 
66
    return arm_feature(env, ARM_FEATURE_IWMMXT);
 
67
}
 
68
 
 
69
static const VMStateDescription vmstate_iwmmxt = {
 
70
    .name = "cpu/iwmmxt",
 
71
    .version_id = 1,
 
72
    .minimum_version_id = 1,
 
73
    .minimum_version_id_old = 1,
 
74
    .fields = (VMStateField[]) {
 
75
        VMSTATE_UINT64_ARRAY(env.iwmmxt.regs, ARMCPU, 16),
 
76
        VMSTATE_UINT32_ARRAY(env.iwmmxt.cregs, ARMCPU, 16),
 
77
        VMSTATE_END_OF_LIST()
 
78
    }
 
79
};
 
80
 
 
81
static bool m_needed(void *opaque)
 
82
{
 
83
    ARMCPU *cpu = opaque;
 
84
    CPUARMState *env = &cpu->env;
 
85
 
 
86
    return arm_feature(env, ARM_FEATURE_M);
 
87
}
 
88
 
 
89
const VMStateDescription vmstate_m = {
 
90
    .name = "cpu/m",
 
91
    .version_id = 1,
 
92
    .minimum_version_id = 1,
 
93
    .minimum_version_id_old = 1,
 
94
    .fields = (VMStateField[]) {
 
95
        VMSTATE_UINT32(env.v7m.other_sp, ARMCPU),
 
96
        VMSTATE_UINT32(env.v7m.vecbase, ARMCPU),
 
97
        VMSTATE_UINT32(env.v7m.basepri, ARMCPU),
 
98
        VMSTATE_UINT32(env.v7m.control, ARMCPU),
 
99
        VMSTATE_INT32(env.v7m.current_sp, ARMCPU),
 
100
        VMSTATE_INT32(env.v7m.exception, ARMCPU),
 
101
        VMSTATE_END_OF_LIST()
 
102
    }
 
103
};
 
104
 
 
105
static bool thumb2ee_needed(void *opaque)
 
106
{
 
107
    ARMCPU *cpu = opaque;
 
108
    CPUARMState *env = &cpu->env;
 
109
 
 
110
    return arm_feature(env, ARM_FEATURE_THUMB2EE);
 
111
}
 
112
 
 
113
static const VMStateDescription vmstate_thumb2ee = {
 
114
    .name = "cpu/thumb2ee",
 
115
    .version_id = 1,
 
116
    .minimum_version_id = 1,
 
117
    .minimum_version_id_old = 1,
 
118
    .fields = (VMStateField[]) {
 
119
        VMSTATE_UINT32(env.teecr, ARMCPU),
 
120
        VMSTATE_UINT32(env.teehbr, ARMCPU),
 
121
        VMSTATE_END_OF_LIST()
 
122
    }
 
123
};
 
124
 
 
125
static int get_cpsr(QEMUFile *f, void *opaque, size_t size)
 
126
{
 
127
    ARMCPU *cpu = opaque;
 
128
    CPUARMState *env = &cpu->env;
 
129
    uint32_t val = qemu_get_be32(f);
 
130
 
 
131
    /* Avoid mode switch when restoring CPSR */
133
132
    env->uncached_cpsr = val & CPSR_M;
134
133
    cpsr_write(env, val, 0xffffffff);
135
 
    env->spsr = qemu_get_be32(f);
136
 
    for (i = 0; i < 6; i++) {
137
 
        env->banked_spsr[i] = qemu_get_be32(f);
138
 
        env->banked_r13[i] = qemu_get_be32(f);
139
 
        env->banked_r14[i] = qemu_get_be32(f);
140
 
    }
141
 
    for (i = 0; i < 5; i++) {
142
 
        env->usr_regs[i] = qemu_get_be32(f);
143
 
        env->fiq_regs[i] = qemu_get_be32(f);
144
 
    }
145
 
    env->cp15.c0_cpuid = qemu_get_be32(f);
146
 
    env->cp15.c0_cssel = qemu_get_be32(f);
147
 
    env->cp15.c1_sys = qemu_get_be32(f);
148
 
    env->cp15.c1_coproc = qemu_get_be32(f);
149
 
    env->cp15.c1_xscaleauxcr = qemu_get_be32(f);
150
 
    env->cp15.c1_scr = qemu_get_be32(f);
151
 
    env->cp15.c1_sedbg = qemu_get_be32(f);
152
 
    env->cp15.c1_nseac = qemu_get_be32(f);
153
 
    env->cp15.c2_base0 = qemu_get_be32(f);
154
 
    env->cp15.c2_base0_hi = qemu_get_be32(f);
155
 
    env->cp15.c2_base1 = qemu_get_be32(f);
156
 
    env->cp15.c2_base1_hi = qemu_get_be32(f);
157
 
    env->cp15.c2_control = qemu_get_be32(f);
158
 
    env->cp15.c2_mask = qemu_get_be32(f);
159
 
    env->cp15.c2_base_mask = qemu_get_be32(f);
160
 
    env->cp15.c2_data = qemu_get_be32(f);
161
 
    env->cp15.c2_insn = qemu_get_be32(f);
162
 
    env->cp15.c3 = qemu_get_be32(f);
163
 
    env->cp15.c5_insn = qemu_get_be32(f);
164
 
    env->cp15.c5_data = qemu_get_be32(f);
165
 
    for (i = 0; i < 8; i++) {
166
 
        env->cp15.c6_region[i] = qemu_get_be32(f);
167
 
    }
168
 
    env->cp15.c6_insn = qemu_get_be32(f);
169
 
    env->cp15.c6_data = qemu_get_be32(f);
170
 
    env->cp15.c7_par = qemu_get_be32(f);
171
 
    env->cp15.c7_par_hi = qemu_get_be32(f);
172
 
    env->cp15.c9_insn = qemu_get_be32(f);
173
 
    env->cp15.c9_data = qemu_get_be32(f);
174
 
    env->cp15.c9_pmcr = qemu_get_be32(f);
175
 
    env->cp15.c9_pmcnten = qemu_get_be32(f);
176
 
    env->cp15.c9_pmovsr = qemu_get_be32(f);
177
 
    env->cp15.c9_pmxevtyper = qemu_get_be32(f);
178
 
    env->cp15.c9_pmuserenr = qemu_get_be32(f);
179
 
    env->cp15.c9_pminten = qemu_get_be32(f);
180
 
    env->cp15.c13_fcse = qemu_get_be32(f);
181
 
    env->cp15.c13_context = qemu_get_be32(f);
182
 
    env->cp15.c13_tls1 = qemu_get_be32(f);
183
 
    env->cp15.c13_tls2 = qemu_get_be32(f);
184
 
    env->cp15.c13_tls3 = qemu_get_be32(f);
185
 
    env->cp15.c15_cpar = qemu_get_be32(f);
186
 
    env->cp15.c15_power_control = qemu_get_be32(f);
187
 
    env->cp15.c15_diagnostic = qemu_get_be32(f);
188
 
    env->cp15.c15_power_diagnostic = qemu_get_be32(f);
189
 
 
190
 
    env->features = qemu_get_be64(f);
191
 
 
192
 
    if (arm_feature(env, ARM_FEATURE_VFP)) {
193
 
        for (i = 0;  i < 16; i++) {
194
 
            CPU_DoubleU u;
195
 
            u.l.upper = qemu_get_be32(f);
196
 
            u.l.lower = qemu_get_be32(f);
197
 
            env->vfp.regs[i] = u.d;
198
 
        }
199
 
        for (i = 0; i < 16; i++) {
200
 
            env->vfp.xregs[i] = qemu_get_be32(f);
201
 
        }
202
 
 
203
 
        /* TODO: Should use proper FPSCR access functions.  */
204
 
        env->vfp.vec_len = qemu_get_be32(f);
205
 
        env->vfp.vec_stride = qemu_get_be32(f);
206
 
 
207
 
        if (arm_feature(env, ARM_FEATURE_VFP3)) {
208
 
            for (i = 16;  i < 32; i++) {
209
 
                CPU_DoubleU u;
210
 
                u.l.upper = qemu_get_be32(f);
211
 
                u.l.lower = qemu_get_be32(f);
212
 
                env->vfp.regs[i] = u.d;
213
 
            }
214
 
        }
215
 
    }
216
 
 
217
 
    if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
218
 
        for (i = 0; i < 16; i++) {
219
 
            env->iwmmxt.regs[i] = qemu_get_be64(f);
220
 
        }
221
 
        for (i = 0; i < 16; i++) {
222
 
            env->iwmmxt.cregs[i] = qemu_get_be32(f);
223
 
        }
224
 
    }
225
 
 
226
 
    if (arm_feature(env, ARM_FEATURE_M)) {
227
 
        env->v7m.other_sp = qemu_get_be32(f);
228
 
        env->v7m.vecbase = qemu_get_be32(f);
229
 
        env->v7m.basepri = qemu_get_be32(f);
230
 
        env->v7m.control = qemu_get_be32(f);
231
 
        env->v7m.current_sp = qemu_get_be32(f);
232
 
        env->v7m.exception = qemu_get_be32(f);
233
 
    }
234
 
 
235
 
    if (arm_feature(env, ARM_FEATURE_THUMB2EE)) {
236
 
        env->teecr = qemu_get_be32(f);
237
 
        env->teehbr = qemu_get_be32(f);
238
 
    }
239
 
 
240
134
    return 0;
241
135
}
 
136
 
 
137
static void put_cpsr(QEMUFile *f, void *opaque, size_t size)
 
138
{
 
139
    ARMCPU *cpu = opaque;
 
140
    CPUARMState *env = &cpu->env;
 
141
 
 
142
    qemu_put_be32(f, cpsr_read(env));
 
143
}
 
144
 
 
145
static const VMStateInfo vmstate_cpsr = {
 
146
    .name = "cpsr",
 
147
    .get = get_cpsr,
 
148
    .put = put_cpsr,
 
149
};
 
150
 
 
151
const VMStateDescription vmstate_arm_cpu = {
 
152
    .name = "cpu",
 
153
    .version_id = 12,
 
154
    .minimum_version_id = 12,
 
155
    .minimum_version_id_old = 12,
 
156
    .fields = (VMStateField[]) {
 
157
        VMSTATE_UINT32_ARRAY(env.regs, ARMCPU, 16),
 
158
        {
 
159
            .name = "cpsr",
 
160
            .version_id = 0,
 
161
            .size = sizeof(uint32_t),
 
162
            .info = &vmstate_cpsr,
 
163
            .flags = VMS_SINGLE,
 
164
            .offset = 0,
 
165
        },
 
166
        VMSTATE_UINT32(env.spsr, ARMCPU),
 
167
        VMSTATE_UINT32_ARRAY(env.banked_spsr, ARMCPU, 7),
 
168
        VMSTATE_UINT32_ARRAY(env.banked_r13, ARMCPU, 7),
 
169
        VMSTATE_UINT32_ARRAY(env.banked_r14, ARMCPU, 7),
 
170
        VMSTATE_UINT32_ARRAY(env.usr_regs, ARMCPU, 5),
 
171
        VMSTATE_UINT32_ARRAY(env.fiq_regs, ARMCPU, 5),
 
172
        VMSTATE_UINT32(env.cp15.c0_cpuid, ARMCPU),
 
173
        VMSTATE_UINT32(env.cp15.c0_cssel, ARMCPU),
 
174
        VMSTATE_UINT32(env.cp15.c1_sys, ARMCPU),
 
175
        VMSTATE_UINT32(env.cp15.c1_coproc, ARMCPU),
 
176
        VMSTATE_UINT32(env.cp15.c1_xscaleauxcr, ARMCPU),
 
177
        VMSTATE_UINT32(env.cp15.c1_scr, ARMCPU),
 
178
        VMSTATE_UINT32(env.cp15.c1_sedbg, ARMCPU),
 
179
        VMSTATE_UINT32(env.cp15.c1_nseac, ARMCPU),
 
180
        VMSTATE_UINT32(env.cp15.c2_base0, ARMCPU),
 
181
        VMSTATE_UINT32(env.cp15.c2_base0_hi, ARMCPU),
 
182
        VMSTATE_UINT32(env.cp15.c2_base1, ARMCPU),
 
183
        VMSTATE_UINT32(env.cp15.c2_base1_hi, ARMCPU),
 
184
        VMSTATE_UINT32(env.cp15.c2_control, ARMCPU),
 
185
        VMSTATE_UINT32(env.cp15.c2_mask, ARMCPU),
 
186
        VMSTATE_UINT32(env.cp15.c2_base_mask, ARMCPU),
 
187
        VMSTATE_UINT32(env.cp15.c2_data, ARMCPU),
 
188
        VMSTATE_UINT32(env.cp15.c2_insn, ARMCPU),
 
189
        VMSTATE_UINT32(env.cp15.c3, ARMCPU),
 
190
        VMSTATE_UINT32(env.cp15.c5_insn, ARMCPU),
 
191
        VMSTATE_UINT32(env.cp15.c5_data, ARMCPU),
 
192
        VMSTATE_UINT32_ARRAY(env.cp15.c6_region, ARMCPU, 8),
 
193
        VMSTATE_UINT32(env.cp15.c6_insn, ARMCPU),
 
194
        VMSTATE_UINT32(env.cp15.c6_data, ARMCPU),
 
195
        VMSTATE_UINT32(env.cp15.c7_par, ARMCPU),
 
196
        VMSTATE_UINT32(env.cp15.c7_par_hi, ARMCPU),
 
197
        VMSTATE_UINT32(env.cp15.c9_insn, ARMCPU),
 
198
        VMSTATE_UINT32(env.cp15.c9_data, ARMCPU),
 
199
        VMSTATE_UINT32(env.cp15.c9_pmcr, ARMCPU),
 
200
        VMSTATE_UINT32(env.cp15.c9_pmcnten, ARMCPU),
 
201
        VMSTATE_UINT32(env.cp15.c9_pmovsr, ARMCPU),
 
202
        VMSTATE_UINT32(env.cp15.c9_pmxevtyper, ARMCPU),
 
203
        VMSTATE_UINT32(env.cp15.c9_pmuserenr, ARMCPU),
 
204
        VMSTATE_UINT32(env.cp15.c9_pminten, ARMCPU),
 
205
        VMSTATE_UINT32(env.cp15.c13_fcse, ARMCPU),
 
206
        VMSTATE_UINT32(env.cp15.c13_context, ARMCPU),
 
207
        VMSTATE_UINT32(env.cp15.c13_tls1, ARMCPU),
 
208
        VMSTATE_UINT32(env.cp15.c13_tls2, ARMCPU),
 
209
        VMSTATE_UINT32(env.cp15.c13_tls3, ARMCPU),
 
210
        VMSTATE_UINT32(env.cp15.c15_cpar, ARMCPU),
 
211
        VMSTATE_UINT32(env.cp15.c15_ticonfig, ARMCPU),
 
212
        VMSTATE_UINT32(env.cp15.c15_i_max, ARMCPU),
 
213
        VMSTATE_UINT32(env.cp15.c15_i_min, ARMCPU),
 
214
        VMSTATE_UINT32(env.cp15.c15_threadid, ARMCPU),
 
215
        VMSTATE_UINT32(env.cp15.c15_power_control, ARMCPU),
 
216
        VMSTATE_UINT32(env.cp15.c15_diagnostic, ARMCPU),
 
217
        VMSTATE_UINT32(env.cp15.c15_power_diagnostic, ARMCPU),
 
218
        VMSTATE_UINT32(env.exclusive_addr, ARMCPU),
 
219
        VMSTATE_UINT32(env.exclusive_val, ARMCPU),
 
220
        VMSTATE_UINT32(env.exclusive_high, ARMCPU),
 
221
        VMSTATE_UINT64(env.features, ARMCPU),
 
222
        VMSTATE_END_OF_LIST()
 
223
    },
 
224
    .subsections = (VMStateSubsection[]) {
 
225
        {
 
226
            .vmsd = &vmstate_vfp,
 
227
            .needed = vfp_needed,
 
228
        } , {
 
229
            .vmsd = &vmstate_iwmmxt,
 
230
            .needed = iwmmxt_needed,
 
231
        } , {
 
232
            .vmsd = &vmstate_m,
 
233
            .needed = m_needed,
 
234
        } , {
 
235
            .vmsd = &vmstate_thumb2ee,
 
236
            .needed = thumb2ee_needed,
 
237
        } , {
 
238
            /* empty */
 
239
        }
 
240
    }
 
241
};