[qemu.git] / target / mips / machine.c

#include "qemu/osdep.h"
#include "cpu.h"
#include "internal.h"
#include "migration/cpu.h"

static int cpu_post_load(void *opaque, int version_id)
{
    MIPSCPU *cpu = opaque;
    CPUMIPSState *env = &cpu->env;

    restore_fp_status(env);
    restore_msa_fp_status(env);
    compute_hflags(env);
    restore_pamask(env);

    return 0;
}

/* FPU state */

static int get_fpr(QEMUFile *f, void *pv, size_t size,
                   const VMStateField *field)
{
    int i;
    fpr_t *v = pv;
    /* Restore entire MSA vector register */
    for (i = 0; i < MSA_WRLEN / 64; i++) {
        qemu_get_sbe64s(f, &v->wr.d[i]);
    }
    return 0;
}

static int put_fpr(QEMUFile *f, void *pv, size_t size,
                   const VMStateField *field, QJSON *vmdesc)
{
    int i;
    fpr_t *v = pv;
    /* Save entire MSA vector register */
    for (i = 0; i < MSA_WRLEN / 64; i++) {
        qemu_put_sbe64s(f, &v->wr.d[i]);
    }

    return 0;
}

const VMStateInfo vmstate_info_fpr = {
    .name = "fpr",
    .get  = get_fpr,
    .put  = put_fpr,
};

#define VMSTATE_FPR_ARRAY_V(_f, _s, _n, _v)                     \
    VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_fpr, fpr_t)

#define VMSTATE_FPR_ARRAY(_f, _s, _n)                           \
    VMSTATE_FPR_ARRAY_V(_f, _s, _n, 0)

static VMStateField vmstate_fpu_fields[] = {
    VMSTATE_FPR_ARRAY(fpr, CPUMIPSFPUContext, 32),
    VMSTATE_UINT32(fcr0, CPUMIPSFPUContext),
    VMSTATE_UINT32(fcr31, CPUMIPSFPUContext),
    VMSTATE_END_OF_LIST()
};

const VMStateDescription vmstate_fpu = {
    .name = "cpu/fpu",
    .version_id = 1,
    .minimum_version_id = 1,
    .fields = vmstate_fpu_fields
};

const VMStateDescription vmstate_inactive_fpu = {
    .name = "cpu/inactive_fpu",
    .version_id = 1,
    .minimum_version_id = 1,
    .fields = vmstate_fpu_fields
};

/* TC state */

static VMStateField vmstate_tc_fields[] = {
    VMSTATE_UINTTL_ARRAY(gpr, TCState, 32),
    VMSTATE_UINTTL(PC, TCState),
    VMSTATE_UINTTL_ARRAY(HI, TCState, MIPS_DSP_ACC),
    VMSTATE_UINTTL_ARRAY(LO, TCState, MIPS_DSP_ACC),
    VMSTATE_UINTTL_ARRAY(ACX, TCState, MIPS_DSP_ACC),
    VMSTATE_UINTTL(DSPControl, TCState),
    VMSTATE_INT32(CP0_TCStatus, TCState),
    VMSTATE_INT32(CP0_TCBind, TCState),
    VMSTATE_UINTTL(CP0_TCHalt, TCState),
    VMSTATE_UINTTL(CP0_TCContext, TCState),
    VMSTATE_UINTTL(CP0_TCSchedule, TCState),
    VMSTATE_UINTTL(CP0_TCScheFBack, TCState),
    VMSTATE_INT32(CP0_Debug_tcstatus, TCState),
    VMSTATE_UINTTL(CP0_UserLocal, TCState),
    VMSTATE_INT32(msacsr, TCState),
    VMSTATE_END_OF_LIST()
};

const VMStateDescription vmstate_tc = {
    .name = "cpu/tc",
    .version_id = 1,
    .minimum_version_id = 1,
    .fields = vmstate_tc_fields
};

const VMStateDescription vmstate_inactive_tc = {
    .name = "cpu/inactive_tc",
    .version_id = 1,
    .minimum_version_id = 1,
    .fields = vmstate_tc_fields
};

/* MVP state */

