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
  27 static void m68k_cpu_set_pc(CPUState *cs, vaddr value)
  28 {
  29     M68kCPU *cpu = M68K_CPU(cs);
  30
  31     cpu->env.pc = value;
  32 }
  33
  34 static bool m68k_cpu_has_work(CPUState *cs)
  35 {
  36     return cs->interrupt_request & CPU_INTERRUPT_HARD;
  37 }
  38
  39 static void m68k_set_feature(CPUM68KState *env, int feature)
  40 {
  41     env->features |= (1u << feature);
  42 }
  43
  44 static void m68k_unset_feature(CPUM68KState *env, int feature)
  45 {
  46     env->features &= (-1u - (1u << feature));
  47 }
  48
  49 static 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
  76 static 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
  84 static 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
  99 static 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 */
 108 static 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  */
 122 static 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  */
 141 static 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  */
 172 static 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  */
 199 static 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  */
 220 static 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
 234 static 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
 246 static 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
 259 static 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
 280 static 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
 303 static 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)
 311 static 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
 319 typedef struct m68k_FPReg_tmp {
 320     FPReg *parent;
 321     uint64_t tmp_mant;
 322     uint16_t tmp_exp;
 323 } m68k_FPReg_tmp;
 324
 325 static 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
 334 static 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
 343 static 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
 352 static 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
 361 static 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
 372 static 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
 380 static 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
 389 const 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
 404 static 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
 411 const 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
 426 static bool cpu_68040_mmu_needed(void *opaque)
 427 {
 428     M68kCPU *s = opaque;
 429
 430     return m68k_feature(&s->env, M68K_FEATURE_M68040);
 431 }
 432
 433 const 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
 451 static bool cpu_68040_spregs_needed(void *opaque)
 452 {
 453     M68kCPU *s = opaque;
 454
 455     return m68k_feature(&s->env, M68K_FEATURE_M68040);
 456 }
 457
 458 const 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
 472 static 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
 506 static 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
 513 static 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
 524 static 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
 550 static 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
 565 static 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
 580 static 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
 602 DEFINE_TYPES(m68k_cpus_type_infos)