LXR qemu/target/m68k/cpu.c

   1/*
   2 * QEMU Motorola 68k CPU
   3 *
   4 * Copyright (c) 2012 SUSE LINUX Products GmbH
   5 *
   6 * This library is free software; you can redistribute it and/or
   7 * modify it under the terms of the GNU Lesser General Public
   8 * License as published by the Free Software Foundation; either
   9 * version 2.1 of the License, or (at your option) any later version.
  10 *
  11 * This library is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 * Lesser General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU Lesser General Public
  17 * License along with this library; if not, see
  18 * <http://www.gnu.org/licenses/lgpl-2.1.html>
  19 */
  20
  21#include "qemu/osdep.h"
  22#include "qapi/error.h"
  23#include "cpu.h"
  24#include "migration/vmstate.h"
  25#include "fpu/softfloat.h"
  26
  27static void m68k_cpu_set_pc(CPUState *cs, vaddr value)
  28{
  29    M68kCPU *cpu = M68K_CPU(cs);
  30
  31    cpu->env.pc = value;
  32}
  33
  34static bool m68k_cpu_has_work(CPUState *cs)
  35{
  36    return cs->interrupt_request & CPU_INTERRUPT_HARD;
  37}
  38
  39static void m68k_set_feature(CPUM68KState *env, int feature)
  40{
  41    env->features |= (1u << feature);
  42}
  43
  44static void m68k_unset_feature(CPUM68KState *env, int feature)
  45{
  46    env->features &= (-1u - (1u << feature));
  47}
  48
  49static void m68k_cpu_reset(DeviceState *dev)
  50{
  51    CPUState *s = CPU(dev);
  52    M68kCPU *cpu = M68K_CPU(s);
  53    M68kCPUClass *mcc = M68K_CPU_GET_CLASS(cpu);
  54    CPUM68KState *env = &cpu->env;
  55    floatx80 nan = floatx80_default_nan(NULL);
  56    int i;
  57
  58    mcc->parent_reset(dev);
  59
  60    memset(env, 0, offsetof(CPUM68KState, end_reset_fields));
  61#ifdef CONFIG_SOFTMMU
  62    cpu_m68k_set_sr(env, SR_S | SR_I);
  63#else
  64    cpu_m68k_set_sr(env, 0);
  65#endif
  66    for (i = 0; i < 8; i++) {
  67        env->fregs[i].d = nan;
  68    }
  69    cpu_m68k_set_fpcr(env, 0);
  70    env->fpsr = 0;
  71
  72    /* TODO: We should set PC from the interrupt vector.  */
  73    env->pc = 0;
  74}
  75
  76static void m68k_cpu_disas_set_info(CPUState *s, disassemble_info *info)
  77{
  78    info->print_insn = print_insn_m68k;
  79    info->mach = 0;
  80}
  81
  82/* CPU models */
  83
  84static ObjectClass *m68k_cpu_class_by_name(const char *cpu_model)
  85{
  86    ObjectClass *oc;
  87    char *typename;
  88
  89    typename = g_strdup_printf(M68K_CPU_TYPE_NAME("%s"), cpu_model);
  90    oc = object_class_by_name(typename);
  91    g_free(typename);
  92    if (oc != NULL && (object_class_dynamic_cast(oc, TYPE_M68K_CPU) == NULL ||
  93                       object_class_is_abstract(oc))) {
  94        return NULL;
  95    }
  96    return oc;
  97}
  98
  99static void m5206_cpu_initfn(Object *obj)
 100{
 101    M68kCPU *cpu = M68K_CPU(obj);
 102    CPUM68KState *env = &cpu->env;
 103
 104    m68k_set_feature(env, M68K_FEATURE_CF_ISA_A);
 105}
 106
 107/* Base feature set, including isns. for m68k family */
 108static void m68000_cpu_initfn(Object *obj)
 109{
 110    M68kCPU *cpu = M68K_CPU(obj);
 111    CPUM68KState *env = &cpu->env;
 112
 113    m68k_set_feature(env, M68K_FEATURE_M68000);
 114    m68k_set_feature(env, M68K_FEATURE_USP);
 115    m68k_set_feature(env, M68K_FEATURE_WORD_INDEX);
 116    m68k_set_feature(env, M68K_FEATURE_MOVEP);
 117}
 118
 119/*
 120 * Adds BKPT, MOVE-from-SR *now priv instr, and MOVEC, MOVES, RTD
 121 */
 122static void m68010_cpu_initfn(Object *obj)
 123{
 124    M68kCPU *cpu = M68K_CPU(obj);
 125    CPUM68KState *env = &cpu->env;
 126
 127    m68000_cpu_initfn(obj);
 128    m68k_set_feature(env, M68K_FEATURE_M68010);
 129    m68k_set_feature(env, M68K_FEATURE_RTD);
 130    m68k_set_feature(env, M68K_FEATURE_BKPT);
 131    m68k_set_feature(env, M68K_FEATURE_MOVEC);
 132}
 133
 134/*
 135 * Adds BFCHG, BFCLR, BFEXTS, BFEXTU, BFFFO, BFINS, BFSET, BFTST, CAS, CAS2,
 136 *      CHK2, CMP2, DIVSL, DIVUL, EXTB, PACK, TRAPcc, UNPK.
 137 *
 138 * 68020/30 only:
 139 *      CALLM, cpBcc, cpDBcc, cpGEN, cpRESTORE, cpSAVE, cpScc, cpTRAPcc
 140 */
 141static void m68020_cpu_initfn(Object *obj)
 142{
 143    M68kCPU *cpu = M68K_CPU(obj);
 144    CPUM68KState *env = &cpu->env;
 145
 146    m68010_cpu_initfn(obj);
 147    m68k_unset_feature(env, M68K_FEATURE_M68010);
 148    m68k_set_feature(env, M68K_FEATURE_M68020);
 149    m68k_set_feature(env, M68K_FEATURE_QUAD_MULDIV);
 150    m68k_set_feature(env, M68K_FEATURE_BRAL);
 151    m68k_set_feature(env, M68K_FEATURE_BCCL);
 152    m68k_set_feature(env, M68K_FEATURE_BITFIELD);
 153    m68k_set_feature(env, M68K_FEATURE_EXT_FULL);
 154    m68k_set_feature(env, M68K_FEATURE_SCALED_INDEX);
 155    m68k_set_feature(env, M68K_FEATURE_LONG_MULDIV);
 156    m68k_set_feature(env, M68K_FEATURE_FPU);
 157    m68k_set_feature(env, M68K_FEATURE_CAS);
 158    m68k_set_feature(env, M68K_FEATURE_CHK2);
 159    m68k_set_feature(env, M68K_FEATURE_MSP);
 160    m68k_set_feature(env, M68K_FEATURE_UNALIGNED_DATA);
 161    m68k_set_feature(env, M68K_FEATURE_TRAPCC);
 162}
 163
 164/*
 165 * Adds: PFLUSH (*5)
 166 * 68030 Only: PFLUSHA (*5), PLOAD (*5), PMOVE
 167 * 68030/40 Only: PTEST
 168 *
 169 * NOTES:
 170 *  5. Not valid on MC68EC030
 171 */
 172static void m68030_cpu_initfn(Object *obj)
 173{
 174    M68kCPU *cpu = M68K_CPU(obj);
 175    CPUM68KState *env = &cpu->env;
 176
 177    m68020_cpu_initfn(obj);
 178    m68k_unset_feature(env, M68K_FEATURE_M68020);
 179    m68k_set_feature(env, M68K_FEATURE_M68030);
 180}
 181
 182/*
 183 * Adds: CINV, CPUSH
 184 * Adds all with Note *2: FABS, FSABS, FDABS, FADD, FSADD, FDADD, FBcc, FCMP,
 185 *                        FDBcc, FDIV, FSDIV, FDDIV, FMOVE, FSMOVE, FDMOVE,
 186 *                        FMOVEM, FMUL, FSMUL, FDMUL, FNEG, FSNEG, FDNEG, FNOP,
 187 *                        FRESTORE, FSAVE, FScc, FSQRT, FSSQRT, FDSQRT, FSUB,
 188 *                        FSSUB, FDSUB, FTRAPcc, FTST
 189 *
 190 * Adds with Notes *2, and *3: FACOS, FASIN, FATAN, FATANH, FCOS, FCOSH, FETOX,
 191 *                             FETOXM, FGETEXP, FGETMAN, FINT, FINTRZ, FLOG10,
 192 *                             FLOG2, FLOGN, FLOGNP1, FMOD, FMOVECR, FREM,
 193 *                             FSCALE, FSGLDIV, FSGLMUL, FSIN, FSINCOS, FSINH,
 194 *                             FTAN, FTANH, FTENTOX, FTWOTOX
 195 * NOTES:
 196 * 2. Not applicable to the MC68EC040, MC68LC040, MC68EC060, and MC68LC060.
 197 * 3. These are software-supported instructions on the MC68040 and MC68060.
 198 */
 199static void m68040_cpu_initfn(Object *obj)
 200{
 201    M68kCPU *cpu = M68K_CPU(obj);
 202    CPUM68KState *env = &cpu->env;
 203
 204    m68030_cpu_initfn(obj);
 205    m68k_unset_feature(env, M68K_FEATURE_M68030);
 206    m68k_set_feature(env, M68K_FEATURE_M68040);
 207}
 208
 209/*
 210 * Adds: PLPA
 211 * Adds all with Note *2: CAS, CAS2, MULS, MULU, CHK2, CMP2, DIVS, DIVU
 212 * All Fxxxx instructions are as per m68040 with exception to; FMOVEM NOTE3
 213 *
 214 * Does NOT implement MOVEP
 215 *
 216 * NOTES:
 217 * 2. Not applicable to the MC68EC040, MC68LC040, MC68EC060, and MC68LC060.
 218 * 3. These are software-supported instructions on the MC68040 and MC68060.
 219 */
 220static void m68060_cpu_initfn(Object *obj)
 221{
 222    M68kCPU *cpu = M68K_CPU(obj);
 223    CPUM68KState *env = &cpu->env;
 224
 225    m68040_cpu_initfn(obj);
 226    m68k_unset_feature(env, M68K_FEATURE_M68040);
 227    m68k_set_feature(env, M68K_FEATURE_M68060);
 228    m68k_unset_feature(env, M68K_FEATURE_MOVEP);
 229
 230    /* Implemented as a software feature */
 231    m68k_unset_feature(env, M68K_FEATURE_QUAD_MULDIV);
 232}
 233
 234static void m5208_cpu_initfn(Object *obj)
 235{
 236    M68kCPU *cpu = M68K_CPU(obj);
 237    CPUM68KState *env = &cpu->env;
 238
 239    m68k_set_feature(env, M68K_FEATURE_CF_ISA_A);
 240    m68k_set_feature(env, M68K_FEATURE_CF_ISA_APLUSC);
 241    m68k_set_feature(env, M68K_FEATURE_BRAL);
 242    m68k_set_feature(env, M68K_FEATURE_CF_EMAC);
 243    m68k_set_feature(env, M68K_FEATURE_USP);
 244}
 245
 246static void cfv4e_cpu_initfn(Object *obj)
 247{
 248    M68kCPU *cpu = M68K_CPU(obj);
 249    CPUM68KState *env = &cpu->env;
 250
 251    m68k_set_feature(env, M68K_FEATURE_CF_ISA_A);
 252    m68k_set_feature(env, M68K_FEATURE_CF_ISA_B);
 253    m68k_set_feature(env, M68K_FEATURE_BRAL);
 254    m68k_set_feature(env, M68K_FEATURE_CF_FPU);
 255    m68k_set_feature(env, M68K_FEATURE_CF_EMAC);
 256    m68k_set_feature(env, M68K_FEATURE_USP);
 257}
 258
 259static void any_cpu_initfn(Object *obj)
 260{
 261    M68kCPU *cpu = M68K_CPU(obj);
 262    CPUM68KState *env = &cpu->env;
 263
 264    m68k_set_feature(env, M68K_FEATURE_CF_ISA_A);
 265    m68k_set_feature(env, M68K_FEATURE_CF_ISA_B);
 266    m68k_set_feature(env, M68K_FEATURE_CF_ISA_APLUSC);
 267    m68k_set_feature(env, M68K_FEATURE_BRAL);
 268    m68k_set_feature(env, M68K_FEATURE_CF_FPU);
 269    /*
 270     * MAC and EMAC are mututally exclusive, so pick EMAC.
 271     * It's mostly backwards compatible.
 272     */
 273    m68k_set_feature(env, M68K_FEATURE_CF_EMAC);
 274    m68k_set_feature(env, M68K_FEATURE_CF_EMAC_B);
 275    m68k_set_feature(env, M68K_FEATURE_USP);
 276    m68k_set_feature(env, M68K_FEATURE_EXT_FULL);
 277    m68k_set_feature(env, M68K_FEATURE_WORD_INDEX);
 278}
 279
 280static void m68k_cpu_realizefn(DeviceState *dev, Error **errp)
 281{
 282    CPUState *cs = CPU(dev);
 283    M68kCPU *cpu = M68K_CPU(dev);
 284    M68kCPUClass *mcc = M68K_CPU_GET_CLASS(dev);
 285    Error *local_err = NULL;
 286
 287    register_m68k_insns(&cpu->env);
 288
 289    cpu_exec_realizefn(cs, &local_err);
 290    if (local_err != NULL) {
 291        error_propagate(errp, local_err);
 292        return;
 293    }
 294
 295    m68k_cpu_init_gdb(cpu);
 296
 297    cpu_reset(cs);
 298    qemu_init_vcpu(cs);
 299
 300    mcc->parent_realize(dev, errp);
 301}
 302
 303static void m68k_cpu_initfn(Object *obj)
 304{
 305    M68kCPU *cpu = M68K_CPU(obj);
 306
 307    cpu_set_cpustate_pointers(cpu);
 308}
 309
 310#if defined(CONFIG_SOFTMMU)
 311static bool fpu_needed(void *opaque)
 312{
 313    M68kCPU *s = opaque;
 314
 315    return m68k_feature(&s->env, M68K_FEATURE_CF_FPU) ||
 316           m68k_feature(&s->env, M68K_FEATURE_FPU);
 317}
 318
 319typedef struct m68k_FPReg_tmp {
 320    FPReg *parent;
 321    uint64_t tmp_mant;
 322    uint16_t tmp_exp;
 323} m68k_FPReg_tmp;
 324
 325static void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, floatx80 f)
 326{
 327    CPU_LDoubleU temp;
 328
 329    temp.d = f;
 330    *pmant = temp.l.lower;
 331    *pexp = temp.l.upper;
 332}
 333
 334static floatx80 cpu_set_fp80(uint64_t mant, uint16_t upper)
 335{
 336    CPU_LDoubleU temp;
 337
 338    temp.l.upper = upper;
 339    temp.l.lower = mant;
 340    return temp.d;
 341}
 342
 343static int freg_pre_save(void *opaque)
 344{
 345    m68k_FPReg_tmp *tmp = opaque;
 346
 347    cpu_get_fp80(&tmp->tmp_mant, &tmp->tmp_exp, tmp->parent->d);
 348
 349    return 0;
 350}
 351
 352static int freg_post_load(void *opaque, int version)
 353{
 354    m68k_FPReg_tmp *tmp = opaque;
 355
 356    tmp->parent->d = cpu_set_fp80(tmp->tmp_mant, tmp->tmp_exp);
 357
 358    return 0;
 359}
 360
 361static const VMStateDescription vmstate_freg_tmp = {
 362    .name = "freg_tmp",
 363    .post_load = freg_post_load,
 364    .pre_save  = freg_pre_save,
 365    .fields = (VMStateField[]) {
 366        VMSTATE_UINT64(tmp_mant, m68k_FPReg_tmp),
 367        VMSTATE_UINT16(tmp_exp, m68k_FPReg_tmp),
 368        VMSTATE_END_OF_LIST()
 369    }
 370};
 371
 372static const VMStateDescription vmstate_freg = {
 373    .name = "freg",
 374    .fields = (VMStateField[]) {
 375        VMSTATE_WITH_TMP(FPReg, m68k_FPReg_tmp, vmstate_freg_tmp),
 376        VMSTATE_END_OF_LIST()
 377    }
 378};
 379
 380static int fpu_post_load(void *opaque, int version)
 381{
 382    M68kCPU *s = opaque;
 383
 384    cpu_m68k_restore_fp_status(&s->env);
 385
 386    return 0;
 387}
 388
 389const VMStateDescription vmmstate_fpu = {
 390    .name = "cpu/fpu",
 391    .version_id = 1,
 392    .minimum_version_id = 1,
 393    .needed = fpu_needed,
 394    .post_load = fpu_post_load,
 395    .fields = (VMStateField[]) {
 396        VMSTATE_UINT32(env.fpcr, M68kCPU),
 397        VMSTATE_UINT32(env.fpsr, M68kCPU),
 398        VMSTATE_STRUCT_ARRAY(env.fregs, M68kCPU, 8, 0, vmstate_freg, FPReg),
 399        VMSTATE_STRUCT(env.fp_result, M68kCPU, 0, vmstate_freg, FPReg),
 400        VMSTATE_END_OF_LIST()
 401    }
 402};
 403
 404static bool cf_spregs_needed(void *opaque)
 405{
 406    M68kCPU *s = opaque;
 407
 408    return m68k_feature(&s->env, M68K_FEATURE_CF_ISA_A);
 409}
 410
 411const VMStateDescription vmstate_cf_spregs = {
 412    .name = "cpu/cf_spregs",
 413    .version_id = 1,
 414    .minimum_version_id = 1,
 415    .needed = cf_spregs_needed,
 416    .fields = (VMStateField[]) {
 417        VMSTATE_UINT64_ARRAY(env.macc, M68kCPU, 4),
 418        VMSTATE_UINT32(env.macsr, M68kCPU),
 419        VMSTATE_UINT32(env.mac_mask, M68kCPU),
 420        VMSTATE_UINT32(env.rambar0, M68kCPU),
 421        VMSTATE_UINT32(env.mbar, M68kCPU),
 422        VMSTATE_END_OF_LIST()
 423    }
 424};
 425
 426static bool cpu_68040_mmu_needed(void *opaque)
 427{
 428    M68kCPU *s = opaque;
 429
 430    return m68k_feature(&s->env, M68K_FEATURE_M68040);
 431}
 432
 433const VMStateDescription vmstate_68040_mmu = {
 434    .name = "cpu/68040_mmu",
 435    .version_id = 1,
 436    .minimum_version_id = 1,
 437    .needed = cpu_68040_mmu_needed,
 438    .fields = (VMStateField[]) {
 439        VMSTATE_UINT32(env.mmu.ar, M68kCPU),
 440        VMSTATE_UINT32(env.mmu.ssw, M68kCPU),
 441        VMSTATE_UINT16(env.mmu.tcr, M68kCPU),
 442        VMSTATE_UINT32(env.mmu.urp, M68kCPU),
 443        VMSTATE_UINT32(env.mmu.srp, M68kCPU),
 444        VMSTATE_BOOL(env.mmu.fault, M68kCPU),
 445        VMSTATE_UINT32_ARRAY(env.mmu.ttr, M68kCPU, 4),
 446        VMSTATE_UINT32(env.mmu.mmusr, M68kCPU),
 447        VMSTATE_END_OF_LIST()
 448    }
 449};
 450
 451static bool cpu_68040_spregs_needed(void *opaque)
 452{
 453    M68kCPU *s = opaque;
 454
 455    return m68k_feature(&s->env, M68K_FEATURE_M68040);
 456}
 457
 458const VMStateDescription vmstate_68040_spregs = {
 459    .name = "cpu/68040_spregs",
 460    .version_id = 1,
 461    .minimum_version_id = 1,
 462    .needed = cpu_68040_spregs_needed,
 463    .fields = (VMStateField[]) {
 464        VMSTATE_UINT32(env.vbr, M68kCPU),
 465        VMSTATE_UINT32(env.cacr, M68kCPU),
 466        VMSTATE_UINT32(env.sfc, M68kCPU),
 467        VMSTATE_UINT32(env.dfc, M68kCPU),
 468        VMSTATE_END_OF_LIST()
 469    }
 470};
 471
 472static const VMStateDescription vmstate_m68k_cpu = {
 473    .name = "cpu",
 474    .version_id = 1,
 475    .minimum_version_id = 1,
 476    .fields      = (VMStateField[]) {
 477        VMSTATE_UINT32_ARRAY(env.dregs, M68kCPU, 8),
 478        VMSTATE_UINT32_ARRAY(env.aregs, M68kCPU, 8),
 479        VMSTATE_UINT32(env.pc, M68kCPU),
 480        VMSTATE_UINT32(env.sr, M68kCPU),
 481        VMSTATE_INT32(env.current_sp, M68kCPU),
 482        VMSTATE_UINT32_ARRAY(env.sp, M68kCPU, 3),
 483        VMSTATE_UINT32(env.cc_op, M68kCPU),
 484        VMSTATE_UINT32(env.cc_x, M68kCPU),
 485        VMSTATE_UINT32(env.cc_n, M68kCPU),
 486        VMSTATE_UINT32(env.cc_v, M68kCPU),
 487        VMSTATE_UINT32(env.cc_c, M68kCPU),
 488        VMSTATE_UINT32(env.cc_z, M68kCPU),
 489        VMSTATE_INT32(env.pending_vector, M68kCPU),
 490        VMSTATE_INT32(env.pending_level, M68kCPU),
 491        VMSTATE_END_OF_LIST()
 492    },
 493    .subsections = (const VMStateDescription * []) {
 494        &vmmstate_fpu,
 495        &vmstate_cf_spregs,
 496        &vmstate_68040_mmu,
 497        &vmstate_68040_spregs,
 498        NULL
 499    },
 500};
 501#endif
 502
 503#ifndef CONFIG_USER_ONLY
 504#include "hw/core/sysemu-cpu-ops.h"
 505
 506static const struct SysemuCPUOps m68k_sysemu_ops = {
 507    .get_phys_page_debug = m68k_cpu_get_phys_page_debug,
 508};
 509#endif
 510
 511#include "hw/core/tcg-cpu-ops.h"
 512
 513static const struct TCGCPUOps m68k_tcg_ops = {
 514    .initialize = m68k_tcg_init,
 515
 516#ifndef CONFIG_USER_ONLY
 517    .tlb_fill = m68k_cpu_tlb_fill,
 518    .cpu_exec_interrupt = m68k_cpu_exec_interrupt,
 519    .do_interrupt = m68k_cpu_do_interrupt,
 520    .do_transaction_failed = m68k_cpu_transaction_failed,
 521#endif /* !CONFIG_USER_ONLY */
 522};
 523
 524static void m68k_cpu_class_init(ObjectClass *c, void *data)
 525{
 526    M68kCPUClass *mcc = M68K_CPU_CLASS(c);
 527    CPUClass *cc = CPU_CLASS(c);
 528    DeviceClass *dc = DEVICE_CLASS(c);
 529
 530    device_class_set_parent_realize(dc, m68k_cpu_realizefn,
 531                                    &mcc->parent_realize);
 532    device_class_set_parent_reset(dc, m68k_cpu_reset, &mcc->parent_reset);
 533
 534    cc->class_by_name = m68k_cpu_class_by_name;
 535    cc->has_work = m68k_cpu_has_work;
 536    cc->dump_state = m68k_cpu_dump_state;
 537    cc->set_pc = m68k_cpu_set_pc;
 538    cc->gdb_read_register = m68k_cpu_gdb_read_register;
 539    cc->gdb_write_register = m68k_cpu_gdb_write_register;
 540#if defined(CONFIG_SOFTMMU)
 541    dc->vmsd = &vmstate_m68k_cpu;
 542    cc->sysemu_ops = &m68k_sysemu_ops;
 543#endif
 544    cc->disas_set_info = m68k_cpu_disas_set_info;
 545
 546    cc->gdb_num_core_regs = 18;
 547    cc->tcg_ops = &m68k_tcg_ops;
 548}
 549
 550static void m68k_cpu_class_init_cf_core(ObjectClass *c, void *data)
 551{
 552    CPUClass *cc = CPU_CLASS(c);
 553
 554    cc->gdb_core_xml_file = "cf-core.xml";
 555}
 556
 557#define DEFINE_M68K_CPU_TYPE_CF(model)               \
 558    {                                                \
 559        .name = M68K_CPU_TYPE_NAME(#model),          \
 560        .instance_init = model##_cpu_initfn,         \
 561        .parent = TYPE_M68K_CPU,                     \
 562        .class_init = m68k_cpu_class_init_cf_core    \
 563    }
 564
 565static void m68k_cpu_class_init_m68k_core(ObjectClass *c, void *data)
 566{
 567    CPUClass *cc = CPU_CLASS(c);
 568
 569    cc->gdb_core_xml_file = "m68k-core.xml";
 570}
 571
 572#define DEFINE_M68K_CPU_TYPE_M68K(model)             \
 573    {                                                \
 574        .name = M68K_CPU_TYPE_NAME(#model),          \
 575        .instance_init = model##_cpu_initfn,         \
 576        .parent = TYPE_M68K_CPU,                     \
 577        .class_init = m68k_cpu_class_init_m68k_core  \
 578    }
 579
 580static const TypeInfo m68k_cpus_type_infos[] = {
 581    { /* base class should be registered first */
 582        .name = TYPE_M68K_CPU,
 583        .parent = TYPE_CPU,
 584        .instance_size = sizeof(M68kCPU),
 585        .instance_init = m68k_cpu_initfn,
 586        .abstract = true,
 587        .class_size = sizeof(M68kCPUClass),
 588        .class_init = m68k_cpu_class_init,
 589    },
 590    DEFINE_M68K_CPU_TYPE_M68K(m68000),
 591    DEFINE_M68K_CPU_TYPE_M68K(m68010),
 592    DEFINE_M68K_CPU_TYPE_M68K(m68020),
 593    DEFINE_M68K_CPU_TYPE_M68K(m68030),
 594    DEFINE_M68K_CPU_TYPE_M68K(m68040),
 595    DEFINE_M68K_CPU_TYPE_M68K(m68060),
 596    DEFINE_M68K_CPU_TYPE_CF(m5206),
 597    DEFINE_M68K_CPU_TYPE_CF(m5208),
 598    DEFINE_M68K_CPU_TYPE_CF(cfv4e),
 599    DEFINE_M68K_CPU_TYPE_CF(any),
 600};
 601
 602DEFINE_TYPES(m68k_cpus_type_infos)
 603