const VMStateDescription vmstate_mvp = {
    .name = "cpu/mvp",
    .version_id = 1,
    .minimum_version_id = 1,
    .fields = (VMStateField[]) {
        VMSTATE_INT32(CP0_MVPControl, CPUMIPSMVPContext),
        VMSTATE_INT32(CP0_MVPConf0, CPUMIPSMVPContext),
        VMSTATE_INT32(CP0_MVPConf1, CPUMIPSMVPContext),
        VMSTATE_END_OF_LIST()
    }
};

/* TLB state */

static int get_tlb(QEMUFile *f, void *pv, size_t size,
                   const VMStateField *field)
{
    r4k_tlb_t *v = pv;
    uint16_t flags;

    qemu_get_betls(f, &v->VPN);
    qemu_get_be32s(f, &v->PageMask);
    qemu_get_be16s(f, &v->ASID);
    qemu_get_be16s(f, &flags);
    v->G = (flags >> 10) & 1;
    v->C0 = (flags >> 7) & 3;
    v->C1 = (flags >> 4) & 3;
    v->V0 = (flags >> 3) & 1;
    v->V1 = (flags >> 2) & 1;
    v->D0 = (flags >> 1) & 1;
    v->D1 = (flags >> 0) & 1;
    v->EHINV = (flags >> 15) & 1;
    v->RI1 = (flags >> 14) & 1;
    v->RI0 = (flags >> 13) & 1;
    v->XI1 = (flags >> 12) & 1;
    v->XI0 = (flags >> 11) & 1;
    qemu_get_be64s(f, &v->PFN[0]);
    qemu_get_be64s(f, &v->PFN[1]);

    return 0;
}

static int put_tlb(QEMUFile *f, void *pv, size_t size,
                   const VMStateField *field, QJSON *vmdesc)
{
    r4k_tlb_t *v = pv;

    uint16_t asid = v->ASID;
    uint16_t flags = ((v->EHINV << 15) |
                      (v->RI1 << 14) |
                      (v->RI0 << 13) |
                      (v->XI1 << 12) |
                      (v->XI0 << 11) |
                      (v->G << 10) |
                      (v->C0 << 7) |
                      (v->C1 << 4) |
                      (v->V0 << 3) |
                      (v->V1 << 2) |
                      (v->D0 << 1) |
                      (v->D1 << 0));

    qemu_put_betls(f, &v->VPN);
    qemu_put_be32s(f, &v->PageMask);
    qemu_put_be16s(f, &asid);
    qemu_put_be16s(f, &flags);
    qemu_put_be64s(f, &v->PFN[0]);
    qemu_put_be64s(f, &v->PFN[1]);

    return 0;
}

const VMStateInfo vmstate_info_tlb = {
    .name = "tlb_entry",
    .get  = get_tlb,
    .put  = put_tlb,
};

#define VMSTATE_TLB_ARRAY_V(_f, _s, _n, _v)                     \
    VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_tlb, r4k_tlb_t)

#define VMSTATE_TLB_ARRAY(_f, _s, _n)                           \
    VMSTATE_TLB_ARRAY_V(_f, _s, _n, 0)

const VMStateDescription vmstate_tlb = {
    .name = "cpu/tlb",
    .version_id = 2,
    .minimum_version_id = 2,
    .fields = (VMStateField[]) {
        VMSTATE_UINT32(nb_tlb, CPUMIPSTLBContext),
        VMSTATE_UINT32(tlb_in_use, CPUMIPSTLBContext),
        VMSTATE_TLB_ARRAY(mmu.r4k.tlb, CPUMIPSTLBContext, MIPS_TLB_MAX),
        VMSTATE_END_OF_LIST()
    }
};

/* MIPS CPU state */

const VMStateDescription vmstate_mips_cpu = {
    .name = "cpu",
    .version_id = 18,
    .minimum_version_id = 18,
    .post_load = cpu_post_load,
    .fields = (VMStateField[]) {
        /* Active TC */
        VMSTATE_STRUCT(env.active_tc, MIPSCPU, 1, vmstate_tc, TCState),

        /* Active FPU */
        VMSTATE_STRUCT(env.active_fpu, MIPSCPU, 1, vmstate_fpu,
                       CPUMIPSFPUContext),

        /* MVP */
        VMSTATE_STRUCT_POINTER(env.mvp, MIPSCPU, vmstate_mvp,
                               CPUMIPSMVPContext),

        /* TLB */
        VMSTATE_STRUCT_POINTER(env.tlb, MIPSCPU, vmstate_tlb,
                               CPUMIPSTLBContext),

        /* CPU metastate */
        VMSTATE_UINT32(env.current_tc, MIPSCPU),
        VMSTATE_UINT32(env.current_fpu, MIPSCPU),
        VMSTATE_INT32(env.error_code, MIPSCPU),
        VMSTATE_UINTTL(env.btarget, MIPSCPU),
        VMSTATE_UINTTL(env.bcond, MIPSCPU),

        /* Remaining CP0 registers */
        VMSTATE_INT32(env.CP0_Index, MIPSCPU),
        VMSTATE_INT32(env.CP0_Random, MIPSCPU),
        VMSTATE_INT32(env.CP0_VPEControl, MIPSCPU),
        VMSTATE_INT32(env.CP0_VPEConf0, MIPSCPU),
        VMSTATE_INT32(env.CP0_VPEConf1, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_YQMask, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_VPESchedule, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_VPEScheFBack, MIPSCPU),
        VMSTATE_INT32(env.CP0_VPEOpt, MIPSCPU),
        VMSTATE_UINT64(env.CP0_EntryLo0, MIPSCPU),
        VMSTATE_UINT64(env.CP0_EntryLo1, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_Context, MIPSCPU),
        VMSTATE_INT32(env.CP0_MemoryMapID, MIPSCPU),
        VMSTATE_INT32(env.CP0_PageMask, MIPSCPU),
        VMSTATE_INT32(env.CP0_PageGrain, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_SegCtl0, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_SegCtl1, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_SegCtl2, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_PWBase, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_PWField, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_PWSize, MIPSCPU),
        VMSTATE_INT32(env.CP0_Wired, MIPSCPU),
        VMSTATE_INT32(env.CP0_PWCtl, MIPSCPU),
        VMSTATE_INT32(env.CP0_SRSConf0, MIPSCPU),
        VMSTATE_INT32(env.CP0_SRSConf1, MIPSCPU),
        VMSTATE_INT32(env.CP0_SRSConf2, MIPSCPU),
        VMSTATE_INT32(env.CP0_SRSConf3, MIPSCPU),
        VMSTATE_INT32(env.CP0_SRSConf4, MIPSCPU),
        VMSTATE_INT32(env.CP0_HWREna, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_BadVAddr, MIPSCPU),
        VMSTATE_UINT32(env.CP0_BadInstr, MIPSCPU),
        VMSTATE_UINT32(env.CP0_BadInstrP, MIPSCPU),
        VMSTATE_UINT32(env.CP0_BadInstrX, MIPSCPU),
        VMSTATE_INT32(env.CP0_Count, MIPSCPU),
        VMSTATE_UINT32(env.CP0_SAARI, MIPSCPU),
        VMSTATE_UINT64_ARRAY(env.CP0_SAAR, MIPSCPU, 2),
        VMSTATE_UINTTL(env.CP0_EntryHi, MIPSCPU),
        VMSTATE_INT32(env.CP0_Compare, MIPSCPU),
        VMSTATE_INT32(env.CP0_Status, MIPSCPU),
        VMSTATE_INT32(env.CP0_IntCtl, MIPSCPU),
        VMSTATE_INT32(env.CP0_SRSCtl, MIPSCPU),
        VMSTATE_INT32(env.CP0_SRSMap, MIPSCPU),
        VMSTATE_INT32(env.CP0_Cause, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_EPC, MIPSCPU),
        VMSTATE_INT32(env.CP0_PRid, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_EBase, MIPSCPU),
        VMSTATE_INT32(env.CP0_Config0, MIPSCPU),
        VMSTATE_INT32(env.CP0_Config1, MIPSCPU),
        VMSTATE_INT32(env.CP0_Config2, MIPSCPU),
        VMSTATE_INT32(env.CP0_Config3, MIPSCPU),
        VMSTATE_INT32(env.CP0_Config6, MIPSCPU),
        VMSTATE_INT32(env.CP0_Config7, MIPSCPU),
        VMSTATE_UINT64(env.CP0_LLAddr, MIPSCPU),
        VMSTATE_UINT64_ARRAY(env.CP0_MAAR, MIPSCPU, MIPS_MAAR_MAX),
        VMSTATE_INT32(env.CP0_MAARI, MIPSCPU),
        VMSTATE_UINTTL(env.lladdr, MIPSCPU),
        VMSTATE_UINTTL_ARRAY(env.CP0_WatchLo, MIPSCPU, 8),
        VMSTATE_INT32_ARRAY(env.CP0_WatchHi, MIPSCPU, 8),
        VMSTATE_UINTTL(env.CP0_XContext, MIPSCPU),
        VMSTATE_INT32(env.CP0_Framemask, MIPSCPU),
        VMSTATE_INT32(env.CP0_Debug, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_DEPC, MIPSCPU),
        VMSTATE_INT32(env.CP0_Performance0, MIPSCPU),
        VMSTATE_UINT64(env.CP0_TagLo, MIPSCPU),
        VMSTATE_INT32(env.CP0_DataLo, MIPSCPU),
        VMSTATE_INT32(env.CP0_TagHi, MIPSCPU),
        VMSTATE_INT32(env.CP0_DataHi, MIPSCPU),
        VMSTATE_UINTTL(env.CP0_ErrorEPC, MIPSCPU),
        VMSTATE_INT32(env.CP0_DESAVE, MIPSCPU),
        VMSTATE_UINTTL_ARRAY(env.CP0_KScratch, MIPSCPU, MIPS_KSCRATCH_NUM),

        /* Inactive TC */
        VMSTATE_STRUCT_ARRAY(env.tcs, MIPSCPU, MIPS_SHADOW_SET_MAX, 1,
                             vmstate_inactive_tc, TCState),
        VMSTATE_STRUCT_ARRAY(env.fpus, MIPSCPU, MIPS_FPU_MAX, 1,
                             vmstate_inactive_fpu, CPUMIPSFPUContext),

        VMSTATE_END_OF_LIST()
    },
};
Commit	Line	Data
c684822a	1	#include "qemu/osdep.h"
33c11879	2	#include "cpu.h"
26aa3d9a	3	#include "internal.h"
1e00b8d5	4	#include "migration/cpu.h"
33a84765	5
64451111 LA	6	static int cpu_post_load(void *opaque, int version_id)
	7	{
	8	MIPSCPU *cpu = opaque;
	9	CPUMIPSState *env = &cpu->env;
	10
	11	restore_fp_status(env);
	12	restore_msa_fp_status(env);
	13	compute_hflags(env);
e117f526	14	restore_pamask(env);
64451111 LA	15
	16	return 0;
	17	}
	18
04cd7962 LA	19	/* FPU state */
04cd7962 LA	20
03fee66f MAL	21	static int get_fpr(QEMUFile f, void pv, size_t size,
03fee66f MAL	22	const VMStateField *field)
33a84765	23	{
64451111	24	int i;
04cd7962	25	fpr_t *v = pv;
64451111	26	/* Restore entire MSA vector register */
eca3cbb8	27	for (i = 0; i < MSA_WRLEN / 64; i++) {
64451111 LA	28	qemu_get_sbe64s(f, &v->wr.d[i]);
64451111 LA	29	}
04cd7962	30	return 0;
33a84765 TS	31	}
33a84765 TS	32
03fee66f MAL	33	static int put_fpr(QEMUFile f, void pv, size_t size,
03fee66f MAL	34	const VMStateField field, QJSON vmdesc)
33a84765	35	{
64451111	36	int i;
04cd7962	37	fpr_t *v = pv;
64451111	38	/* Save entire MSA vector register */
eca3cbb8	39	for (i = 0; i < MSA_WRLEN / 64; i++) {
64451111 LA	40	qemu_put_sbe64s(f, &v->wr.d[i]);
64451111 LA	41	}
2c21ee76 JD	42
2c21ee76 JD	43	return 0;
33a84765 TS	44	}
33a84765 TS	45
04cd7962 LA	46	const VMStateInfo vmstate_info_fpr = {
	47	.name = "fpr",
	48	.get = get_fpr,
	49	.put = put_fpr,
	50	};
	51
	52	#define VMSTATE_FPR_ARRAY_V(_f, _s, _n, _v) \
	53	VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_fpr, fpr_t)
	54
	55	#define VMSTATE_FPR_ARRAY(_f, _s, _n) \
	56	VMSTATE_FPR_ARRAY_V(_f, _s, _n, 0)
	57
	58	static VMStateField vmstate_fpu_fields[] = {
	59	VMSTATE_FPR_ARRAY(fpr, CPUMIPSFPUContext, 32),
04cd7962 LA	60	VMSTATE_UINT32(fcr0, CPUMIPSFPUContext),
	61	VMSTATE_UINT32(fcr31, CPUMIPSFPUContext),
	62	VMSTATE_END_OF_LIST()
	63	};
	64
	65	const VMStateDescription vmstate_fpu = {
	66	.name = "cpu/fpu",
	67	.version_id = 1,
	68	.minimum_version_id = 1,
	69	.fields = vmstate_fpu_fields
	70	};
	71
	72	const VMStateDescription vmstate_inactive_fpu = {
	73	.name = "cpu/inactive_fpu",
	74	.version_id = 1,
	75	.minimum_version_id = 1,
	76	.fields = vmstate_fpu_fields
	77	};
33a84765	78
04cd7962 LA	79	/* TC state */
	80
	81	static VMStateField vmstate_tc_fields[] = {
	82	VMSTATE_UINTTL_ARRAY(gpr, TCState, 32),
	83	VMSTATE_UINTTL(PC, TCState),
	84	VMSTATE_UINTTL_ARRAY(HI, TCState, MIPS_DSP_ACC),
	85	VMSTATE_UINTTL_ARRAY(LO, TCState, MIPS_DSP_ACC),
	86	VMSTATE_UINTTL_ARRAY(ACX, TCState, MIPS_DSP_ACC),
	87	VMSTATE_UINTTL(DSPControl, TCState),
	88	VMSTATE_INT32(CP0_TCStatus, TCState),
	89	VMSTATE_INT32(CP0_TCBind, TCState),
	90	VMSTATE_UINTTL(CP0_TCHalt, TCState),
	91	VMSTATE_UINTTL(CP0_TCContext, TCState),
	92	VMSTATE_UINTTL(CP0_TCSchedule, TCState),
	93	VMSTATE_UINTTL(CP0_TCScheFBack, TCState),
	94	VMSTATE_INT32(CP0_Debug_tcstatus, TCState),
	95	VMSTATE_UINTTL(CP0_UserLocal, TCState),
64451111	96	VMSTATE_INT32(msacsr, TCState),
04cd7962 LA	97	VMSTATE_END_OF_LIST()
	98	};
	99
	100	const VMStateDescription vmstate_tc = {
	101	.name = "cpu/tc",
	102	.version_id = 1,
	103	.minimum_version_id = 1,
	104	.fields = vmstate_tc_fields
	105	};
	106
	107	const VMStateDescription vmstate_inactive_tc = {
	108	.name = "cpu/inactive_tc",
	109	.version_id = 1,
	110	.minimum_version_id = 1,
	111	.fields = vmstate_tc_fields
	112	};
	113
	114	/* MVP state */
	115
	116	const VMStateDescription vmstate_mvp = {
	117	.name = "cpu/mvp",
	118	.version_id = 1,
	119	.minimum_version_id = 1,
	120	.fields = (VMStateField[]) {
	121	VMSTATE_INT32(CP0_MVPControl, CPUMIPSMVPContext),
	122	VMSTATE_INT32(CP0_MVPConf0, CPUMIPSMVPContext),
	123	VMSTATE_INT32(CP0_MVPConf1, CPUMIPSMVPContext),
	124	VMSTATE_END_OF_LIST()
460c81f1	125	}
04cd7962	126	};
33a84765	127
04cd7962	128	/* TLB state */
33a84765	129
03fee66f MAL	130	static int get_tlb(QEMUFile f, void pv, size_t size,
03fee66f MAL	131	const VMStateField *field)
33a84765	132	{
04cd7962 LA	133	r4k_tlb_t *v = pv;
	134	uint16_t flags;
	135
	136	qemu_get_betls(f, &v->VPN);
	137	qemu_get_be32s(f, &v->PageMask);
2d72e7b0	138	qemu_get_be16s(f, &v->ASID);
04cd7962 LA	139	qemu_get_be16s(f, &flags);
	140	v->G = (flags >> 10) & 1;
	141	v->C0 = (flags >> 7) & 3;
	142	v->C1 = (flags >> 4) & 3;
	143	v->V0 = (flags >> 3) & 1;
	144	v->V1 = (flags >> 2) & 1;
	145	v->D0 = (flags >> 1) & 1;
	146	v->D1 = (flags >> 0) & 1;
	147	v->EHINV = (flags >> 15) & 1;
	148	v->RI1 = (flags >> 14) & 1;
	149	v->RI0 = (flags >> 13) & 1;
	150	v->XI1 = (flags >> 12) & 1;
	151	v->XI0 = (flags >> 11) & 1;
284b731a LA	152	qemu_get_be64s(f, &v->PFN[0]);
284b731a LA	153	qemu_get_be64s(f, &v->PFN[1]);
04cd7962 LA	154
04cd7962 LA	155	return 0;
33a84765 TS	156	}
33a84765 TS	157
03fee66f MAL	158	static int put_tlb(QEMUFile f, void pv, size_t size,
03fee66f MAL	159	const VMStateField field, QJSON vmdesc)
33a84765	160	{
04cd7962 LA	161	r4k_tlb_t *v = pv;
04cd7962 LA	162
2d72e7b0	163	uint16_t asid = v->ASID;
04cd7962 LA	164	uint16_t flags = ((v->EHINV << 15) \|
	165	(v->RI1 << 14) \|
	166	(v->RI0 << 13) \|
	167	(v->XI1 << 12) \|
	168	(v->XI0 << 11) \|
	169	(v->G << 10) \|
	170	(v->C0 << 7) \|
	171	(v->C1 << 4) \|
	172	(v->V0 << 3) \|
	173	(v->V1 << 2) \|
	174	(v->D0 << 1) \|
	175	(v->D1 << 0));
	176
	177	qemu_put_betls(f, &v->VPN);
	178	qemu_put_be32s(f, &v->PageMask);
2d72e7b0	179	qemu_put_be16s(f, &asid);
04cd7962	180	qemu_put_be16s(f, &flags);
284b731a LA	181	qemu_put_be64s(f, &v->PFN[0]);
284b731a LA	182	qemu_put_be64s(f, &v->PFN[1]);
2c21ee76 JD	183
2c21ee76 JD	184	return 0;
8dd3dca3 AJ	185	}
8dd3dca3 AJ	186
04cd7962 LA	187	const VMStateInfo vmstate_info_tlb = {
	188	.name = "tlb_entry",
	189	.get = get_tlb,
	190	.put = put_tlb,
	191	};
33a84765	192
04cd7962 LA	193	#define VMSTATE_TLB_ARRAY_V(_f, _s, _n, _v) \
04cd7962 LA	194	VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_tlb, r4k_tlb_t)
33a84765	195
04cd7962 LA	196	#define VMSTATE_TLB_ARRAY(_f, _s, _n) \
04cd7962 LA	197	VMSTATE_TLB_ARRAY_V(_f, _s, _n, 0)
33a84765	198
04cd7962 LA	199	const VMStateDescription vmstate_tlb = {
04cd7962 LA	200	.name = "cpu/tlb",
2d72e7b0 PB	201	.version_id = 2,
2d72e7b0 PB	202	.minimum_version_id = 2,
04cd7962 LA	203	.fields = (VMStateField[]) {
	204	VMSTATE_UINT32(nb_tlb, CPUMIPSTLBContext),
	205	VMSTATE_UINT32(tlb_in_use, CPUMIPSTLBContext),
	206	VMSTATE_TLB_ARRAY(mmu.r4k.tlb, CPUMIPSTLBContext, MIPS_TLB_MAX),
	207	VMSTATE_END_OF_LIST()
460c81f1	208	}
04cd7962	209	};
33a84765	210
04cd7962	211	/* MIPS CPU state */
33a84765	212
04cd7962 LA	213	const VMStateDescription vmstate_mips_cpu = {
04cd7962 LA	214	.name = "cpu",
c7c7e1e9 LA	215	.version_id = 18,
c7c7e1e9 LA	216	.minimum_version_id = 18,
64451111	217	.post_load = cpu_post_load,
04cd7962 LA	218	.fields = (VMStateField[]) {
	219	/* Active TC */
	220	VMSTATE_STRUCT(env.active_tc, MIPSCPU, 1, vmstate_tc, TCState),
	221
	222	/* Active FPU */
	223	VMSTATE_STRUCT(env.active_fpu, MIPSCPU, 1, vmstate_fpu,
	224	CPUMIPSFPUContext),
	225
	226	/* MVP */
	227	VMSTATE_STRUCT_POINTER(env.mvp, MIPSCPU, vmstate_mvp,
	228	CPUMIPSMVPContext),
	229
	230	/* TLB */
	231	VMSTATE_STRUCT_POINTER(env.tlb, MIPSCPU, vmstate_tlb,
	232	CPUMIPSTLBContext),
	233
	234	/* CPU metastate */
	235	VMSTATE_UINT32(env.current_tc, MIPSCPU),
	236	VMSTATE_UINT32(env.current_fpu, MIPSCPU),
	237	VMSTATE_INT32(env.error_code, MIPSCPU),
04cd7962 LA	238	VMSTATE_UINTTL(env.btarget, MIPSCPU),
	239	VMSTATE_UINTTL(env.bcond, MIPSCPU),
	240
	241	/* Remaining CP0 registers */
	242	VMSTATE_INT32(env.CP0_Index, MIPSCPU),
	243	VMSTATE_INT32(env.CP0_Random, MIPSCPU),
	244	VMSTATE_INT32(env.CP0_VPEControl, MIPSCPU),
	245	VMSTATE_INT32(env.CP0_VPEConf0, MIPSCPU),
	246	VMSTATE_INT32(env.CP0_VPEConf1, MIPSCPU),
	247	VMSTATE_UINTTL(env.CP0_YQMask, MIPSCPU),
	248	VMSTATE_UINTTL(env.CP0_VPESchedule, MIPSCPU),
	249	VMSTATE_UINTTL(env.CP0_VPEScheFBack, MIPSCPU),
	250	VMSTATE_INT32(env.CP0_VPEOpt, MIPSCPU),
284b731a LA	251	VMSTATE_UINT64(env.CP0_EntryLo0, MIPSCPU),
284b731a LA	252	VMSTATE_UINT64(env.CP0_EntryLo1, MIPSCPU),
04cd7962	253	VMSTATE_UINTTL(env.CP0_Context, MIPSCPU),
3ef521ee	254	VMSTATE_INT32(env.CP0_MemoryMapID, MIPSCPU),
04cd7962 LA	255	VMSTATE_INT32(env.CP0_PageMask, MIPSCPU),
04cd7962 LA	256	VMSTATE_INT32(env.CP0_PageGrain, MIPSCPU),
cec56a73 JH	257	VMSTATE_UINTTL(env.CP0_SegCtl0, MIPSCPU),
	258	VMSTATE_UINTTL(env.CP0_SegCtl1, MIPSCPU),
	259	VMSTATE_UINTTL(env.CP0_SegCtl2, MIPSCPU),
5e31fdd5	260	VMSTATE_UINTTL(env.CP0_PWBase, MIPSCPU),
fa75ad14	261	VMSTATE_UINTTL(env.CP0_PWField, MIPSCPU),
20b28ebc	262	VMSTATE_UINTTL(env.CP0_PWSize, MIPSCPU),
04cd7962	263	VMSTATE_INT32(env.CP0_Wired, MIPSCPU),
103be64c	264	VMSTATE_INT32(env.CP0_PWCtl, MIPSCPU),
04cd7962 LA	265	VMSTATE_INT32(env.CP0_SRSConf0, MIPSCPU),
	266	VMSTATE_INT32(env.CP0_SRSConf1, MIPSCPU),
	267	VMSTATE_INT32(env.CP0_SRSConf2, MIPSCPU),
	268	VMSTATE_INT32(env.CP0_SRSConf3, MIPSCPU),
	269	VMSTATE_INT32(env.CP0_SRSConf4, MIPSCPU),
	270	VMSTATE_INT32(env.CP0_HWREna, MIPSCPU),
	271	VMSTATE_UINTTL(env.CP0_BadVAddr, MIPSCPU),
	272	VMSTATE_UINT32(env.CP0_BadInstr, MIPSCPU),
	273	VMSTATE_UINT32(env.CP0_BadInstrP, MIPSCPU),
25beba9b	274	VMSTATE_UINT32(env.CP0_BadInstrX, MIPSCPU),
04cd7962	275	VMSTATE_INT32(env.CP0_Count, MIPSCPU),
167db30e YK	276	VMSTATE_UINT32(env.CP0_SAARI, MIPSCPU),
167db30e YK	277	VMSTATE_UINT64_ARRAY(env.CP0_SAAR, MIPSCPU, 2),
04cd7962 LA	278	VMSTATE_UINTTL(env.CP0_EntryHi, MIPSCPU),
	279	VMSTATE_INT32(env.CP0_Compare, MIPSCPU),
	280	VMSTATE_INT32(env.CP0_Status, MIPSCPU),
	281	VMSTATE_INT32(env.CP0_IntCtl, MIPSCPU),
	282	VMSTATE_INT32(env.CP0_SRSCtl, MIPSCPU),
	283	VMSTATE_INT32(env.CP0_SRSMap, MIPSCPU),
	284	VMSTATE_INT32(env.CP0_Cause, MIPSCPU),
	285	VMSTATE_UINTTL(env.CP0_EPC, MIPSCPU),
	286	VMSTATE_INT32(env.CP0_PRid, MIPSCPU),
74dbf824	287	VMSTATE_UINTTL(env.CP0_EBase, MIPSCPU),
04cd7962 LA	288	VMSTATE_INT32(env.CP0_Config0, MIPSCPU),
	289	VMSTATE_INT32(env.CP0_Config1, MIPSCPU),
	290	VMSTATE_INT32(env.CP0_Config2, MIPSCPU),
	291	VMSTATE_INT32(env.CP0_Config3, MIPSCPU),
	292	VMSTATE_INT32(env.CP0_Config6, MIPSCPU),
	293	VMSTATE_INT32(env.CP0_Config7, MIPSCPU),
c7c7e1e9	294	VMSTATE_UINT64(env.CP0_LLAddr, MIPSCPU),
f6d4dd81 YK	295	VMSTATE_UINT64_ARRAY(env.CP0_MAAR, MIPSCPU, MIPS_MAAR_MAX),
f6d4dd81 YK	296	VMSTATE_INT32(env.CP0_MAARI, MIPSCPU),
c7c7e1e9	297	VMSTATE_UINTTL(env.lladdr, MIPSCPU),
04cd7962 LA	298	VMSTATE_UINTTL_ARRAY(env.CP0_WatchLo, MIPSCPU, 8),
	299	VMSTATE_INT32_ARRAY(env.CP0_WatchHi, MIPSCPU, 8),
	300	VMSTATE_UINTTL(env.CP0_XContext, MIPSCPU),
	301	VMSTATE_INT32(env.CP0_Framemask, MIPSCPU),
	302	VMSTATE_INT32(env.CP0_Debug, MIPSCPU),
	303	VMSTATE_UINTTL(env.CP0_DEPC, MIPSCPU),
	304	VMSTATE_INT32(env.CP0_Performance0, MIPSCPU),
284b731a	305	VMSTATE_UINT64(env.CP0_TagLo, MIPSCPU),
04cd7962 LA	306	VMSTATE_INT32(env.CP0_DataLo, MIPSCPU),
	307	VMSTATE_INT32(env.CP0_TagHi, MIPSCPU),
	308	VMSTATE_INT32(env.CP0_DataHi, MIPSCPU),
	309	VMSTATE_UINTTL(env.CP0_ErrorEPC, MIPSCPU),
	310	VMSTATE_INT32(env.CP0_DESAVE, MIPSCPU),
	311	VMSTATE_UINTTL_ARRAY(env.CP0_KScratch, MIPSCPU, MIPS_KSCRATCH_NUM),
	312
	313	/* Inactive TC */
	314	VMSTATE_STRUCT_ARRAY(env.tcs, MIPSCPU, MIPS_SHADOW_SET_MAX, 1,
	315	vmstate_inactive_tc, TCState),
	316	VMSTATE_STRUCT_ARRAY(env.fpus, MIPSCPU, MIPS_FPU_MAX, 1,
	317	vmstate_inactive_fpu, CPUMIPSFPUContext),
	318
	319	VMSTATE_END_OF_LIST()
	320	},
	321	};