Diff for /qemu/target-ppc/translate_init.c between versions 1.1.1.3 and 1.1.1.4

version 1.1.1.3, 2018/04/24 16:43:50 version 1.1.1.4, 2018/04/24 16:49:06
Line 1 Line 1
 /*  /*
  *  PowerPC CPU initialization for qemu.   *  PowerPC CPU initialization for qemu.
  *    *
  *  Copyright (c) 2003-2005 Jocelyn Mayer   *  Copyright (c) 2003-2007 Jocelyn Mayer
  *   *
  * This library is free software; you can redistribute it and/or   * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public   * modify it under the terms of the GNU Lesser General Public
Line 23 Line 23
  * inside "#if defined(TODO) ... #endif" statements to make tests easier.   * inside "#if defined(TODO) ... #endif" statements to make tests easier.
  */   */
   
   #include "dis-asm.h"
   #include "host-utils.h"
   
 //#define PPC_DUMP_CPU  //#define PPC_DUMP_CPU
 //#define PPC_DEBUG_SPR  //#define PPC_DEBUG_SPR
   //#define PPC_DUMP_SPR_ACCESSES
   #if defined(CONFIG_USER_ONLY)
   #define TODO_USER_ONLY 1
   #endif
   
 struct ppc_def_t {  struct ppc_def_t {
     const unsigned char *name;      const unsigned char *name;
     uint32_t pvr;      uint32_t pvr;
     uint32_t pvr_mask;      uint32_t svr;
     uint32_t insns_flags;      uint64_t insns_flags;
     uint32_t flags;  
     uint64_t msr_mask;      uint64_t msr_mask;
       powerpc_mmu_t   mmu_model;
       powerpc_excp_t  excp_model;
       powerpc_input_t bus_model;
       uint32_t flags;
       int bfd_mach;
       void (*init_proc)(CPUPPCState *env);
       int  (*check_pow)(CPUPPCState *env);
 };  };
   
   /* For user-mode emulation, we don't emulate any IRQ controller */
   #if defined(CONFIG_USER_ONLY)
   #define PPC_IRQ_INIT_FN(name)                                                 \
   static inline void glue(glue(ppc, name),_irq_init) (CPUPPCState *env)         \
   {                                                                             \
   }
   #else
   #define PPC_IRQ_INIT_FN(name)                                                 \
   void glue(glue(ppc, name),_irq_init) (CPUPPCState *env);
   #endif
   
   PPC_IRQ_INIT_FN(40x);
   PPC_IRQ_INIT_FN(6xx);
   PPC_IRQ_INIT_FN(970);
   
 /* Generic callbacks:  /* Generic callbacks:
  * do nothing but store/retrieve spr value   * do nothing but store/retrieve spr value
  */   */
   #ifdef PPC_DUMP_SPR_ACCESSES
   static void spr_read_generic (void *opaque, int sprn)
   {
       gen_op_load_dump_spr(sprn);
   }
   
   static void spr_write_generic (void *opaque, int sprn)
   {
       gen_op_store_dump_spr(sprn);
   }
   #else
 static void spr_read_generic (void *opaque, int sprn)  static void spr_read_generic (void *opaque, int sprn)
 {  {
     gen_op_load_spr(sprn);      gen_op_load_spr(sprn);
Line 47  static void spr_write_generic (void *opa Line 86  static void spr_write_generic (void *opa
 {  {
     gen_op_store_spr(sprn);      gen_op_store_spr(sprn);
 }  }
   #endif
   
   #if !defined(CONFIG_USER_ONLY)
   static void spr_write_clear (void *opaque, int sprn)
   {
       gen_op_mask_spr(sprn);
   }
   #endif
   
 /* SPR common to all PPC */  /* SPR common to all PowerPC */
 /* XER */  /* XER */
 static void spr_read_xer (void *opaque, int sprn)  static void spr_read_xer (void *opaque, int sprn)
 {  {
Line 93  static void spr_read_ureg (void *opaque, Line 140  static void spr_read_ureg (void *opaque,
     gen_op_load_spr(sprn + 0x10);      gen_op_load_spr(sprn + 0x10);
 }  }
   
 /* SPR common to all non-embedded PPC (ie not 4xx) */  /* SPR common to all non-embedded PowerPC */
 /* DECR */  /* DECR */
   #if !defined(CONFIG_USER_ONLY)
 static void spr_read_decr (void *opaque, int sprn)  static void spr_read_decr (void *opaque, int sprn)
 {  {
     gen_op_load_decr();      gen_op_load_decr();
Line 104  static void spr_write_decr (void *opaque Line 152  static void spr_write_decr (void *opaque
 {  {
     gen_op_store_decr();      gen_op_store_decr();
 }  }
   #endif
   
 /* SPR common to all non-embedded PPC, except 601 */  /* SPR common to all non-embedded PowerPC, except 601 */
 /* Time base */  /* Time base */
 static void spr_read_tbl (void *opaque, int sprn)  static void spr_read_tbl (void *opaque, int sprn)
 {  {
     gen_op_load_tbl();      gen_op_load_tbl();
 }  }
   
 static void spr_write_tbl (void *opaque, int sprn)  static void spr_read_tbu (void *opaque, int sprn)
 {  {
     gen_op_store_tbl();      gen_op_load_tbu();
 }  }
   
 static void spr_read_tbu (void *opaque, int sprn)  __attribute__ (( unused ))
   static void spr_read_atbl (void *opaque, int sprn)
 {  {
     gen_op_load_tbu();      gen_op_load_atbl();
   }
   
   __attribute__ (( unused ))
   static void spr_read_atbu (void *opaque, int sprn)
   {
       gen_op_load_atbu();
   }
   
   #if !defined(CONFIG_USER_ONLY)
   static void spr_write_tbl (void *opaque, int sprn)
   {
       gen_op_store_tbl();
 }  }
   
 static void spr_write_tbu (void *opaque, int sprn)  static void spr_write_tbu (void *opaque, int sprn)
Line 127  static void spr_write_tbu (void *opaque, Line 189  static void spr_write_tbu (void *opaque,
     gen_op_store_tbu();      gen_op_store_tbu();
 }  }
   
   __attribute__ (( unused ))
   static void spr_write_atbl (void *opaque, int sprn)
   {
       gen_op_store_atbl();
   }
   
   __attribute__ (( unused ))
   static void spr_write_atbu (void *opaque, int sprn)
   {
       gen_op_store_atbu();
   }
   #endif
   
   #if !defined(CONFIG_USER_ONLY)
 /* IBAT0U...IBAT0U */  /* IBAT0U...IBAT0U */
 /* IBAT0L...IBAT7L */  /* IBAT0L...IBAT7L */
 static void spr_read_ibat (void *opaque, int sprn)  static void spr_read_ibat (void *opaque, int sprn)
Line 141  static void spr_read_ibat_h (void *opaqu Line 217  static void spr_read_ibat_h (void *opaqu
   
 static void spr_write_ibatu (void *opaque, int sprn)  static void spr_write_ibatu (void *opaque, int sprn)
 {  {
     DisasContext *ctx = opaque;  
   
     gen_op_store_ibatu((sprn - SPR_IBAT0U) / 2);      gen_op_store_ibatu((sprn - SPR_IBAT0U) / 2);
     RET_STOP(ctx);  
 }  }
   
 static void spr_write_ibatu_h (void *opaque, int sprn)  static void spr_write_ibatu_h (void *opaque, int sprn)
 {  {
     DisasContext *ctx = opaque;  
   
     gen_op_store_ibatu((sprn - SPR_IBAT4U) / 2);      gen_op_store_ibatu((sprn - SPR_IBAT4U) / 2);
     RET_STOP(ctx);  
 }  }
   
 static void spr_write_ibatl (void *opaque, int sprn)  static void spr_write_ibatl (void *opaque, int sprn)
 {  {
     DisasContext *ctx = opaque;  
   
     gen_op_store_ibatl((sprn - SPR_IBAT0L) / 2);      gen_op_store_ibatl((sprn - SPR_IBAT0L) / 2);
     RET_STOP(ctx);  
 }  }
   
 static void spr_write_ibatl_h (void *opaque, int sprn)  static void spr_write_ibatl_h (void *opaque, int sprn)
 {  {
     DisasContext *ctx = opaque;  
   
     gen_op_store_ibatl((sprn - SPR_IBAT4L) / 2);      gen_op_store_ibatl((sprn - SPR_IBAT4L) / 2);
     RET_STOP(ctx);  
 }  }
   
 /* DBAT0U...DBAT7U */  /* DBAT0U...DBAT7U */
Line 180  static void spr_read_dbat (void *opaque, Line 244  static void spr_read_dbat (void *opaque,
   
 static void spr_read_dbat_h (void *opaque, int sprn)  static void spr_read_dbat_h (void *opaque, int sprn)
 {  {
     gen_op_load_dbat(sprn & 1, (sprn - SPR_DBAT4U) / 2);      gen_op_load_dbat(sprn & 1, ((sprn - SPR_DBAT4U) / 2) + 4);
 }  }
   
 static void spr_write_dbatu (void *opaque, int sprn)  static void spr_write_dbatu (void *opaque, int sprn)
 {  {
     DisasContext *ctx = opaque;  
   
     gen_op_store_dbatu((sprn - SPR_DBAT0U) / 2);      gen_op_store_dbatu((sprn - SPR_DBAT0U) / 2);
     RET_STOP(ctx);  
 }  }
   
 static void spr_write_dbatu_h (void *opaque, int sprn)  static void spr_write_dbatu_h (void *opaque, int sprn)
 {  {
     DisasContext *ctx = opaque;      gen_op_store_dbatu(((sprn - SPR_DBAT4U) / 2) + 4);
   
     gen_op_store_dbatu((sprn - SPR_DBAT4U) / 2);  
     RET_STOP(ctx);  
 }  }
   
 static void spr_write_dbatl (void *opaque, int sprn)  static void spr_write_dbatl (void *opaque, int sprn)
 {  {
     DisasContext *ctx = opaque;  
   
     gen_op_store_dbatl((sprn - SPR_DBAT0L) / 2);      gen_op_store_dbatl((sprn - SPR_DBAT0L) / 2);
     RET_STOP(ctx);  
 }  }
   
 static void spr_write_dbatl_h (void *opaque, int sprn)  static void spr_write_dbatl_h (void *opaque, int sprn)
 {  {
     DisasContext *ctx = opaque;      gen_op_store_dbatl(((sprn - SPR_DBAT4L) / 2) + 4);
   
     gen_op_store_dbatl((sprn - SPR_DBAT4L) / 2);  
     RET_STOP(ctx);  
 }  }
   
 /* SDR1 */  /* SDR1 */
Line 223  static void spr_read_sdr1 (void *opaque, Line 275  static void spr_read_sdr1 (void *opaque,
   
 static void spr_write_sdr1 (void *opaque, int sprn)  static void spr_write_sdr1 (void *opaque, int sprn)
 {  {
       gen_op_store_sdr1();
   }
   
   /* 64 bits PowerPC specific SPRs */
   /* ASR */
   #if defined(TARGET_PPC64)
   static void spr_read_asr (void *opaque, int sprn)
   {
       gen_op_load_asr();
   }
   
   static void spr_write_asr (void *opaque, int sprn)
   {
       gen_op_store_asr();
   }
   #endif
   #endif
   
   /* PowerPC 601 specific registers */
   /* RTC */
   static void spr_read_601_rtcl (void *opaque, int sprn)
   {
       gen_op_load_601_rtcl();
   }
   
   static void spr_read_601_rtcu (void *opaque, int sprn)
   {
       gen_op_load_601_rtcu();
   }
   
   #if !defined(CONFIG_USER_ONLY)
   static void spr_write_601_rtcu (void *opaque, int sprn)
   {
       gen_op_store_601_rtcu();
   }
   
   static void spr_write_601_rtcl (void *opaque, int sprn)
   {
       gen_op_store_601_rtcl();
   }
   
   static void spr_write_hid0_601 (void *opaque, int sprn)
   {
     DisasContext *ctx = opaque;      DisasContext *ctx = opaque;
   
     gen_op_store_sdr1();      gen_op_store_hid0_601();
     RET_STOP(ctx);      /* Must stop the translation as endianness may have changed */
       GEN_STOP(ctx);
   }
   #endif
   
   /* Unified bats */
   #if !defined(CONFIG_USER_ONLY)
   static void spr_read_601_ubat (void *opaque, int sprn)
   {
       gen_op_load_601_bat(sprn & 1, (sprn - SPR_IBAT0U) / 2);
   }
   
   static void spr_write_601_ubatu (void *opaque, int sprn)
   {
       gen_op_store_601_batu((sprn - SPR_IBAT0U) / 2);
   }
   
   static void spr_write_601_ubatl (void *opaque, int sprn)
   {
       gen_op_store_601_batl((sprn - SPR_IBAT0L) / 2);
   }
   #endif
   
   /* PowerPC 40x specific registers */
   #if !defined(CONFIG_USER_ONLY)
   static void spr_read_40x_pit (void *opaque, int sprn)
   {
       gen_op_load_40x_pit();
   }
   
   static void spr_write_40x_pit (void *opaque, int sprn)
   {
       gen_op_store_40x_pit();
   }
   
   static void spr_write_40x_dbcr0 (void *opaque, int sprn)
   {
       DisasContext *ctx = opaque;
   
       gen_op_store_40x_dbcr0();
       /* We must stop translation as we may have rebooted */
       GEN_STOP(ctx);
   }
   
   static void spr_write_40x_sler (void *opaque, int sprn)
   {
       gen_op_store_40x_sler();
   }
   
   static void spr_write_booke_tcr (void *opaque, int sprn)
   {
       gen_op_store_booke_tcr();
   }
   
   static void spr_write_booke_tsr (void *opaque, int sprn)
   {
       gen_op_store_booke_tsr();
   }
   #endif
   
   /* PowerPC 403 specific registers */
   /* PBL1 / PBU1 / PBL2 / PBU2 */
   #if !defined(CONFIG_USER_ONLY)
   static void spr_read_403_pbr (void *opaque, int sprn)
   {
       gen_op_load_403_pb(sprn - SPR_403_PBL1);
   }
   
   static void spr_write_403_pbr (void *opaque, int sprn)
   {
       gen_op_store_403_pb(sprn - SPR_403_PBL1);
 }  }
   
 static void spr_write_pir (void *opaque, int sprn)  static void spr_write_pir (void *opaque, int sprn)
 {  {
     gen_op_store_pir();      gen_op_store_pir();
 }  }
   #endif
   
   #if !defined(CONFIG_USER_ONLY)
   /* Callback used to write the exception vector base */
   static void spr_write_excp_prefix (void *opaque, int sprn)
   {
       gen_op_store_excp_prefix();
       gen_op_store_spr(sprn);
   }
   
   static void spr_write_excp_vector (void *opaque, int sprn)
   {
       DisasContext *ctx = opaque;
   
       if (sprn >= SPR_BOOKE_IVOR0 && sprn <= SPR_BOOKE_IVOR15) {
           gen_op_store_excp_vector(sprn - SPR_BOOKE_IVOR0);
           gen_op_store_spr(sprn);
       } else if (sprn >= SPR_BOOKE_IVOR32 && sprn <= SPR_BOOKE_IVOR37) {
           gen_op_store_excp_vector(sprn - SPR_BOOKE_IVOR32 + 32);
           gen_op_store_spr(sprn);
       } else {
           printf("Trying to write an unknown exception vector %d %03x\n",
                  sprn, sprn);
           GEN_EXCP_PRIVREG(ctx);
       }
   }
   #endif
   
   #if defined(CONFIG_USER_ONLY)
   #define spr_register(env, num, name, uea_read, uea_write,                     \
                        oea_read, oea_write, initial_value)                      \
   do {                                                                          \
        _spr_register(env, num, name, uea_read, uea_write, initial_value);       \
   } while (0)
   static inline void _spr_register (CPUPPCState *env, int num,
                                     const unsigned char *name,
                                     void (*uea_read)(void *opaque, int sprn),
                                     void (*uea_write)(void *opaque, int sprn),
                                     target_ulong initial_value)
   #else
 static inline void spr_register (CPUPPCState *env, int num,  static inline void spr_register (CPUPPCState *env, int num,
                                  const unsigned char *name,                                   const unsigned char *name,
                                  void (*uea_read)(void *opaque, int sprn),                                   void (*uea_read)(void *opaque, int sprn),
Line 241  static inline void spr_register (CPUPPCS Line 445  static inline void spr_register (CPUPPCS
                                  void (*oea_read)(void *opaque, int sprn),                                   void (*oea_read)(void *opaque, int sprn),
                                  void (*oea_write)(void *opaque, int sprn),                                   void (*oea_write)(void *opaque, int sprn),
                                  target_ulong initial_value)                                   target_ulong initial_value)
   #endif
 {  {
     ppc_spr_t *spr;      ppc_spr_t *spr;
   
     spr = &env->spr_cb[num];      spr = &env->spr_cb[num];
     if (spr->name != NULL ||env-> spr[num] != 0x00000000 ||      if (spr->name != NULL ||env-> spr[num] != 0x00000000 ||
         spr->uea_read != NULL || spr->uea_write != NULL ||  #if !defined(CONFIG_USER_ONLY)
         spr->oea_read != NULL || spr->oea_write != NULL) {          spr->oea_read != NULL || spr->oea_write != NULL ||
   #endif
           spr->uea_read != NULL || spr->uea_write != NULL) {
         printf("Error: Trying to register SPR %d (%03x) twice !\n", num, num);          printf("Error: Trying to register SPR %d (%03x) twice !\n", num, num);
         exit(1);          exit(1);
     }      }
 #if defined(PPC_DEBUG_SPR)  #if defined(PPC_DEBUG_SPR)
     printf("*** register spr %d (%03x) %s val %08" PRIx64 "\n", num, num, name,      printf("*** register spr %d (%03x) %s val " ADDRX "\n", num, num, name,
            (unsigned long long)initial_value);             initial_value);
 #endif  #endif
     spr->name = name;      spr->name = name;
     spr->uea_read = uea_read;      spr->uea_read = uea_read;
     spr->uea_write = uea_write;      spr->uea_write = uea_write;
   #if !defined(CONFIG_USER_ONLY)
     spr->oea_read = oea_read;      spr->oea_read = oea_read;
     spr->oea_write = oea_write;      spr->oea_write = oea_write;
   #endif
     env->spr[num] = initial_value;      env->spr[num] = initial_value;
 }  }
   
Line 335  static void gen_spr_ne_601 (CPUPPCState  Line 544  static void gen_spr_ne_601 (CPUPPCState 
 /* BATs 0-3 */  /* BATs 0-3 */
 static void gen_low_BATs (CPUPPCState *env)  static void gen_low_BATs (CPUPPCState *env)
 {  {
   #if !defined(CONFIG_USER_ONLY)
     spr_register(env, SPR_IBAT0U, "IBAT0U",      spr_register(env, SPR_IBAT0U, "IBAT0U",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_ibat, &spr_write_ibatu,                   &spr_read_ibat, &spr_write_ibatu,
Line 399  static void gen_low_BATs (CPUPPCState *e Line 609  static void gen_low_BATs (CPUPPCState *e
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_dbat, &spr_write_dbatl,                   &spr_read_dbat, &spr_write_dbatl,
                  0x00000000);                   0x00000000);
     env->nb_BATs = 4;      env->nb_BATs += 4;
   #endif
 }  }
   
 /* BATs 4-7 */  /* BATs 4-7 */
 static void gen_high_BATs (CPUPPCState *env)  static void gen_high_BATs (CPUPPCState *env)
 {  {
   #if !defined(CONFIG_USER_ONLY)
     spr_register(env, SPR_IBAT4U, "IBAT4U",      spr_register(env, SPR_IBAT4U, "IBAT4U",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_ibat_h, &spr_write_ibatu_h,                   &spr_read_ibat_h, &spr_write_ibatu_h,
Line 469  static void gen_high_BATs (CPUPPCState * Line 681  static void gen_high_BATs (CPUPPCState *
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_dbat_h, &spr_write_dbatl_h,                   &spr_read_dbat_h, &spr_write_dbatl_h,
                  0x00000000);                   0x00000000);
     env->nb_BATs = 8;      env->nb_BATs += 4;
   #endif
 }  }
   
 /* Generic PowerPC time base */  /* Generic PowerPC time base */
Line 493  static void gen_tbl (CPUPPCState *env) Line 706  static void gen_tbl (CPUPPCState *env)
                  0x00000000);                   0x00000000);
 }  }
   
   /* Softare table search registers */
   static void gen_6xx_7xx_soft_tlb (CPUPPCState *env, int nb_tlbs, int nb_ways)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = nb_tlbs;
       env->nb_ways = nb_ways;
       env->id_tlbs = 1;
       spr_register(env, SPR_DMISS, "DMISS",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_DCMP, "DCMP",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_HASH1, "HASH1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_HASH2, "HASH2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_IMISS, "IMISS",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_ICMP, "ICMP",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_RPA, "RPA",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   #endif
   }
   
   /* SPR common to MPC755 and G2 */
   static void gen_spr_G2_755 (CPUPPCState *env)
   {
       /* SGPRs */
       spr_register(env, SPR_SPRG4, "SPRG4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_SPRG5, "SPRG5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_SPRG6, "SPRG6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_SPRG7, "SPRG7",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
 /* SPR common to all 7xx PowerPC implementations */  /* SPR common to all 7xx PowerPC implementations */
 static void gen_spr_7xx (CPUPPCState *env)  static void gen_spr_7xx (CPUPPCState *env)
 {  {
Line 545  static void gen_spr_7xx (CPUPPCState *en Line 818  static void gen_spr_7xx (CPUPPCState *en
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   0x00000000);
     /* XXX : not implemented */      /* XXX : not implemented */
     spr_register(env, SPR_SIA, "SIA",      spr_register(env, SPR_SIAR, "SIAR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, SPR_NOACCESS,                   &spr_read_generic, SPR_NOACCESS,
                  0x00000000);                   0x00000000);
       /* XXX : not implemented */
     spr_register(env, SPR_UMMCR0, "UMMCR0",      spr_register(env, SPR_UMMCR0, "UMMCR0",
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  0x00000000);                   0x00000000);
       /* XXX : not implemented */
     spr_register(env, SPR_UMMCR1, "UMMCR1",      spr_register(env, SPR_UMMCR1, "UMMCR1",
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  0x00000000);                   0x00000000);
       /* XXX : not implemented */
     spr_register(env, SPR_UPMC1, "UPMC1",      spr_register(env, SPR_UPMC1, "UPMC1",
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  0x00000000);                   0x00000000);
       /* XXX : not implemented */
     spr_register(env, SPR_UPMC2, "UPMC2",      spr_register(env, SPR_UPMC2, "UPMC2",
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  0x00000000);                   0x00000000);
       /* XXX : not implemented */
     spr_register(env, SPR_UPMC3, "UPMC3",      spr_register(env, SPR_UPMC3, "UPMC3",
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  0x00000000);                   0x00000000);
       /* XXX : not implemented */
     spr_register(env, SPR_UPMC4, "UPMC4",      spr_register(env, SPR_UPMC4, "UPMC4",
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  0x00000000);                   0x00000000);
     spr_register(env, SPR_USIA, "USIA",      /* XXX : not implemented */
       spr_register(env, SPR_USIAR, "USIAR",
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  &spr_read_ureg, SPR_NOACCESS,                   &spr_read_ureg, SPR_NOACCESS,
                  0x00000000);                   0x00000000);
     /* Thermal management */      /* External access control */
     /* XXX : not implemented */      /* XXX : not implemented */
     spr_register(env, SPR_THRM1, "THRM1",      spr_register(env, SPR_EAR, "EAR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   0x00000000);
   }
   
   static void gen_spr_thrm (CPUPPCState *env)
   {
       /* Thermal management */
     /* XXX : not implemented */      /* XXX : not implemented */
     spr_register(env, SPR_THRM2, "THRM2",      spr_register(env, SPR_THRM1, "THRM1",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   0x00000000);
     /* XXX : not implemented */      /* XXX : not implemented */
     spr_register(env, SPR_THRM3, "THRM3",      spr_register(env, SPR_THRM2, "THRM2",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   0x00000000);
     /* External access control */  
     /* XXX : not implemented */      /* XXX : not implemented */
     spr_register(env, SPR_EAR, "EAR",      spr_register(env, SPR_THRM3, "THRM3",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   0x00000000);
Line 627  static void gen_spr_604 (CPUPPCState *en Line 911  static void gen_spr_604 (CPUPPCState *en
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   0x00000000);
     /* XXX : not implemented */      /* XXX : not implemented */
     spr_register(env, SPR_MMCR1, "MMCR1",  
                  SPR_NOACCESS, SPR_NOACCESS,  
                  &spr_read_generic, &spr_write_generic,  
                  0x00000000);  
     /* XXX : not implemented */  
     spr_register(env, SPR_PMC1, "PMC1",      spr_register(env, SPR_PMC1, "PMC1",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
Line 642  static void gen_spr_604 (CPUPPCState *en Line 921  static void gen_spr_604 (CPUPPCState *en
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   0x00000000);
     /* XXX : not implemented */      /* XXX : not implemented */
     spr_register(env, SPR_PMC3, "PMC3",      spr_register(env, SPR_SIAR, "SIAR",
                  SPR_NOACCESS, SPR_NOACCESS,  
                  &spr_read_generic, &spr_write_generic,  
                  0x00000000);  
     /* XXX : not implemented */  
     spr_register(env, SPR_PMC4, "PMC4",  
                  SPR_NOACCESS, SPR_NOACCESS,  
                  &spr_read_generic, &spr_write_generic,  
                  0x00000000);  
     /* XXX : not implemented */  
     spr_register(env, SPR_SIA, "SIA",  
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, SPR_NOACCESS,                   &spr_read_generic, SPR_NOACCESS,
                  0x00000000);                   0x00000000);
Line 669  static void gen_spr_604 (CPUPPCState *en Line 938  static void gen_spr_604 (CPUPPCState *en
                  0x00000000);                   0x00000000);
 }  }
   
 // XXX: TODO (64 bits PPC sprs)  /* SPR specific to PowerPC 603 implementation */
 /*  static void gen_spr_603 (CPUPPCState *env)
  * ASR => SPR 280 (64 bits)  
  * FPECR => SPR 1022 (?)  
  * VRSAVE => SPR 256 (Altivec)  
  * SCOMC => SPR 276 (64 bits ?)  
  * SCOMD => SPR 277 (64 bits ?)  
  * HSPRG0 => SPR 304 (hypervisor)  
  * HSPRG1 => SPR 305 (hypervisor)  
  * HDEC => SPR 310 (hypervisor)  
  * HIOR => SPR 311 (hypervisor)  
  * RMOR => SPR 312 (970)  
  * HRMOR => SPR 313 (hypervisor)  
  * HSRR0 => SPR 314 (hypervisor)  
  * HSRR1 => SPR 315 (hypervisor)  
  * LPCR => SPR 316 (970)  
  * LPIDR => SPR 317 (970)  
  * ... and more (thermal management, performance counters, ...)  
  */  
   
 static void init_ppc_proc (CPUPPCState *env, ppc_def_t *def)  
 {  {
     /* Default MMU definitions */      /* External access control */
     env->nb_BATs = -1;      /* XXX : not implemented */
     env->nb_tlb = 0;      spr_register(env, SPR_EAR, "EAR",
     env->nb_ways = 0;  
     /* XXX: missing:  
      * 32 bits PPC:  
      * - MPC5xx(x)  
      * - MPC8xx(x)  
      * - RCPU (MPC5xx)  
      */  
     spr_register(env, SPR_PVR, "PVR",  
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, SPR_NOACCESS,                   &spr_read_generic, &spr_write_generic,
                  def->pvr);                   0x00000000);
     switch (def->pvr & def->pvr_mask) {  }
     case CPU_PPC_604:     /* PPC 604                       */  
     case CPU_PPC_604E:    /* PPC 604e                      */  
     case CPU_PPC_604R:    /* PPC 604r                      */  
         gen_spr_generic(env);  
         gen_spr_ne_601(env);  
         /* Memory management */  
         gen_low_BATs(env);  
         /* Time base */  
         gen_tbl(env);  
         gen_spr_604(env);  
         /* Hardware implementation registers */  
         /* XXX : not implemented */  
         spr_register(env, SPR_HID0, "HID0",  
                      SPR_NOACCESS, SPR_NOACCESS,  
                      &spr_read_generic, &spr_write_generic,  
                      0x00000000);  
         /* XXX : not implemented */  
         spr_register(env, SPR_HID1, "HID1",  
                      SPR_NOACCESS, SPR_NOACCESS,  
                      &spr_read_generic, &spr_write_generic,  
                      0x00000000);  
         break;  
   
     case CPU_PPC_74x:     /* PPC 740 / 750                 */  /* SPR specific to PowerPC G2 implementation */
     case CPU_PPC_74xP:    /* PPC 740P / 750P               */  static void gen_spr_G2 (CPUPPCState *env)
     case CPU_PPC_750CXE:  /* IBM PPC 750cxe                */  {
         gen_spr_generic(env);      /* Memory base address */
         gen_spr_ne_601(env);      /* MBAR */
         /* Memory management */      /* XXX : not implemented */
         gen_low_BATs(env);      spr_register(env, SPR_MBAR, "MBAR",
         /* Time base */  
         gen_tbl(env);  
         gen_spr_7xx(env);  
         /* XXX : not implemented */  
         spr_register(env, SPR_L2CR, "L2CR",  
                      SPR_NOACCESS, SPR_NOACCESS,  
                      &spr_read_generic, &spr_write_generic,  
                      0x00000000);  
         /* Hardware implementation registers */  
         /* XXX : not implemented */  
         spr_register(env, SPR_HID0, "HID0",  
                      SPR_NOACCESS, SPR_NOACCESS,  
                      &spr_read_generic, &spr_write_generic,  
                      0x00000000);  
         /* XXX : not implemented */  
         spr_register(env, SPR_HID1, "HID1",  
                      SPR_NOACCESS, SPR_NOACCESS,  
                      &spr_read_generic, &spr_write_generic,  
                      0x00000000);  
         break;  
   
     case CPU_PPC_750FX:   /* IBM PPC 750 FX                */  
     case CPU_PPC_750GX:   /* IBM PPC 750 GX                */  
         gen_spr_generic(env);  
         gen_spr_ne_601(env);  
         /* Memory management */  
         gen_low_BATs(env);  
         /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */  
         gen_high_BATs(env);  
         /* Time base */  
         gen_tbl(env);  
         gen_spr_7xx(env);  
         /* XXX : not implemented */  
         spr_register(env, SPR_L2CR, "L2CR",  
                      SPR_NOACCESS, SPR_NOACCESS,  
                      &spr_read_generic, &spr_write_generic,  
                      0x00000000);  
         /* Hardware implementation registers */  
         /* XXX : not implemented */  
         spr_register(env, SPR_HID0, "HID0",  
                      SPR_NOACCESS, SPR_NOACCESS,  
                      &spr_read_generic, &spr_write_generic,  
                      0x00000000);  
         /* XXX : not implemented */  
         spr_register(env, SPR_HID1, "HID1",  
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                      &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                      0x00000000);                   0x00000000);
         /* XXX : not implemented */      /* Exception processing */
         spr_register(env, SPR_750_HID2, "HID2",      spr_register(env, SPR_BOOKE_CSRR0, "CSRR0",
                      SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                      &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                      0x00000000);                   0x00000000);
         break;      spr_register(env, SPR_BOOKE_CSRR1, "CSRR1",
                    SPR_NOACCESS, SPR_NOACCESS,
     default:                   &spr_read_generic, &spr_write_generic,
         gen_spr_generic(env);                   0x00000000);
         break;      /* Breakpoints */
     }      /* XXX : not implemented */
     if (env->nb_BATs == -1)      spr_register(env, SPR_DABR, "DABR",
         env->nb_BATs = 4;                   SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_DABR2, "DABR2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_IABR, "IABR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_IABR2, "IABR2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_IBCR, "IBCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_DBCR, "DBCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
 }  }
   
 #if defined(PPC_DUMP_CPU)  /* SPR specific to PowerPC 602 implementation */
 static void dump_sprs (CPUPPCState *env)  static void gen_spr_602 (CPUPPCState *env)
 {  {
     ppc_spr_t *spr;      /* ESA registers */
     uint32_t pvr = env->spr[SPR_PVR];      /* XXX : not implemented */
     uint32_t sr, sw, ur, uw;      spr_register(env, SPR_SER, "SER",
     int i, j, n;                   SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
     printf("* SPRs for PVR=%08x\n", pvr);                   0x00000000);
     for (i = 0; i < 32; i++) {      /* XXX : not implemented */
         for (j = 0; j < 32; j++) {      spr_register(env, SPR_SEBR, "SEBR",
             n = (i << 5) | j;                   SPR_NOACCESS, SPR_NOACCESS,
             spr = &env->spr_cb[n];                   &spr_read_generic, &spr_write_generic,
             sw = spr->oea_write != NULL && spr->oea_write != SPR_NOACCESS;                   0x00000000);
             sr = spr->oea_read != NULL && spr->oea_read != SPR_NOACCESS;      /* XXX : not implemented */
             uw = spr->uea_write != NULL && spr->uea_write != SPR_NOACCESS;      spr_register(env, SPR_ESASRR, "ESASRR",
             ur = spr->uea_read != NULL && spr->uea_read != SPR_NOACCESS;                   SPR_NOACCESS, SPR_NOACCESS,
             if (sw || sr || uw || ur) {                   &spr_read_generic, &spr_write_generic,
                 printf("%4d (%03x) %8s s%c%c u%c%c\n",                   0x00000000);
                        (i << 5) | j, (i << 5) | j, spr->name,      /* Floating point status */
                        sw ? 'w' : '-', sr ? 'r' : '-',      /* XXX : not implemented */
                        uw ? 'w' : '-', ur ? 'r' : '-');      spr_register(env, SPR_SP, "SP",
             }                   SPR_NOACCESS, SPR_NOACCESS,
         }                   &spr_read_generic, &spr_write_generic,
     }                   0x00000000);
     fflush(stdout);      /* XXX : not implemented */
     fflush(stderr);      spr_register(env, SPR_LT, "LT",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Watchdog timer */
       /* XXX : not implemented */
       spr_register(env, SPR_TCR, "TCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Interrupt base */
       spr_register(env, SPR_IBR, "IBR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_IABR, "IABR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
 }  }
 #endif  
   
 /*****************************************************************************/  
 #include <stdlib.h>  
 #include <string.h>  
   
 int fflush (FILE *stream);  
   
 /* Opcode types */  
 enum {  
     PPC_DIRECT   = 0, /* Opcode routine        */  
     PPC_INDIRECT = 1, /* Indirect opcode table */  
 };  
   
 static inline int is_indirect_opcode (void *handler)  /* SPR specific to PowerPC 601 implementation */
   static void gen_spr_601 (CPUPPCState *env)
 {  {
     return ((unsigned long)handler & 0x03) == PPC_INDIRECT;      /* Multiplication/division register */
       /* MQ */
       spr_register(env, SPR_MQ, "MQ",
                    &spr_read_generic, &spr_write_generic,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* RTC registers */
       spr_register(env, SPR_601_RTCU, "RTCU",
                    SPR_NOACCESS, SPR_NOACCESS,
                    SPR_NOACCESS, &spr_write_601_rtcu,
                    0x00000000);
       spr_register(env, SPR_601_VRTCU, "RTCU",
                    &spr_read_601_rtcu, SPR_NOACCESS,
                    &spr_read_601_rtcu, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_601_RTCL, "RTCL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    SPR_NOACCESS, &spr_write_601_rtcl,
                    0x00000000);
       spr_register(env, SPR_601_VRTCL, "RTCL",
                    &spr_read_601_rtcl, SPR_NOACCESS,
                    &spr_read_601_rtcl, SPR_NOACCESS,
                    0x00000000);
       /* Timer */
   #if 0 /* ? */
       spr_register(env, SPR_601_UDECR, "UDECR",
                    &spr_read_decr, SPR_NOACCESS,
                    &spr_read_decr, SPR_NOACCESS,
                    0x00000000);
   #endif
       /* External access control */
       /* XXX : not implemented */
       spr_register(env, SPR_EAR, "EAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       spr_register(env, SPR_IBAT0U, "IBAT0U",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_601_ubat, &spr_write_601_ubatu,
                    0x00000000);
       spr_register(env, SPR_IBAT0L, "IBAT0L",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_601_ubat, &spr_write_601_ubatl,
                    0x00000000);
       spr_register(env, SPR_IBAT1U, "IBAT1U",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_601_ubat, &spr_write_601_ubatu,
                    0x00000000);
       spr_register(env, SPR_IBAT1L, "IBAT1L",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_601_ubat, &spr_write_601_ubatl,
                    0x00000000);
       spr_register(env, SPR_IBAT2U, "IBAT2U",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_601_ubat, &spr_write_601_ubatu,
                    0x00000000);
       spr_register(env, SPR_IBAT2L, "IBAT2L",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_601_ubat, &spr_write_601_ubatl,
                    0x00000000);
       spr_register(env, SPR_IBAT3U, "IBAT3U",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_601_ubat, &spr_write_601_ubatu,
                    0x00000000);
       spr_register(env, SPR_IBAT3L, "IBAT3L",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_601_ubat, &spr_write_601_ubatl,
                    0x00000000);
       env->nb_BATs = 4;
   #endif
 }  }
   
 static inline opc_handler_t **ind_table(void *handler)  static void gen_spr_74xx (CPUPPCState *env)
 {  {
     return (opc_handler_t **)((unsigned long)handler & ~3);      /* Processor identification */
       spr_register(env, SPR_PIR, "PIR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_pir,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MMCR2, "MMCR2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UMMCR2, "UMMCR2",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* XXX: not implemented */
       spr_register(env, SPR_BAMR, "BAMR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MSSCR0, "MSSCR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Altivec */
       spr_register(env, SPR_VRSAVE, "VRSAVE",
                    &spr_read_generic, &spr_write_generic,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_L2CR, "L2CR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
 }  }
   
 /* Instruction table creation */  static void gen_l3_ctrl (CPUPPCState *env)
 /* Opcodes tables creation */  
 static void fill_new_table (opc_handler_t **table, int len)  
 {  {
     int i;      /* L3CR */
       /* XXX : not implemented */
     for (i = 0; i < len; i++)      spr_register(env, SPR_L3CR, "L3CR",
         table[i] = &invalid_handler;                   SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* L3ITCR0 */
       /* XXX : not implemented */
       spr_register(env, SPR_L3ITCR0, "L3ITCR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* L3PM */
       /* XXX : not implemented */
       spr_register(env, SPR_L3PM, "L3PM",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
 }  }
   
 static int create_new_table (opc_handler_t **table, unsigned char idx)  static void gen_74xx_soft_tlb (CPUPPCState *env, int nb_tlbs, int nb_ways)
 {  {
     opc_handler_t **tmp;  #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = nb_tlbs;
       env->nb_ways = nb_ways;
       env->id_tlbs = 1;
       /* XXX : not implemented */
       spr_register(env, SPR_PTEHI, "PTEHI",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_PTELO, "PTELO",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_TLBMISS, "TLBMISS",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   #endif
   }
   
     tmp = malloc(0x20 * sizeof(opc_handler_t));  static void gen_spr_usprgh (CPUPPCState *env)
     if (tmp == NULL)  
         return -1;  
     fill_new_table(tmp, 0x20);  
     table[idx] = (opc_handler_t *)((unsigned long)tmp | PPC_INDIRECT);  
   
     return 0;  
 }  
   
 static int insert_in_table (opc_handler_t **table, unsigned char idx,  
                             opc_handler_t *handler)  
 {  {
     if (table[idx] != &invalid_handler)      spr_register(env, SPR_USPRG4, "USPRG4",
         return -1;                   &spr_read_ureg, SPR_NOACCESS,
     table[idx] = handler;                   &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
     return 0;      spr_register(env, SPR_USPRG5, "USPRG5",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_USPRG6, "USPRG6",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_USPRG7, "USPRG7",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
 }  }
   
 static int register_direct_insn (opc_handler_t **ppc_opcodes,  /* PowerPC BookE SPR */
                                  unsigned char idx, opc_handler_t *handler)  static void gen_spr_BookE (CPUPPCState *env, uint64_t ivor_mask)
 {  {
     if (insert_in_table(ppc_opcodes, idx, handler) < 0) {      const unsigned char *ivor_names[64] = {
         printf("*** ERROR: opcode %02x already assigned in main "          "IVOR0",  "IVOR1",  "IVOR2",  "IVOR3",
                 "opcode table\n", idx);          "IVOR4",  "IVOR5",  "IVOR6",  "IVOR7",
         return -1;          "IVOR8",  "IVOR9",  "IVOR10", "IVOR11",
     }          "IVOR12", "IVOR13", "IVOR14", "IVOR15",
           "IVOR16", "IVOR17", "IVOR18", "IVOR19",
     return 0;          "IVOR20", "IVOR21", "IVOR22", "IVOR23",
 }          "IVOR24", "IVOR25", "IVOR26", "IVOR27",
           "IVOR28", "IVOR29", "IVOR30", "IVOR31",
           "IVOR32", "IVOR33", "IVOR34", "IVOR35",
           "IVOR36", "IVOR37", "IVOR38", "IVOR39",
           "IVOR40", "IVOR41", "IVOR42", "IVOR43",
           "IVOR44", "IVOR45", "IVOR46", "IVOR47",
           "IVOR48", "IVOR49", "IVOR50", "IVOR51",
           "IVOR52", "IVOR53", "IVOR54", "IVOR55",
           "IVOR56", "IVOR57", "IVOR58", "IVOR59",
           "IVOR60", "IVOR61", "IVOR62", "IVOR63",
       };
   #define SPR_BOOKE_IVORxx (-1)
       int ivor_sprn[64] = {
           SPR_BOOKE_IVOR0,  SPR_BOOKE_IVOR1,  SPR_BOOKE_IVOR2,  SPR_BOOKE_IVOR3,
           SPR_BOOKE_IVOR4,  SPR_BOOKE_IVOR5,  SPR_BOOKE_IVOR6,  SPR_BOOKE_IVOR7,
           SPR_BOOKE_IVOR8,  SPR_BOOKE_IVOR9,  SPR_BOOKE_IVOR10, SPR_BOOKE_IVOR11,
           SPR_BOOKE_IVOR12, SPR_BOOKE_IVOR13, SPR_BOOKE_IVOR14, SPR_BOOKE_IVOR15,
           SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
           SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
           SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
           SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
           SPR_BOOKE_IVOR32, SPR_BOOKE_IVOR33, SPR_BOOKE_IVOR34, SPR_BOOKE_IVOR35,
           SPR_BOOKE_IVOR36, SPR_BOOKE_IVOR37, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
           SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
           SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
           SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
           SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
           SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
           SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
       };
       int i;
   
 static int register_ind_in_table (opc_handler_t **table,      /* Interrupt processing */
                                   unsigned char idx1, unsigned char idx2,      spr_register(env, SPR_BOOKE_CSRR0, "CSRR0",
                                   opc_handler_t *handler)                   SPR_NOACCESS, SPR_NOACCESS,
 {                   &spr_read_generic, &spr_write_generic,
     if (table[idx1] == &invalid_handler) {                   0x00000000);
         if (create_new_table(table, idx1) < 0) {      spr_register(env, SPR_BOOKE_CSRR1, "CSRR1",
             printf("*** ERROR: unable to create indirect table "                   SPR_NOACCESS, SPR_NOACCESS,
                     "idx=%02x\n", idx1);                   &spr_read_generic, &spr_write_generic,
             return -1;                   0x00000000);
         }      /* Debug */
     } else {      /* XXX : not implemented */
         if (!is_indirect_opcode(table[idx1])) {      spr_register(env, SPR_BOOKE_IAC1, "IAC1",
             printf("*** ERROR: idx %02x already assigned to a direct "                   SPR_NOACCESS, SPR_NOACCESS,
                     "opcode\n", idx1);                   &spr_read_generic, &spr_write_generic,
             return -1;                   0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC2, "IAC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DAC1, "DAC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DAC2, "DAC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DBCR0, "DBCR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DBCR1, "DBCR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DBCR2, "DBCR2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DBSR, "DBSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_clear,
                    0x00000000);
       spr_register(env, SPR_BOOKE_DEAR, "DEAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_ESR, "ESR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_IVPR, "IVPR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_excp_prefix,
                    0x00000000);
       /* Exception vectors */
       for (i = 0; i < 64; i++) {
           if (ivor_mask & (1ULL << i)) {
               if (ivor_sprn[i] == SPR_BOOKE_IVORxx) {
                   fprintf(stderr, "ERROR: IVOR %d SPR is not defined\n", i);
                   exit(1);
               }
               spr_register(env, ivor_sprn[i], ivor_names[i],
                            SPR_NOACCESS, SPR_NOACCESS,
                            &spr_read_generic, &spr_write_excp_vector,
                            0x00000000);
         }          }
     }      }
     if (handler != NULL &&      spr_register(env, SPR_BOOKE_PID, "PID",
         insert_in_table(ind_table(table[idx1]), idx2, handler) < 0) {                   SPR_NOACCESS, SPR_NOACCESS,
         printf("*** ERROR: opcode %02x already assigned in "                   &spr_read_generic, &spr_write_generic,
                 "opcode table %02x\n", idx2, idx1);                   0x00000000);
         return -1;      spr_register(env, SPR_BOOKE_TCR, "TCR",
     }                   SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_booke_tcr,
     return 0;                   0x00000000);
       spr_register(env, SPR_BOOKE_TSR, "TSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_booke_tsr,
                    0x00000000);
       /* Timer */
       spr_register(env, SPR_DECR, "DECR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_decr, &spr_write_decr,
                    0x00000000);
       spr_register(env, SPR_BOOKE_DECAR, "DECAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    SPR_NOACCESS, &spr_write_generic,
                    0x00000000);
       /* SPRGs */
       spr_register(env, SPR_USPRG0, "USPRG0",
                    &spr_read_generic, &spr_write_generic,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_SPRG4, "SPRG4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_SPRG5, "SPRG5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_SPRG6, "SPRG6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_SPRG7, "SPRG7",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
 }  }
   
 static int register_ind_insn (opc_handler_t **ppc_opcodes,  /* FSL storage control registers */
                               unsigned char idx1, unsigned char idx2,  static void gen_spr_BookE_FSL (CPUPPCState *env, uint32_t mas_mask)
                                opc_handler_t *handler)  
 {  {
     int ret;  #if !defined(CONFIG_USER_ONLY)
       const unsigned char *mas_names[8] = {
     ret = register_ind_in_table(ppc_opcodes, idx1, idx2, handler);          "MAS0", "MAS1", "MAS2", "MAS3", "MAS4", "MAS5", "MAS6", "MAS7",
       };
       int mas_sprn[8] = {
           SPR_BOOKE_MAS0, SPR_BOOKE_MAS1, SPR_BOOKE_MAS2, SPR_BOOKE_MAS3,
           SPR_BOOKE_MAS4, SPR_BOOKE_MAS5, SPR_BOOKE_MAS6, SPR_BOOKE_MAS7,
       };
       int i;
   
     return ret;      /* TLB assist registers */
       /* XXX : not implemented */
       for (i = 0; i < 8; i++) {
           if (mas_mask & (1 << i)) {
               spr_register(env, mas_sprn[i], mas_names[i],
                            SPR_NOACCESS, SPR_NOACCESS,
                            &spr_read_generic, &spr_write_generic,
                            0x00000000);
           }
       }
       if (env->nb_pids > 1) {
           /* XXX : not implemented */
           spr_register(env, SPR_BOOKE_PID1, "PID1",
                        SPR_NOACCESS, SPR_NOACCESS,
                        &spr_read_generic, &spr_write_generic,
                        0x00000000);
       }
       if (env->nb_pids > 2) {
           /* XXX : not implemented */
           spr_register(env, SPR_BOOKE_PID2, "PID2",
                        SPR_NOACCESS, SPR_NOACCESS,
                        &spr_read_generic, &spr_write_generic,
                        0x00000000);
       }
       /* XXX : not implemented */
       spr_register(env, SPR_MMUCFG, "MMUCFG",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000); /* TOFIX */
       /* XXX : not implemented */
       spr_register(env, SPR_MMUCSR0, "MMUCSR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000); /* TOFIX */
       switch (env->nb_ways) {
       case 4:
           /* XXX : not implemented */
           spr_register(env, SPR_BOOKE_TLB3CFG, "TLB3CFG",
                        SPR_NOACCESS, SPR_NOACCESS,
                        &spr_read_generic, SPR_NOACCESS,
                        0x00000000); /* TOFIX */
           /* Fallthru */
       case 3:
           /* XXX : not implemented */
           spr_register(env, SPR_BOOKE_TLB2CFG, "TLB2CFG",
                        SPR_NOACCESS, SPR_NOACCESS,
                        &spr_read_generic, SPR_NOACCESS,
                        0x00000000); /* TOFIX */
           /* Fallthru */
       case 2:
           /* XXX : not implemented */
           spr_register(env, SPR_BOOKE_TLB1CFG, "TLB1CFG",
                        SPR_NOACCESS, SPR_NOACCESS,
                        &spr_read_generic, SPR_NOACCESS,
                        0x00000000); /* TOFIX */
           /* Fallthru */
       case 1:
           /* XXX : not implemented */
           spr_register(env, SPR_BOOKE_TLB0CFG, "TLB0CFG",
                        SPR_NOACCESS, SPR_NOACCESS,
                        &spr_read_generic, SPR_NOACCESS,
                        0x00000000); /* TOFIX */
           /* Fallthru */
       case 0:
       default:
           break;
       }
   #endif
 }  }
   
 static int register_dblind_insn (opc_handler_t **ppc_opcodes,   /* SPR specific to PowerPC 440 implementation */
                                  unsigned char idx1, unsigned char idx2,  static void gen_spr_440 (CPUPPCState *env)
                                   unsigned char idx3, opc_handler_t *handler)  
 {  {
     if (register_ind_in_table(ppc_opcodes, idx1, idx2, NULL) < 0) {      /* Cache control */
         printf("*** ERROR: unable to join indirect table idx "      /* XXX : not implemented */
                 "[%02x-%02x]\n", idx1, idx2);      spr_register(env, SPR_440_DNV0, "DNV0",
         return -1;                   SPR_NOACCESS, SPR_NOACCESS,
     }                   &spr_read_generic, &spr_write_generic,
     if (register_ind_in_table(ind_table(ppc_opcodes[idx1]), idx2, idx3,                   0x00000000);
                               handler) < 0) {      /* XXX : not implemented */
         printf("*** ERROR: unable to insert opcode "      spr_register(env, SPR_440_DNV1, "DNV1",
                 "[%02x-%02x-%02x]\n", idx1, idx2, idx3);                   SPR_NOACCESS, SPR_NOACCESS,
         return -1;                   &spr_read_generic, &spr_write_generic,
     }                   0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_DNV2, "DNV2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_DNV3, "DNV3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_DTV0, "DTV0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_DTV1, "DTV1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_DTV2, "DTV2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_DTV3, "DTV3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_DVLIM, "DVLIM",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_INV0, "INV0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_INV1, "INV1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_INV2, "INV2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_INV3, "INV3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_ITV0, "ITV0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_ITV1, "ITV1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_ITV2, "ITV2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_ITV3, "ITV3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_IVLIM, "IVLIM",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Cache debug */
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DCDBTRH, "DCDBTRH",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DCDBTRL, "DCDBTRL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_ICDBDR, "ICDBDR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_ICDBTRH, "ICDBTRH",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_ICDBTRL, "ICDBTRL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_DBDR, "DBDR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Processor control */
       spr_register(env, SPR_4xx_CCR0, "CCR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_440_RSTCFG, "RSTCFG",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       /* Storage control */
       spr_register(env, SPR_440_MMUCR, "MMUCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   /* SPR shared between PowerPC 40x implementations */
   static void gen_spr_40x (CPUPPCState *env)
   {
       /* Cache */
       /* not emulated, as Qemu do not emulate caches */
       spr_register(env, SPR_40x_DCCR, "DCCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* not emulated, as Qemu do not emulate caches */
       spr_register(env, SPR_40x_ICCR, "ICCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* not emulated, as Qemu do not emulate caches */
       spr_register(env, SPR_BOOKE_ICDBDR, "ICDBDR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       /* Exception */
       spr_register(env, SPR_40x_DEAR, "DEAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_40x_ESR, "ESR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_40x_EVPR, "EVPR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_excp_prefix,
                    0x00000000);
       spr_register(env, SPR_40x_SRR2, "SRR2",
                    &spr_read_generic, &spr_write_generic,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_40x_SRR3, "SRR3",
                    &spr_read_generic, &spr_write_generic,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Timers */
       spr_register(env, SPR_40x_PIT, "PIT",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_40x_pit, &spr_write_40x_pit,
                    0x00000000);
       spr_register(env, SPR_40x_TCR, "TCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_booke_tcr,
                    0x00000000);
       spr_register(env, SPR_40x_TSR, "TSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_booke_tsr,
                    0x00000000);
   }
   
   /* SPR specific to PowerPC 405 implementation */
   static void gen_spr_405 (CPUPPCState *env)
   {
       /* MMU */
       spr_register(env, SPR_40x_PID, "PID",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_4xx_CCR0, "CCR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00700000);
       /* Debug interface */
       /* XXX : not implemented */
       spr_register(env, SPR_40x_DBCR0, "DBCR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_40x_dbcr0,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_405_DBCR1, "DBCR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_DBSR, "DBSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_clear,
                    /* Last reset was system reset */
                    0x00000300);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_DAC1, "DAC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_40x_DAC2, "DAC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_405_DVC1, "DVC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_405_DVC2, "DVC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_IAC1, "IAC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_40x_IAC2, "IAC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_405_IAC3, "IAC3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_405_IAC4, "IAC4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Storage control */
       /* XXX: TODO: not implemented */
       spr_register(env, SPR_405_SLER, "SLER",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_40x_sler,
                    0x00000000);
       spr_register(env, SPR_40x_ZPR, "ZPR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_405_SU0R, "SU0R",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* SPRG */
       spr_register(env, SPR_USPRG0, "USPRG0",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_SPRG4, "SPRG4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_SPRG5, "SPRG5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_SPRG6, "SPRG6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_SPRG7, "SPRG7",
                    SPR_NOACCESS, SPR_NOACCESS,
                    spr_read_generic, &spr_write_generic,
                    0x00000000);
       gen_spr_usprgh(env);
   }
   
   /* SPR shared between PowerPC 401 & 403 implementations */
   static void gen_spr_401_403 (CPUPPCState *env)
   {
       /* Time base */
       spr_register(env, SPR_403_VTBL,  "TBL",
                    &spr_read_tbl, SPR_NOACCESS,
                    &spr_read_tbl, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_403_TBL,   "TBL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    SPR_NOACCESS, &spr_write_tbl,
                    0x00000000);
       spr_register(env, SPR_403_VTBU,  "TBU",
                    &spr_read_tbu, SPR_NOACCESS,
                    &spr_read_tbu, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_403_TBU,   "TBU",
                    SPR_NOACCESS, SPR_NOACCESS,
                    SPR_NOACCESS, &spr_write_tbu,
                    0x00000000);
       /* Debug */
       /* not emulated, as Qemu do not emulate caches */
       spr_register(env, SPR_403_CDBCR, "CDBCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   /* SPR specific to PowerPC 401 implementation */
   static void gen_spr_401 (CPUPPCState *env)
   {
       /* Debug interface */
       /* XXX : not implemented */
       spr_register(env, SPR_40x_DBCR0, "DBCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_40x_dbcr0,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_DBSR, "DBSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_clear,
                    /* Last reset was system reset */
                    0x00000300);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_DAC1, "DAC",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_IAC1, "IAC",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Storage control */
       /* XXX: TODO: not implemented */
       spr_register(env, SPR_405_SLER, "SLER",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_40x_sler,
                    0x00000000);
       /* not emulated, as Qemu never does speculative access */
       spr_register(env, SPR_40x_SGR, "SGR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0xFFFFFFFF);
       /* not emulated, as Qemu do not emulate caches */
       spr_register(env, SPR_40x_DCWR, "DCWR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   static void gen_spr_401x2 (CPUPPCState *env)
   {
       gen_spr_401(env);
       spr_register(env, SPR_40x_PID, "PID",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_40x_ZPR, "ZPR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   /* SPR specific to PowerPC 403 implementation */
   static void gen_spr_403 (CPUPPCState *env)
   {
       /* Debug interface */
       /* XXX : not implemented */
       spr_register(env, SPR_40x_DBCR0, "DBCR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_40x_dbcr0,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_DBSR, "DBSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_clear,
                    /* Last reset was system reset */
                    0x00000300);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_DAC1, "DAC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_DAC2, "DAC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_IAC1, "IAC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_40x_IAC2, "IAC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   static void gen_spr_403_real (CPUPPCState *env)
   {
       spr_register(env, SPR_403_PBL1,  "PBL1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_403_pbr, &spr_write_403_pbr,
                    0x00000000);
       spr_register(env, SPR_403_PBU1,  "PBU1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_403_pbr, &spr_write_403_pbr,
                    0x00000000);
       spr_register(env, SPR_403_PBL2,  "PBL2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_403_pbr, &spr_write_403_pbr,
                    0x00000000);
       spr_register(env, SPR_403_PBU2,  "PBU2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_403_pbr, &spr_write_403_pbr,
                    0x00000000);
   }
   
   static void gen_spr_403_mmu (CPUPPCState *env)
   {
       /* MMU */
       spr_register(env, SPR_40x_PID, "PID",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_40x_ZPR, "ZPR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   /* SPR specific to PowerPC compression coprocessor extension */
   static void gen_spr_compress (CPUPPCState *env)
   {
       /* XXX : not implemented */
       spr_register(env, SPR_401_SKR, "SKR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   #if defined (TARGET_PPC64)
   /* SPR specific to PowerPC 620 */
   static void gen_spr_620 (CPUPPCState *env)
   {
       /* Processor identification */
       spr_register(env, SPR_PIR, "PIR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_pir,
                    0x00000000);
       spr_register(env, SPR_ASR, "ASR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_asr, &spr_write_asr,
                    0x00000000);
       /* Breakpoints */
       /* XXX : not implemented */
       spr_register(env, SPR_IABR, "IABR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_DABR, "DABR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_SIAR, "SIAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_SDA, "SDA",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMC1R, "PMC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_620_PMC1W, "PMC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                     SPR_NOACCESS, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMC2R, "PMC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_620_PMC2W, "PMC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                     SPR_NOACCESS, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_MMCR0R, "MMCR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_620_MMCR0W, "MMCR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                     SPR_NOACCESS, &spr_write_generic,
                    0x00000000);
       /* External access control */
       /* XXX : not implemented */
       spr_register(env, SPR_EAR, "EAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   #if 0 // XXX: check this
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMR0, "PMR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMR1, "PMR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMR2, "PMR2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMR3, "PMR3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMR4, "PMR4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMR5, "PMR5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMR6, "PMR6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMR7, "PMR7",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMR8, "PMR8",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMR9, "PMR9",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMRA, "PMR10",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMRB, "PMR11",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMRC, "PMR12",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMRD, "PMR13",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMRE, "PMR14",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_PMRF, "PMR15",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   #endif
       /* XXX : not implemented */
       spr_register(env, SPR_620_BUSCSR, "BUSCSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_L2CR, "L2CR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_620_L2SR, "L2SR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   #endif /* defined (TARGET_PPC64) */
   
   static void gen_spr_5xx_8xx (CPUPPCState *env)
   {
       /* Exception processing */
       spr_register(env, SPR_DSISR, "DSISR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_DAR, "DAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Timer */
       spr_register(env, SPR_DECR, "DECR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_decr, &spr_write_decr,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_EIE, "EIE",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_EID, "EID",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_NRI, "NRI",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_CMPA, "CMPA",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_CMPB, "CMPB",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_CMPC, "CMPC",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_CMPD, "CMPD",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_ECR, "ECR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_DER, "DER",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_COUNTA, "COUNTA",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_COUNTB, "COUNTB",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_CMPE, "CMPE",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_CMPF, "CMPF",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_CMPG, "CMPG",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_CMPH, "CMPH",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_LCTRL1, "LCTRL1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_LCTRL2, "LCTRL2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_BAR, "BAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_DPDR, "DPDR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_IMMR, "IMMR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   static void gen_spr_5xx (CPUPPCState *env)
   {
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_MI_GRA, "MI_GRA",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_L2U_GRA, "L2U_GRA",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RPCU_BBCMCR, "L2U_BBCMCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_L2U_MCR, "L2U_MCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_MI_RBA0, "MI_RBA0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_MI_RBA1, "MI_RBA1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_MI_RBA2, "MI_RBA2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_MI_RBA3, "MI_RBA3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_L2U_RBA0, "L2U_RBA0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_L2U_RBA1, "L2U_RBA1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_L2U_RBA2, "L2U_RBA2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_L2U_RBA3, "L2U_RBA3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_MI_RA0, "MI_RA0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_MI_RA1, "MI_RA1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_MI_RA2, "MI_RA2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_MI_RA3, "MI_RA3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_L2U_RA0, "L2U_RA0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_L2U_RA1, "L2U_RA1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_L2U_RA2, "L2U_RA2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_L2U_RA3, "L2U_RA3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_RCPU_FPECR, "FPECR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   static void gen_spr_8xx (CPUPPCState *env)
   {
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_IC_CST, "IC_CST",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_IC_ADR, "IC_ADR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_IC_DAT, "IC_DAT",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_DC_CST, "DC_CST",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_DC_ADR, "DC_ADR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_DC_DAT, "DC_DAT",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MI_CTR, "MI_CTR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MI_AP, "MI_AP",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MI_EPN, "MI_EPN",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MI_TWC, "MI_TWC",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MI_RPN, "MI_RPN",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MI_DBCAM, "MI_DBCAM",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MI_DBRAM0, "MI_DBRAM0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MI_DBRAM1, "MI_DBRAM1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_CTR, "MD_CTR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_CASID, "MD_CASID",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_AP, "MD_AP",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_EPN, "MD_EPN",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_TWB, "MD_TWB",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_TWC, "MD_TWC",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_RPN, "MD_RPN",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_TW, "MD_TW",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_DBCAM, "MD_DBCAM",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_DBRAM0, "MD_DBRAM0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_MPC_MD_DBRAM1, "MD_DBRAM1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   // XXX: TODO
   /*
    * AMR     => SPR 29 (Power 2.04)
    * CTRL    => SPR 136 (Power 2.04)
    * CTRL    => SPR 152 (Power 2.04)
    * SCOMC   => SPR 276 (64 bits ?)
    * SCOMD   => SPR 277 (64 bits ?)
    * TBU40   => SPR 286 (Power 2.04 hypv)
    * HSPRG0  => SPR 304 (Power 2.04 hypv)
    * HSPRG1  => SPR 305 (Power 2.04 hypv)
    * HDSISR  => SPR 306 (Power 2.04 hypv)
    * HDAR    => SPR 307 (Power 2.04 hypv)
    * PURR    => SPR 309 (Power 2.04 hypv)
    * HDEC    => SPR 310 (Power 2.04 hypv)
    * HIOR    => SPR 311 (hypv)
    * RMOR    => SPR 312 (970)
    * HRMOR   => SPR 313 (Power 2.04 hypv)
    * HSRR0   => SPR 314 (Power 2.04 hypv)
    * HSRR1   => SPR 315 (Power 2.04 hypv)
    * LPCR    => SPR 316 (970)
    * LPIDR   => SPR 317 (970)
    * SPEFSCR => SPR 512 (Power 2.04 emb)
    * EPR     => SPR 702 (Power 2.04 emb)
    * perf    => 768-783 (Power 2.04)
    * perf    => 784-799 (Power 2.04)
    * PPR     => SPR 896 (Power 2.04)
    * EPLC    => SPR 947 (Power 2.04 emb)
    * EPSC    => SPR 948 (Power 2.04 emb)
    * DABRX   => 1015    (Power 2.04 hypv)
    * FPECR   => SPR 1022 (?)
    * ... and more (thermal management, performance counters, ...)
    */
   
   /*****************************************************************************/
   /* Exception vectors models                                                  */
   static void init_excp_4xx_real (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_PIT]      = 0x00001000;
       env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00001010;
       env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00001020;
       env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00002000;
       env->excp_prefix = 0x00000000UL;
       env->ivor_mask = 0x0000FFF0UL;
       env->ivpr_mask = 0xFFFF0000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_4xx_softmmu (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_PIT]      = 0x00001000;
       env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00001010;
       env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00001020;
       env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00001100;
       env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00001200;
       env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00002000;
       env->excp_prefix = 0x00000000UL;
       env->ivor_mask = 0x0000FFF0UL;
       env->ivpr_mask = 0xFFFF0000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_MPC5xx (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_FPA]      = 0x00000E00;
       env->excp_vectors[POWERPC_EXCP_EMUL]     = 0x00001000;
       env->excp_vectors[POWERPC_EXCP_DABR]     = 0x00001C00;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001C00;
       env->excp_vectors[POWERPC_EXCP_MEXTBR]   = 0x00001E00;
       env->excp_vectors[POWERPC_EXCP_NMEXTBR]  = 0x00001F00;
       env->excp_prefix = 0x00000000UL;
       env->ivor_mask = 0x0000FFF0UL;
       env->ivpr_mask = 0xFFFF0000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_MPC8xx (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_FPA]      = 0x00000E00;
       env->excp_vectors[POWERPC_EXCP_EMUL]     = 0x00001000;
       env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00001100;
       env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00001200;
       env->excp_vectors[POWERPC_EXCP_ITLBE]    = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_DTLBE]    = 0x00001400;
       env->excp_vectors[POWERPC_EXCP_DABR]     = 0x00001C00;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001C00;
       env->excp_vectors[POWERPC_EXCP_MEXTBR]   = 0x00001E00;
       env->excp_vectors[POWERPC_EXCP_NMEXTBR]  = 0x00001F00;
       env->excp_prefix = 0x00000000UL;
       env->ivor_mask = 0x0000FFF0UL;
       env->ivpr_mask = 0xFFFF0000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_G2 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000A00;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
       env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
       env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
       env->excp_prefix = 0x00000000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_e200 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000FFC;
       env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_APU]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_SPEU]     = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_EFPDI]    = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_EFPRI]    = 0x00000000;
       env->excp_prefix = 0x00000000UL;
       env->ivor_mask = 0x0000FFF7UL;
       env->ivpr_mask = 0xFFFF0000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_BookE (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_APU]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00000000;
       env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00000000;
       env->excp_prefix = 0x00000000UL;
       env->ivor_mask = 0x0000FFE0UL;
       env->ivpr_mask = 0xFFFF0000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_601 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_IO]       = 0x00000A00;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_RUNM]     = 0x00002000;
       env->excp_prefix = 0xFFF00000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0x00000100UL;
   #endif
   }
   
   static void init_excp_602 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       /* XXX: exception prefix has a special behavior on 602 */
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
       env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
       env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
       env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00001500;
       env->excp_vectors[POWERPC_EXCP_EMUL]     = 0x00001600;
       env->excp_prefix = 0xFFF00000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_603 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
       env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
       env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
       env->excp_prefix = 0x00000000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_604 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
       env->excp_prefix = 0x00000000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   #if defined(TARGET_PPC64)
   static void init_excp_620 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
       env->excp_prefix = 0xFFF00000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0x0000000000000100ULL;
   #endif
   }
   #endif /* defined(TARGET_PPC64) */
   
   static void init_excp_7x0 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
       env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
       env->excp_prefix = 0x00000000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_750cl (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
       env->excp_prefix = 0x00000000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_750cx (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
       env->excp_prefix = 0x00000000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   /* XXX: Check if this is correct */
   static void init_excp_7x5 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
       env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
       env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
       env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
       env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
       env->excp_prefix = 0x00000000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_7400 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
       env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
       env->excp_vectors[POWERPC_EXCP_VPUA]     = 0x00001600;
       env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
       env->excp_prefix = 0x00000000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   static void init_excp_7450 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
       env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
       env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
       env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
       env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
       env->excp_vectors[POWERPC_EXCP_VPUA]     = 0x00001600;
       env->excp_prefix = 0x00000000UL;
       /* Hardware reset vector */
       env->hreset_vector = 0xFFFFFFFCUL;
   #endif
   }
   
   #if defined (TARGET_PPC64)
   static void init_excp_970 (CPUPPCState *env)
   {
   #if !defined(CONFIG_USER_ONLY)
       env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
       env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
       env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
       env->excp_vectors[POWERPC_EXCP_DSEG]     = 0x00000380;
       env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
       env->excp_vectors[POWERPC_EXCP_ISEG]     = 0x00000480;
       env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
       env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
       env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
       env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
       env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
       env->excp_vectors[POWERPC_EXCP_HDECR]    = 0x00000980;
       env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
       env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
       env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
       env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
       env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
       env->excp_vectors[POWERPC_EXCP_MAINT]    = 0x00001600;
       env->excp_vectors[POWERPC_EXCP_VPUA]     = 0x00001700;
       env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001800;
       env->excp_prefix   = 0x00000000FFF00000ULL;
       /* Hardware reset vector */
       env->hreset_vector = 0x0000000000000100ULL;
   #endif
   }
   #endif
   
   /*****************************************************************************/
   /* Power management enable checks                                            */
   static int check_pow_none (CPUPPCState *env)
   {
       return 0;
   }
   
   static int check_pow_nocheck (CPUPPCState *env)
   {
       return 1;
   }
   
   static int check_pow_hid0 (CPUPPCState *env)
   {
       if (env->spr[SPR_HID0] & 0x00E00000)
           return 1;
   
       return 0;
   }
   
   static int check_pow_hid0_74xx (CPUPPCState *env)
   {
       if (env->spr[SPR_HID0] & 0x00600000)
           return 1;
   
       return 0;
   }
   
   /*****************************************************************************/
   /* PowerPC implementations definitions                                       */
   
   /* PowerPC 401                                                               */
   #define POWERPC_INSNS_401    (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_WRTEE | PPC_DCR |                           \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |     \
                                 PPC_CACHE_DCBZ |                                \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_4xx_COMMON | PPC_40x_EXCP)
   #define POWERPC_MSRM_401     (0x00000000000FD201ULL)
   #define POWERPC_MMU_401      (POWERPC_MMU_REAL)
   #define POWERPC_EXCP_401     (POWERPC_EXCP_40x)
   #define POWERPC_INPUT_401    (PPC_FLAGS_INPUT_401)
   #define POWERPC_BFDM_401     (bfd_mach_ppc_403)
   #define POWERPC_FLAG_401     (POWERPC_FLAG_CE | POWERPC_FLAG_DE |             \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_401        check_pow_nocheck
   
   static void init_proc_401 (CPUPPCState *env)
   {
       gen_spr_40x(env);
       gen_spr_401_403(env);
       gen_spr_401(env);
       init_excp_4xx_real(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc40x_irq_init(env);
   }
   
   /* PowerPC 401x2                                                             */
   #define POWERPC_INSNS_401x2  (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_DCR | PPC_WRTEE |                           \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |     \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC | \
                                 PPC_4xx_COMMON | PPC_40x_EXCP)
   #define POWERPC_MSRM_401x2   (0x00000000001FD231ULL)
   #define POWERPC_MMU_401x2    (POWERPC_MMU_SOFT_4xx_Z)
   #define POWERPC_EXCP_401x2   (POWERPC_EXCP_40x)
   #define POWERPC_INPUT_401x2  (PPC_FLAGS_INPUT_401)
   #define POWERPC_BFDM_401x2   (bfd_mach_ppc_403)
   #define POWERPC_FLAG_401x2   (POWERPC_FLAG_CE | POWERPC_FLAG_DE |             \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_401x2      check_pow_nocheck
   
   static void init_proc_401x2 (CPUPPCState *env)
   {
       gen_spr_40x(env);
       gen_spr_401_403(env);
       gen_spr_401x2(env);
       gen_spr_compress(env);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_4xx_softmmu(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc40x_irq_init(env);
   }
   
   /* PowerPC 401x3                                                             */
   #define POWERPC_INSNS_401x3  (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_DCR | PPC_WRTEE |                           \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |     \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC | \
                                 PPC_4xx_COMMON | PPC_40x_EXCP)
   #define POWERPC_MSRM_401x3   (0x00000000001FD631ULL)
   #define POWERPC_MMU_401x3    (POWERPC_MMU_SOFT_4xx_Z)
   #define POWERPC_EXCP_401x3   (POWERPC_EXCP_40x)
   #define POWERPC_INPUT_401x3  (PPC_FLAGS_INPUT_401)
   #define POWERPC_BFDM_401x3   (bfd_mach_ppc_403)
   #define POWERPC_FLAG_401x3   (POWERPC_FLAG_CE | POWERPC_FLAG_DE |             \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_401x3      check_pow_nocheck
   
   __attribute__ (( unused ))
   static void init_proc_401x3 (CPUPPCState *env)
   {
       gen_spr_40x(env);
       gen_spr_401_403(env);
       gen_spr_401(env);
       gen_spr_401x2(env);
       gen_spr_compress(env);
       init_excp_4xx_softmmu(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc40x_irq_init(env);
   }
   
   /* IOP480                                                                    */
   #define POWERPC_INSNS_IOP480 (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_DCR | PPC_WRTEE |                           \
                                 PPC_CACHE | PPC_CACHE_ICBI |  PPC_40x_ICBT |    \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC | \
                                 PPC_4xx_COMMON | PPC_40x_EXCP)
   #define POWERPC_MSRM_IOP480  (0x00000000001FD231ULL)
   #define POWERPC_MMU_IOP480   (POWERPC_MMU_SOFT_4xx_Z)
   #define POWERPC_EXCP_IOP480  (POWERPC_EXCP_40x)
   #define POWERPC_INPUT_IOP480 (PPC_FLAGS_INPUT_401)
   #define POWERPC_BFDM_IOP480  (bfd_mach_ppc_403)
   #define POWERPC_FLAG_IOP480  (POWERPC_FLAG_CE | POWERPC_FLAG_DE |             \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_IOP480     check_pow_nocheck
   
   static void init_proc_IOP480 (CPUPPCState *env)
   {
       gen_spr_40x(env);
       gen_spr_401_403(env);
       gen_spr_401x2(env);
       gen_spr_compress(env);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_4xx_softmmu(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc40x_irq_init(env);
   }
   
   /* PowerPC 403                                                               */
   #define POWERPC_INSNS_403    (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_DCR | PPC_WRTEE |                           \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |     \
                                 PPC_CACHE_DCBZ |                                \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_4xx_COMMON | PPC_40x_EXCP)
   #define POWERPC_MSRM_403     (0x000000000007D00DULL)
   #define POWERPC_MMU_403      (POWERPC_MMU_REAL)
   #define POWERPC_EXCP_403     (POWERPC_EXCP_40x)
   #define POWERPC_INPUT_403    (PPC_FLAGS_INPUT_401)
   #define POWERPC_BFDM_403     (bfd_mach_ppc_403)
   #define POWERPC_FLAG_403     (POWERPC_FLAG_CE | POWERPC_FLAG_PX |             \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_403        check_pow_nocheck
   
   static void init_proc_403 (CPUPPCState *env)
   {
       gen_spr_40x(env);
       gen_spr_401_403(env);
       gen_spr_403(env);
       gen_spr_403_real(env);
       init_excp_4xx_real(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc40x_irq_init(env);
   }
   
   /* PowerPC 403 GCX                                                           */
   #define POWERPC_INSNS_403GCX (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_DCR | PPC_WRTEE |                           \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |     \
                                 PPC_CACHE_DCBZ |                                \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC | \
                                 PPC_4xx_COMMON | PPC_40x_EXCP)
   #define POWERPC_MSRM_403GCX  (0x000000000007D00DULL)
   #define POWERPC_MMU_403GCX   (POWERPC_MMU_SOFT_4xx_Z)
   #define POWERPC_EXCP_403GCX  (POWERPC_EXCP_40x)
   #define POWERPC_INPUT_403GCX (PPC_FLAGS_INPUT_401)
   #define POWERPC_BFDM_403GCX  (bfd_mach_ppc_403)
   #define POWERPC_FLAG_403GCX  (POWERPC_FLAG_CE | POWERPC_FLAG_PX |             \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_403GCX     check_pow_nocheck
   
   static void init_proc_403GCX (CPUPPCState *env)
   {
       gen_spr_40x(env);
       gen_spr_401_403(env);
       gen_spr_403(env);
       gen_spr_403_real(env);
       gen_spr_403_mmu(env);
       /* Bus access control */
       /* not emulated, as Qemu never does speculative access */
       spr_register(env, SPR_40x_SGR, "SGR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0xFFFFFFFF);
       /* not emulated, as Qemu do not emulate caches */
       spr_register(env, SPR_40x_DCWR, "DCWR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_4xx_softmmu(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc40x_irq_init(env);
   }
   
   /* PowerPC 405                                                               */
   #define POWERPC_INSNS_405    (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_DCR | PPC_WRTEE |                           \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |     \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC | \
                                 PPC_4xx_COMMON | PPC_405_MAC | PPC_40x_EXCP)
   #define POWERPC_MSRM_405     (0x000000000006E630ULL)
   #define POWERPC_MMU_405      (POWERPC_MMU_SOFT_4xx)
   #define POWERPC_EXCP_405     (POWERPC_EXCP_40x)
   #define POWERPC_INPUT_405    (PPC_FLAGS_INPUT_405)
   #define POWERPC_BFDM_405     (bfd_mach_ppc_403)
   #define POWERPC_FLAG_405     (POWERPC_FLAG_CE | POWERPC_FLAG_DWE |            \
                                 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_405        check_pow_nocheck
   
   static void init_proc_405 (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_40x(env);
       gen_spr_405(env);
       /* Bus access control */
       /* not emulated, as Qemu never does speculative access */
       spr_register(env, SPR_40x_SGR, "SGR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0xFFFFFFFF);
       /* not emulated, as Qemu do not emulate caches */
       spr_register(env, SPR_40x_DCWR, "DCWR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_4xx_softmmu(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc40x_irq_init(env);
   }
   
   /* PowerPC 440 EP                                                            */
   #define POWERPC_INSNS_440EP  (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_DCR | PPC_WRTEE | PPC_RFMCI |               \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_TLBSYNC |                               \
                                 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |      \
                                 PPC_440_SPEC)
   #define POWERPC_MSRM_440EP   (0x000000000006D630ULL)
   #define POWERPC_MMU_440EP    (POWERPC_MMU_BOOKE)
   #define POWERPC_EXCP_440EP   (POWERPC_EXCP_BOOKE)
   #define POWERPC_INPUT_440EP  (PPC_FLAGS_INPUT_BookE)
   #define POWERPC_BFDM_440EP   (bfd_mach_ppc_403)
   #define POWERPC_FLAG_440EP   (POWERPC_FLAG_CE | POWERPC_FLAG_DWE |            \
                                 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_440EP      check_pow_nocheck
   
   __attribute__ (( unused ))
   static void init_proc_440EP (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_BookE(env, 0x000000000000FFFFULL);
       gen_spr_440(env);
       gen_spr_usprgh(env);
       /* Processor identification */
       spr_register(env, SPR_BOOKE_PIR, "PIR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_pir,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC3, "IAC3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC4, "IAC4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC1, "DVC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC2, "DVC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_MCSR, "MCSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_CCR1, "CCR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_BookE(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* XXX: TODO: allocate internal IRQ controller */
   }
   
   /* PowerPC 440 GP                                                            */
   #define POWERPC_INSNS_440GP  (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_DCR | PPC_DCRX | PPC_WRTEE | PPC_MFAPIDI |  \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_TLBSYNC | PPC_TLBIVA |                  \
                                 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |      \
                                 PPC_440_SPEC)
   #define POWERPC_MSRM_440GP   (0x000000000006FF30ULL)
   #define POWERPC_MMU_440GP    (POWERPC_MMU_BOOKE)
   #define POWERPC_EXCP_440GP   (POWERPC_EXCP_BOOKE)
   #define POWERPC_INPUT_440GP  (PPC_FLAGS_INPUT_BookE)
   #define POWERPC_BFDM_440GP   (bfd_mach_ppc_403)
   #define POWERPC_FLAG_440GP   (POWERPC_FLAG_CE | POWERPC_FLAG_DWE |            \
                                 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_440GP      check_pow_nocheck
   
   __attribute__ (( unused ))
   static void init_proc_440GP (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_BookE(env, 0x000000000000FFFFULL);
       gen_spr_440(env);
       gen_spr_usprgh(env);
       /* Processor identification */
       spr_register(env, SPR_BOOKE_PIR, "PIR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_pir,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC3, "IAC3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC4, "IAC4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC1, "DVC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC2, "DVC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_BookE(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* XXX: TODO: allocate internal IRQ controller */
   }
   
   /* PowerPC 440x4                                                             */
   #define POWERPC_INSNS_440x4  (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_DCR | PPC_WRTEE |                           \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_TLBSYNC |                               \
                                 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |      \
                                 PPC_440_SPEC)
   #define POWERPC_MSRM_440x4   (0x000000000006FF30ULL)
   #define POWERPC_MMU_440x4    (POWERPC_MMU_BOOKE)
   #define POWERPC_EXCP_440x4   (POWERPC_EXCP_BOOKE)
   #define POWERPC_INPUT_440x4  (PPC_FLAGS_INPUT_BookE)
   #define POWERPC_BFDM_440x4   (bfd_mach_ppc_403)
   #define POWERPC_FLAG_440x4   (POWERPC_FLAG_CE | POWERPC_FLAG_DWE |            \
                                 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_440x4      check_pow_nocheck
   
   __attribute__ (( unused ))
   static void init_proc_440x4 (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_BookE(env, 0x000000000000FFFFULL);
       gen_spr_440(env);
       gen_spr_usprgh(env);
       /* Processor identification */
       spr_register(env, SPR_BOOKE_PIR, "PIR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_pir,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC3, "IAC3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC4, "IAC4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC1, "DVC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC2, "DVC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_BookE(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* XXX: TODO: allocate internal IRQ controller */
   }
   
   /* PowerPC 440x5                                                             */
   #define POWERPC_INSNS_440x5  (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_DCR | PPC_WRTEE | PPC_RFMCI |               \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_TLBSYNC |                               \
                                 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |      \
                                 PPC_440_SPEC)
   #define POWERPC_MSRM_440x5   (0x000000000006FF30ULL)
   #define POWERPC_MMU_440x5    (POWERPC_MMU_BOOKE)
   #define POWERPC_EXCP_440x5   (POWERPC_EXCP_BOOKE)
   #define POWERPC_INPUT_440x5  (PPC_FLAGS_INPUT_BookE)
   #define POWERPC_BFDM_440x5   (bfd_mach_ppc_403)
   #define POWERPC_FLAG_440x5   (POWERPC_FLAG_CE | POWERPC_FLAG_DWE |           \
                                 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_440x5      check_pow_nocheck
   
   __attribute__ (( unused ))
   static void init_proc_440x5 (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_BookE(env, 0x000000000000FFFFULL);
       gen_spr_440(env);
       gen_spr_usprgh(env);
       /* Processor identification */
       spr_register(env, SPR_BOOKE_PIR, "PIR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_pir,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC3, "IAC3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC4, "IAC4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC1, "DVC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC2, "DVC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_MCSR, "MCSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_CCR1, "CCR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_BookE(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* XXX: TODO: allocate internal IRQ controller */
   }
   
   /* PowerPC 460 (guessed)                                                     */
   #define POWERPC_INSNS_460    (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_DCR | PPC_DCRX  | PPC_DCRUX |               \
                                 PPC_WRTEE | PPC_MFAPIDI |                       \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_TLBSYNC | PPC_TLBIVA |                  \
                                 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |      \
                                 PPC_440_SPEC)
   #define POWERPC_MSRM_460     (0x000000000006FF30ULL)
   #define POWERPC_MMU_460      (POWERPC_MMU_BOOKE)
   #define POWERPC_EXCP_460     (POWERPC_EXCP_BOOKE)
   #define POWERPC_INPUT_460    (PPC_FLAGS_INPUT_BookE)
   #define POWERPC_BFDM_460     (bfd_mach_ppc_403)
   #define POWERPC_FLAG_460     (POWERPC_FLAG_CE | POWERPC_FLAG_DWE |            \
                                 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_460        check_pow_nocheck
   
   __attribute__ (( unused ))
   static void init_proc_460 (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_BookE(env, 0x000000000000FFFFULL);
       gen_spr_440(env);
       gen_spr_usprgh(env);
       /* Processor identification */
       spr_register(env, SPR_BOOKE_PIR, "PIR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_pir,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC3, "IAC3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC4, "IAC4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC1, "DVC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC2, "DVC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_MCSR, "MCSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_CCR1, "CCR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_DCRIPR, "SPR_DCRIPR",
                    &spr_read_generic, &spr_write_generic,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_BookE(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* XXX: TODO: allocate internal IRQ controller */
   }
   
   /* PowerPC 460F (guessed)                                                    */
   #define POWERPC_INSNS_460F   (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_FLOAT | PPC_FLOAT_FRES | PPC_FLOAT_FSEL |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_DCR | PPC_DCRX | PPC_DCRUX |                \
                                 PPC_WRTEE | PPC_MFAPIDI |                       \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_TLBSYNC | PPC_TLBIVA |                  \
                                 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |      \
                                 PPC_440_SPEC)
   #define POWERPC_MSRM_460     (0x000000000006FF30ULL)
   #define POWERPC_MMU_460F     (POWERPC_MMU_BOOKE)
   #define POWERPC_EXCP_460F    (POWERPC_EXCP_BOOKE)
   #define POWERPC_INPUT_460F   (PPC_FLAGS_INPUT_BookE)
   #define POWERPC_BFDM_460F    (bfd_mach_ppc_403)
   #define POWERPC_FLAG_460F    (POWERPC_FLAG_CE | POWERPC_FLAG_DWE |            \
                                 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_460F       check_pow_nocheck
   
   __attribute__ (( unused ))
   static void init_proc_460F (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_BookE(env, 0x000000000000FFFFULL);
       gen_spr_440(env);
       gen_spr_usprgh(env);
       /* Processor identification */
       spr_register(env, SPR_BOOKE_PIR, "PIR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_pir,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC3, "IAC3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC4, "IAC4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC1, "DVC1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_DVC2, "DVC2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_MCSR, "MCSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_440_CCR1, "CCR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_DCRIPR, "SPR_DCRIPR",
                    &spr_read_generic, &spr_write_generic,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_BookE(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* XXX: TODO: allocate internal IRQ controller */
   }
   
   /* Freescale 5xx cores (aka RCPU) */
   #define POWERPC_INSNS_MPC5xx (PPC_INSNS_BASE | PPC_STRING |                   \
                                 PPC_MEM_EIEIO | PPC_MEM_SYNC |                  \
                                 PPC_CACHE_ICBI | PPC_FLOAT | PPC_FLOAT_STFIWX | \
                                 PPC_MFTB)
   #define POWERPC_MSRM_MPC5xx  (0x000000000001FF43ULL)
   #define POWERPC_MMU_MPC5xx   (POWERPC_MMU_REAL)
   #define POWERPC_EXCP_MPC5xx  (POWERPC_EXCP_603)
   #define POWERPC_INPUT_MPC5xx (PPC_FLAGS_INPUT_RCPU)
   #define POWERPC_BFDM_MPC5xx  (bfd_mach_ppc_505)
   #define POWERPC_FLAG_MPC5xx  (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_MPC5xx     check_pow_none
   
   __attribute__ (( unused ))
   static void init_proc_MPC5xx (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_5xx_8xx(env);
       gen_spr_5xx(env);
       init_excp_MPC5xx(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* XXX: TODO: allocate internal IRQ controller */
   }
   
   /* Freescale 8xx cores (aka PowerQUICC) */
   #define POWERPC_INSNS_MPC8xx (PPC_INSNS_BASE | PPC_STRING  |                  \
                                 PPC_MEM_EIEIO | PPC_MEM_SYNC |                  \
                                 PPC_CACHE_ICBI | PPC_MFTB)
   #define POWERPC_MSRM_MPC8xx  (0x000000000001F673ULL)
   #define POWERPC_MMU_MPC8xx   (POWERPC_MMU_MPC8xx)
   #define POWERPC_EXCP_MPC8xx  (POWERPC_EXCP_603)
   #define POWERPC_INPUT_MPC8xx (PPC_FLAGS_INPUT_RCPU)
   #define POWERPC_BFDM_MPC8xx  (bfd_mach_ppc_860)
   #define POWERPC_FLAG_MPC8xx  (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_MPC8xx     check_pow_none
   
   __attribute__ (( unused ))
   static void init_proc_MPC8xx (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_5xx_8xx(env);
       gen_spr_8xx(env);
       init_excp_MPC8xx(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* XXX: TODO: allocate internal IRQ controller */
   }
   
   /* Freescale 82xx cores (aka PowerQUICC-II)                                  */
   /* PowerPC G2                                                                */
   #define POWERPC_INSNS_G2     (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_G2      (0x000000000006FFF2ULL)
   #define POWERPC_MMU_G2       (POWERPC_MMU_SOFT_6xx)
   //#define POWERPC_EXCP_G2      (POWERPC_EXCP_G2)
   #define POWERPC_INPUT_G2     (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_G2      (bfd_mach_ppc_ec603e)
   #define POWERPC_FLAG_G2      (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |           \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_G2         check_pow_hid0
   
   static void init_proc_G2 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_G2_755(env);
       gen_spr_G2(env);
       /* Time base */
       gen_tbl(env);
       /* External access control */
       /* XXX : not implemented */
       spr_register(env, SPR_EAR, "EAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Hardware implementation register */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID2, "HID2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_high_BATs(env);
       gen_6xx_7xx_soft_tlb(env, 64, 2);
       init_excp_G2(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC G2LE                                                              */
   #define POWERPC_INSNS_G2LE   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_G2LE    (0x000000000007FFF3ULL)
   #define POWERPC_MMU_G2LE     (POWERPC_MMU_SOFT_6xx)
   #define POWERPC_EXCP_G2LE    (POWERPC_EXCP_G2)
   #define POWERPC_INPUT_G2LE   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_G2LE    (bfd_mach_ppc_ec603e)
   #define POWERPC_FLAG_G2LE    (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |           \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_G2LE       check_pow_hid0
   
   static void init_proc_G2LE (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_G2_755(env);
       gen_spr_G2(env);
       /* Time base */
       gen_tbl(env);
       /* External access control */
       /* XXX : not implemented */
       spr_register(env, SPR_EAR, "EAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Hardware implementation register */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID2, "HID2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_high_BATs(env);
       gen_6xx_7xx_soft_tlb(env, 64, 2);
       init_excp_G2(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* e200 core                                                                 */
   /* XXX: unimplemented instructions:
    * dcblc
    * dcbtlst
    * dcbtstls
    * icblc
    * icbtls
    * tlbivax
    * all SPE multiply-accumulate instructions
    */
   #define POWERPC_INSNS_e200   (PPC_INSNS_BASE | PPC_ISEL |                     \
                                 PPC_SPE | PPC_SPEFPU |                          \
                                 PPC_WRTEE | PPC_RFDI |                          \
                                 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |   \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_TLBSYNC | PPC_TLBIVAX |                 \
                                 PPC_BOOKE)
   #define POWERPC_MSRM_e200    (0x000000000606FF30ULL)
   #define POWERPC_MMU_e200     (POWERPC_MMU_BOOKE_FSL)
   #define POWERPC_EXCP_e200    (POWERPC_EXCP_BOOKE)
   #define POWERPC_INPUT_e200   (PPC_FLAGS_INPUT_BookE)
   #define POWERPC_BFDM_e200    (bfd_mach_ppc_860)
   #define POWERPC_FLAG_e200    (POWERPC_FLAG_SPE | POWERPC_FLAG_CE |            \
                                 POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |           \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_e200       check_pow_hid0
   
   __attribute__ (( unused ))
   static void init_proc_e200 (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_BookE(env, 0x000000070000FFFFULL);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_SPEFSCR, "SPEFSCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_spr_BookE_FSL(env, 0x0000005D);
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_ALTCTXCR, "ALTCTXCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_BUCSR, "BUCSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_CTXCR, "CTXCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_DBCNT, "DBCNT",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_DBCR3, "DBCR3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_L1CFG0, "L1CFG0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_L1CSR0, "L1CSR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_L1FINV0, "L1FINV0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_TLB0CFG, "TLB0CFG",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_TLB1CFG, "TLB1CFG",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC3, "IAC3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_IAC4, "IAC4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_DSRR0, "DSRR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_DSRR1, "DSRR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_e200(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* XXX: TODO: allocate internal IRQ controller */
   }
   
   /* e300 core                                                                 */
   #define POWERPC_INSNS_e300   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_e300    (0x000000000007FFF3ULL)
   #define POWERPC_MMU_e300     (POWERPC_MMU_SOFT_6xx)
   #define POWERPC_EXCP_e300    (POWERPC_EXCP_603)
   #define POWERPC_INPUT_e300   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_e300    (bfd_mach_ppc_603)
   #define POWERPC_FLAG_e300    (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |           \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_e300       check_pow_hid0
   
   __attribute__ (( unused ))
   static void init_proc_e300 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_603(env);
       /* Time base */
       gen_tbl(env);
       /* hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_6xx_7xx_soft_tlb(env, 64, 2);
       init_excp_603(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* e500 core                                                                 */
   #define POWERPC_INSNS_e500   (PPC_INSNS_BASE | PPC_ISEL |                     \
                                 PPC_SPE | PPC_SPEFPU |                          \
                                 PPC_WRTEE | PPC_RFDI |                          \
                                 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |   \
                                 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
                                 PPC_MEM_TLBSYNC | PPC_TLBIVAX |                 \
                                 PPC_BOOKE)
   #define POWERPC_MSRM_e500    (0x000000000606FF30ULL)
   #define POWERPC_MMU_e500     (POWERPC_MMU_BOOKE_FSL)
   #define POWERPC_EXCP_e500    (POWERPC_EXCP_BOOKE)
   #define POWERPC_INPUT_e500   (PPC_FLAGS_INPUT_BookE)
   #define POWERPC_BFDM_e500    (bfd_mach_ppc_860)
   #define POWERPC_FLAG_e500    (POWERPC_FLAG_SPE | POWERPC_FLAG_CE |            \
                                 POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |           \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_e500       check_pow_hid0
   
   __attribute__ (( unused ))
   static void init_proc_e500 (CPUPPCState *env)
   {
       /* Time base */
       gen_tbl(env);
       gen_spr_BookE(env, 0x0000000F0000FD7FULL);
       /* Processor identification */
       spr_register(env, SPR_BOOKE_PIR, "PIR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_pir,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_SPEFSCR, "SPEFSCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
   #if !defined(CONFIG_USER_ONLY)
       env->nb_pids = 3;
   #endif
       gen_spr_BookE_FSL(env, 0x0000005F);
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_BBEAR, "BBEAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_BBTAR, "BBTAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_MCAR, "MCAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_MCSR, "MCSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_NPIDR, "NPIDR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_BUCSR, "BUCSR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_L1CFG0, "L1CFG0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_L1CSR0, "L1CSR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_Exxx_L1CSR1, "L1CSR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_TLB0CFG, "TLB0CFG",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_BOOKE_TLB1CFG, "TLB1CFG",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   #if !defined(CONFIG_USER_ONLY)
       env->nb_tlb = 64;
       env->nb_ways = 1;
       env->id_tlbs = 0;
   #endif
       init_excp_e200(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* XXX: TODO: allocate internal IRQ controller */
   }
   
   /* Non-embedded PowerPC                                                      */
   
   /* POWER : same as 601, without mfmsr, mfsr                                  */
   #if defined(TODO)
   #define POWERPC_INSNS_POWER  (XXX_TODO)
   /* POWER RSC (from RAD6000) */
   #define POWERPC_MSRM_POWER   (0x00000000FEF0ULL)
   #endif /* TODO */
   
   /* PowerPC 601                                                               */
   #define POWERPC_INSNS_601    (PPC_INSNS_BASE | PPC_STRING | PPC_POWER_BR |    \
                                 PPC_FLOAT |                                     \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO | PPC_MEM_TLBIE |  \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_601     (0x000000000000FD70ULL)
   #define POWERPC_MSRR_601     (0x0000000000001040ULL)
   //#define POWERPC_MMU_601      (POWERPC_MMU_601)
   //#define POWERPC_EXCP_601     (POWERPC_EXCP_601)
   #define POWERPC_INPUT_601    (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_601     (bfd_mach_ppc_601)
   #define POWERPC_FLAG_601     (POWERPC_FLAG_SE | POWERPC_FLAG_RTC_CLK)
   #define check_pow_601        check_pow_none
   
   static void init_proc_601 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_601(env);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_hid0_601,
                    0x80010080);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_601_HID2, "HID2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_601_HID5, "HID5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       init_excp_601(env);
       /* XXX: beware that dcache line size is 64 
        *      but dcbz uses 32 bytes "sectors"
        * XXX: this breaks clcs instruction !
        */
       env->dcache_line_size = 32;
       env->icache_line_size = 64;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 601v                                                              */
   #define POWERPC_INSNS_601v   (PPC_INSNS_BASE | PPC_STRING | PPC_POWER_BR |    \
                                 PPC_FLOAT |                                     \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO | PPC_MEM_TLBIE |  \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_601v    (0x000000000000FD70ULL)
   #define POWERPC_MSRR_601v    (0x0000000000001040ULL)
   #define POWERPC_MMU_601v     (POWERPC_MMU_601)
   #define POWERPC_EXCP_601v    (POWERPC_EXCP_601)
   #define POWERPC_INPUT_601v   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_601v    (bfd_mach_ppc_601)
   #define POWERPC_FLAG_601v    (POWERPC_FLAG_SE | POWERPC_FLAG_RTC_CLK)
   #define check_pow_601v       check_pow_none
   
   static void init_proc_601v (CPUPPCState *env)
   {
       init_proc_601(env);
       /* XXX : not implemented */
       spr_register(env, SPR_601_HID15, "HID15",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
   }
   
   /* PowerPC 602                                                               */
   #define POWERPC_INSNS_602    (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_6xx_TLB | PPC_MEM_TLBSYNC | \
                                 PPC_SEGMENT | PPC_602_SPEC)
   #define POWERPC_MSRM_602     (0x0000000000C7FF73ULL)
   /* XXX: 602 MMU is quite specific. Should add a special case */
   #define POWERPC_MMU_602      (POWERPC_MMU_SOFT_6xx)
   //#define POWERPC_EXCP_602     (POWERPC_EXCP_602)
   #define POWERPC_INPUT_602    (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_602     (bfd_mach_ppc_602)
   #define POWERPC_FLAG_602     (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |           \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_602        check_pow_hid0
   
   static void init_proc_602 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_602(env);
       /* Time base */
       gen_tbl(env);
       /* hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_6xx_7xx_soft_tlb(env, 64, 2);
       init_excp_602(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 603                                                               */
   #define POWERPC_INSNS_603    (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_603     (0x000000000007FF73ULL)
   #define POWERPC_MMU_603      (POWERPC_MMU_SOFT_6xx)
   //#define POWERPC_EXCP_603     (POWERPC_EXCP_603)
   #define POWERPC_INPUT_603    (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_603     (bfd_mach_ppc_603)
   #define POWERPC_FLAG_603     (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |           \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_603        check_pow_hid0
   
   static void init_proc_603 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_603(env);
       /* Time base */
       gen_tbl(env);
       /* hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_6xx_7xx_soft_tlb(env, 64, 2);
       init_excp_603(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 603e                                                              */
   #define POWERPC_INSNS_603E   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_603E    (0x000000000007FF73ULL)
   #define POWERPC_MMU_603E     (POWERPC_MMU_SOFT_6xx)
   //#define POWERPC_EXCP_603E    (POWERPC_EXCP_603E)
   #define POWERPC_INPUT_603E   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_603E    (bfd_mach_ppc_ec603e)
   #define POWERPC_FLAG_603E    (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |           \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
   #define check_pow_603E       check_pow_hid0
   
   static void init_proc_603E (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_603(env);
       /* Time base */
       gen_tbl(env);
       /* hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_IABR, "IABR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_6xx_7xx_soft_tlb(env, 64, 2);
       init_excp_603(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 604                                                               */
   #define POWERPC_INSNS_604    (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_604     (0x000000000005FF77ULL)
   #define POWERPC_MMU_604      (POWERPC_MMU_32B)
   //#define POWERPC_EXCP_604     (POWERPC_EXCP_604)
   #define POWERPC_INPUT_604    (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_604     (bfd_mach_ppc_604)
   #define POWERPC_FLAG_604     (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_604        check_pow_nocheck
   
   static void init_proc_604 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_604(env);
       /* Time base */
       gen_tbl(env);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       init_excp_604(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 604E                                                              */
   #define POWERPC_INSNS_604E   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_604E    (0x000000000005FF77ULL)
   #define POWERPC_MMU_604E     (POWERPC_MMU_32B)
   #define POWERPC_EXCP_604E    (POWERPC_EXCP_604)
   #define POWERPC_INPUT_604E   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_604E    (bfd_mach_ppc_604)
   #define POWERPC_FLAG_604E    (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_604E       check_pow_nocheck
   
   static void init_proc_604E (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_604(env);
       /* XXX : not implemented */
       spr_register(env, SPR_MMCR1, "MMCR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_PMC3, "PMC3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_PMC4, "PMC4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Time base */
       gen_tbl(env);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       init_excp_604(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 740                                                               */
   #define POWERPC_INSNS_740    (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_740     (0x000000000005FF77ULL)
   #define POWERPC_MMU_740      (POWERPC_MMU_32B)
   #define POWERPC_EXCP_740     (POWERPC_EXCP_7x0)
   #define POWERPC_INPUT_740    (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_740     (bfd_mach_ppc_750)
   #define POWERPC_FLAG_740     (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_740        check_pow_hid0
   
   static void init_proc_740 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* Time base */
       gen_tbl(env);
       /* Thermal management */
       gen_spr_thrm(env);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       init_excp_7x0(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 750                                                               */
   #define POWERPC_INSNS_750    (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_750     (0x000000000005FF77ULL)
   #define POWERPC_MMU_750      (POWERPC_MMU_32B)
   #define POWERPC_EXCP_750     (POWERPC_EXCP_7x0)
   #define POWERPC_INPUT_750    (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_750     (bfd_mach_ppc_750)
   #define POWERPC_FLAG_750     (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_750        check_pow_hid0
   
   static void init_proc_750 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* XXX : not implemented */
       spr_register(env, SPR_L2CR, "L2CR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Time base */
       gen_tbl(env);
       /* Thermal management */
       gen_spr_thrm(env);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       /* XXX: high BATs are also present but are known to be bugged on
        *      die version 1.x
        */
       init_excp_7x0(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 750 CL                                                            */
   /* XXX: not implemented:
    * cache lock instructions:
    * dcbz_l
    * floating point paired instructions
    * psq_lux
    * psq_lx
    * psq_stux
    * psq_stx
    * ps_abs
    * ps_add
    * ps_cmpo0
    * ps_cmpo1
    * ps_cmpu0
    * ps_cmpu1
    * ps_div
    * ps_madd
    * ps_madds0
    * ps_madds1
    * ps_merge00
    * ps_merge01
    * ps_merge10
    * ps_merge11
    * ps_mr
    * ps_msub
    * ps_mul
    * ps_muls0
    * ps_muls1
    * ps_nabs
    * ps_neg
    * ps_nmadd
    * ps_nmsub
    * ps_res
    * ps_rsqrte
    * ps_sel
    * ps_sub
    * ps_sum0
    * ps_sum1
    */
   #define POWERPC_INSNS_750cl  (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_750cl   (0x000000000005FF77ULL)
   #define POWERPC_MMU_750cl    (POWERPC_MMU_32B)
   #define POWERPC_EXCP_750cl   (POWERPC_EXCP_7x0)
   #define POWERPC_INPUT_750cl  (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_750cl   (bfd_mach_ppc_750)
   #define POWERPC_FLAG_750cl   (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_750cl      check_pow_hid0
   
   static void init_proc_750cl (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* XXX : not implemented */
       spr_register(env, SPR_L2CR, "L2CR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Time base */
       gen_tbl(env);
       /* Thermal management */
       /* Those registers are fake on 750CL */
       spr_register(env, SPR_THRM1, "THRM1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_THRM2, "THRM2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_THRM3, "THRM3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX: not implemented */
       spr_register(env, SPR_750_TDCL, "TDCL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_750_TDCH, "TDCH",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* DMA */
       /* XXX : not implemented */
       spr_register(env, SPR_750_WPAR, "WPAR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_750_DMAL, "DMAL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_750_DMAU, "DMAU",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750CL_HID2, "HID2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750CL_HID4, "HID4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Quantization registers */
       /* XXX : not implemented */
       spr_register(env, SPR_750_GQR0, "GQR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750_GQR1, "GQR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750_GQR2, "GQR2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750_GQR3, "GQR3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750_GQR4, "GQR4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750_GQR5, "GQR5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750_GQR6, "GQR6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750_GQR7, "GQR7",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       /* PowerPC 750cl has 8 DBATs and 8 IBATs */
       gen_high_BATs(env);
       init_excp_750cl(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 750CX                                                             */
   #define POWERPC_INSNS_750cx  (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_750cx   (0x000000000005FF77ULL)
   #define POWERPC_MMU_750cx    (POWERPC_MMU_32B)
   #define POWERPC_EXCP_750cx   (POWERPC_EXCP_7x0)
   #define POWERPC_INPUT_750cx  (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_750cx   (bfd_mach_ppc_750)
   #define POWERPC_FLAG_750cx   (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_750cx      check_pow_hid0
   
   static void init_proc_750cx (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* XXX : not implemented */
       spr_register(env, SPR_L2CR, "L2CR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Time base */
       gen_tbl(env);
       /* Thermal management */
       gen_spr_thrm(env);
       /* This register is not implemented but is present for compatibility */
       spr_register(env, SPR_SDA, "SDA",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       /* PowerPC 750cx has 8 DBATs and 8 IBATs */
       gen_high_BATs(env);
       init_excp_750cx(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 750FX                                                             */
   #define POWERPC_INSNS_750fx  (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_SEGMENT  | PPC_EXTERN)
   #define POWERPC_MSRM_750fx   (0x000000000005FF77ULL)
   #define POWERPC_MMU_750fx    (POWERPC_MMU_32B)
   #define POWERPC_EXCP_750fx   (POWERPC_EXCP_7x0)
   #define POWERPC_INPUT_750fx  (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_750fx   (bfd_mach_ppc_750)
   #define POWERPC_FLAG_750fx   (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_750fx      check_pow_hid0
   
   static void init_proc_750fx (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* XXX : not implemented */
       spr_register(env, SPR_L2CR, "L2CR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Time base */
       gen_tbl(env);
       /* Thermal management */
       gen_spr_thrm(env);
       /* XXX : not implemented */
       spr_register(env, SPR_750_THRM4, "THRM4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750FX_HID2, "HID2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */
       gen_high_BATs(env);
       init_excp_7x0(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 750GX                                                             */
   #define POWERPC_INSNS_750gx  (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_SEGMENT  | PPC_EXTERN)
   #define POWERPC_MSRM_750gx   (0x000000000005FF77ULL)
   #define POWERPC_MMU_750gx    (POWERPC_MMU_32B)
   #define POWERPC_EXCP_750gx   (POWERPC_EXCP_7x0)
   #define POWERPC_INPUT_750gx  (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_750gx   (bfd_mach_ppc_750)
   #define POWERPC_FLAG_750gx   (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_750gx      check_pow_hid0
   
   static void init_proc_750gx (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* XXX : not implemented (XXX: different from 750fx) */
       spr_register(env, SPR_L2CR, "L2CR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Time base */
       gen_tbl(env);
       /* Thermal management */
       gen_spr_thrm(env);
       /* XXX : not implemented */
       spr_register(env, SPR_750_THRM4, "THRM4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Hardware implementation registers */
       /* XXX : not implemented (XXX: different from 750fx) */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented (XXX: different from 750fx) */
       spr_register(env, SPR_750FX_HID2, "HID2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */
       gen_high_BATs(env);
       init_excp_7x0(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 745                                                               */
   #define POWERPC_INSNS_745    (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_745     (0x000000000005FF77ULL)
   #define POWERPC_MMU_745      (POWERPC_MMU_SOFT_6xx)
   #define POWERPC_EXCP_745     (POWERPC_EXCP_7x5)
   #define POWERPC_INPUT_745    (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_745     (bfd_mach_ppc_750)
   #define POWERPC_FLAG_745     (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_745        check_pow_hid0
   
   static void init_proc_745 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       gen_spr_G2_755(env);
       /* Time base */
       gen_tbl(env);
       /* Thermal management */
       gen_spr_thrm(env);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID2, "HID2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_high_BATs(env);
       gen_6xx_7xx_soft_tlb(env, 64, 2);
       init_excp_7x5(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 755                                                               */
   #define POWERPC_INSNS_755    (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |          \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |   \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
                                 PPC_SEGMENT | PPC_EXTERN)
   #define POWERPC_MSRM_755     (0x000000000005FF77ULL)
   #define POWERPC_MMU_755      (POWERPC_MMU_SOFT_6xx)
   #define POWERPC_EXCP_755     (POWERPC_EXCP_7x5)
   #define POWERPC_INPUT_755    (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_755     (bfd_mach_ppc_750)
   #define POWERPC_FLAG_755     (POWERPC_FLAG_SE | POWERPC_FLAG_BE |             \
                                 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_755        check_pow_hid0
   
   static void init_proc_755 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       gen_spr_G2_755(env);
       /* Time base */
       gen_tbl(env);
       /* L2 cache control */
       /* XXX : not implemented */
       spr_register(env, SPR_L2CR, "L2CR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_L2PMCR, "L2PMCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Thermal management */
       gen_spr_thrm(env);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID2, "HID2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_high_BATs(env);
       gen_6xx_7xx_soft_tlb(env, 64, 2);
       init_excp_7x5(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 7400 (aka G4)                                                     */
   #define POWERPC_INSNS_7400   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_MEM_TLBIA |                                 \
                                 PPC_SEGMENT | PPC_EXTERN |                      \
                                 PPC_ALTIVEC)
   #define POWERPC_MSRM_7400    (0x000000000205FF77ULL)
   #define POWERPC_MMU_7400     (POWERPC_MMU_32B)
   #define POWERPC_EXCP_7400    (POWERPC_EXCP_74xx)
   #define POWERPC_INPUT_7400   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_7400    (bfd_mach_ppc_7400)
   #define POWERPC_FLAG_7400    (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_7400       check_pow_hid0_74xx
   
   static void init_proc_7400 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* Time base */
       gen_tbl(env);
       /* 74xx specific SPR */
       gen_spr_74xx(env);
       /* XXX : not implemented */
       spr_register(env, SPR_UBAMR, "UBAMR",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* XXX: this seems not implemented on all revisions. */
       /* XXX : not implemented */
       spr_register(env, SPR_MSSCR1, "MSSCR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Thermal management */
       gen_spr_thrm(env);
       /* Memory management */
       gen_low_BATs(env);
       init_excp_7400(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 7410 (aka G4)                                                     */
   #define POWERPC_INSNS_7410   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_MEM_TLBIA |                                 \
                                 PPC_SEGMENT | PPC_EXTERN |                      \
                                 PPC_ALTIVEC)
   #define POWERPC_MSRM_7410    (0x000000000205FF77ULL)
   #define POWERPC_MMU_7410     (POWERPC_MMU_32B)
   #define POWERPC_EXCP_7410    (POWERPC_EXCP_74xx)
   #define POWERPC_INPUT_7410   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_7410    (bfd_mach_ppc_7400)
   #define POWERPC_FLAG_7410    (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_7410       check_pow_hid0_74xx
   
   static void init_proc_7410 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* Time base */
       gen_tbl(env);
       /* 74xx specific SPR */
       gen_spr_74xx(env);
       /* XXX : not implemented */
       spr_register(env, SPR_UBAMR, "UBAMR",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* Thermal management */
       gen_spr_thrm(env);
       /* L2PMCR */
       /* XXX : not implemented */
       spr_register(env, SPR_L2PMCR, "L2PMCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* LDSTDB */
       /* XXX : not implemented */
       spr_register(env, SPR_LDSTDB, "LDSTDB",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       init_excp_7400(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 7440 (aka G4)                                                     */
   #define POWERPC_INSNS_7440   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_MEM_TLBIA | PPC_74xx_TLB |                  \
                                 PPC_SEGMENT | PPC_EXTERN |                      \
                                 PPC_ALTIVEC)
   #define POWERPC_MSRM_7440    (0x000000000205FF77ULL)
   #define POWERPC_MMU_7440     (POWERPC_MMU_SOFT_74xx)
   #define POWERPC_EXCP_7440    (POWERPC_EXCP_74xx)
   #define POWERPC_INPUT_7440   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_7440    (bfd_mach_ppc_7400)
   #define POWERPC_FLAG_7440    (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_7440       check_pow_hid0_74xx
   
   __attribute__ (( unused ))
   static void init_proc_7440 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* Time base */
       gen_tbl(env);
       /* 74xx specific SPR */
       gen_spr_74xx(env);
       /* XXX : not implemented */
       spr_register(env, SPR_UBAMR, "UBAMR",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* LDSTCR */
       /* XXX : not implemented */
       spr_register(env, SPR_LDSTCR, "LDSTCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* ICTRL */
       /* XXX : not implemented */
       spr_register(env, SPR_ICTRL, "ICTRL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* MSSSR0 */
       /* XXX : not implemented */
       spr_register(env, SPR_MSSSR0, "MSSSR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* PMC */
       /* XXX : not implemented */
       spr_register(env, SPR_PMC5, "PMC5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UPMC5, "UPMC5",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_PMC6, "PMC6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UPMC6, "UPMC6",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_74xx_soft_tlb(env, 128, 2);
       init_excp_7450(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 7450 (aka G4)                                                     */
   #define POWERPC_INSNS_7450   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_MEM_TLBIA | PPC_74xx_TLB |                  \
                                 PPC_SEGMENT | PPC_EXTERN |                      \
                                 PPC_ALTIVEC)
   #define POWERPC_MSRM_7450    (0x000000000205FF77ULL)
   #define POWERPC_MMU_7450     (POWERPC_MMU_SOFT_74xx)
   #define POWERPC_EXCP_7450    (POWERPC_EXCP_74xx)
   #define POWERPC_INPUT_7450   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_7450    (bfd_mach_ppc_7400)
   #define POWERPC_FLAG_7450    (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_7450       check_pow_hid0_74xx
   
   __attribute__ (( unused ))
   static void init_proc_7450 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* Time base */
       gen_tbl(env);
       /* 74xx specific SPR */
       gen_spr_74xx(env);
       /* Level 3 cache control */
       gen_l3_ctrl(env);
       /* L3ITCR1 */
       /* XXX : not implemented */
       spr_register(env, SPR_L3ITCR1, "L3ITCR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* L3ITCR2 */
       /* XXX : not implemented */
       spr_register(env, SPR_L3ITCR2, "L3ITCR2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* L3ITCR3 */
       /* XXX : not implemented */
       spr_register(env, SPR_L3ITCR3, "L3ITCR3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* L3OHCR */
       /* XXX : not implemented */
       spr_register(env, SPR_L3OHCR, "L3OHCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UBAMR, "UBAMR",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* LDSTCR */
       /* XXX : not implemented */
       spr_register(env, SPR_LDSTCR, "LDSTCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* ICTRL */
       /* XXX : not implemented */
       spr_register(env, SPR_ICTRL, "ICTRL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* MSSSR0 */
       /* XXX : not implemented */
       spr_register(env, SPR_MSSSR0, "MSSSR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* PMC */
       /* XXX : not implemented */
       spr_register(env, SPR_PMC5, "PMC5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UPMC5, "UPMC5",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_PMC6, "PMC6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UPMC6, "UPMC6",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_74xx_soft_tlb(env, 128, 2);
       init_excp_7450(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 7445 (aka G4)                                                     */
   #define POWERPC_INSNS_7445   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_MEM_TLBIA | PPC_74xx_TLB |                  \
                                 PPC_SEGMENT | PPC_EXTERN |                      \
                                 PPC_ALTIVEC)
   #define POWERPC_MSRM_7445    (0x000000000205FF77ULL)
   #define POWERPC_MMU_7445     (POWERPC_MMU_SOFT_74xx)
   #define POWERPC_EXCP_7445    (POWERPC_EXCP_74xx)
   #define POWERPC_INPUT_7445   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_7445    (bfd_mach_ppc_7400)
   #define POWERPC_FLAG_7445    (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_7445       check_pow_hid0_74xx
   
   __attribute__ (( unused ))
   static void init_proc_7445 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* Time base */
       gen_tbl(env);
       /* 74xx specific SPR */
       gen_spr_74xx(env);
       /* LDSTCR */
       /* XXX : not implemented */
       spr_register(env, SPR_LDSTCR, "LDSTCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* ICTRL */
       /* XXX : not implemented */
       spr_register(env, SPR_ICTRL, "ICTRL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* MSSSR0 */
       /* XXX : not implemented */
       spr_register(env, SPR_MSSSR0, "MSSSR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* PMC */
       /* XXX : not implemented */
       spr_register(env, SPR_PMC5, "PMC5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UPMC5, "UPMC5",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_PMC6, "PMC6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UPMC6, "UPMC6",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* SPRGs */
       spr_register(env, SPR_SPRG4, "SPRG4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG4, "USPRG4",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_SPRG5, "SPRG5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG5, "USPRG5",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_SPRG6, "SPRG6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG6, "USPRG6",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_SPRG7, "SPRG7",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG7, "USPRG7",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_high_BATs(env);
       gen_74xx_soft_tlb(env, 128, 2);
       init_excp_7450(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 7455 (aka G4)                                                     */
   #define POWERPC_INSNS_7455   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_MEM_TLBIA | PPC_74xx_TLB |                  \
                                 PPC_SEGMENT | PPC_EXTERN |                      \
                                 PPC_ALTIVEC)
   #define POWERPC_MSRM_7455    (0x000000000205FF77ULL)
   #define POWERPC_MMU_7455     (POWERPC_MMU_SOFT_74xx)
   #define POWERPC_EXCP_7455    (POWERPC_EXCP_74xx)
   #define POWERPC_INPUT_7455   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_7455    (bfd_mach_ppc_7400)
   #define POWERPC_FLAG_7455    (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_7455       check_pow_hid0_74xx
   
   __attribute__ (( unused ))
   static void init_proc_7455 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* Time base */
       gen_tbl(env);
       /* 74xx specific SPR */
       gen_spr_74xx(env);
       /* Level 3 cache control */
       gen_l3_ctrl(env);
       /* LDSTCR */
       /* XXX : not implemented */
       spr_register(env, SPR_LDSTCR, "LDSTCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* ICTRL */
       /* XXX : not implemented */
       spr_register(env, SPR_ICTRL, "ICTRL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* MSSSR0 */
       /* XXX : not implemented */
       spr_register(env, SPR_MSSSR0, "MSSSR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* PMC */
       /* XXX : not implemented */
       spr_register(env, SPR_PMC5, "PMC5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UPMC5, "UPMC5",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_PMC6, "PMC6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UPMC6, "UPMC6",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* SPRGs */
       spr_register(env, SPR_SPRG4, "SPRG4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG4, "USPRG4",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_SPRG5, "SPRG5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG5, "USPRG5",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_SPRG6, "SPRG6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG6, "USPRG6",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_SPRG7, "SPRG7",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG7, "USPRG7",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_high_BATs(env);
       gen_74xx_soft_tlb(env, 128, 2);
       init_excp_7450(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   /* PowerPC 7457 (aka G4)                                                     */
   #define POWERPC_INSNS_7457   (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI |                    \
                                 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |               \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_MEM_TLBIA | PPC_74xx_TLB |                  \
                                 PPC_SEGMENT | PPC_EXTERN |                      \
                                 PPC_ALTIVEC)
   #define POWERPC_MSRM_7457    (0x000000000205FF77ULL)
   #define POWERPC_MMU_7457     (POWERPC_MMU_SOFT_74xx)
   #define POWERPC_EXCP_7457    (POWERPC_EXCP_74xx)
   #define POWERPC_INPUT_7457   (PPC_FLAGS_INPUT_6xx)
   #define POWERPC_BFDM_7457    (bfd_mach_ppc_7400)
   #define POWERPC_FLAG_7457    (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
                                 POWERPC_FLAG_BUS_CLK)
   #define check_pow_7457       check_pow_hid0_74xx
   
   __attribute__ (( unused ))
   static void init_proc_7457 (CPUPPCState *env)
   {
       gen_spr_ne_601(env);
       gen_spr_7xx(env);
       /* Time base */
       gen_tbl(env);
       /* 74xx specific SPR */
       gen_spr_74xx(env);
       /* Level 3 cache control */
       gen_l3_ctrl(env);
       /* L3ITCR1 */
       /* XXX : not implemented */
       spr_register(env, SPR_L3ITCR1, "L3ITCR1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* L3ITCR2 */
       /* XXX : not implemented */
       spr_register(env, SPR_L3ITCR2, "L3ITCR2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* L3ITCR3 */
       /* XXX : not implemented */
       spr_register(env, SPR_L3ITCR3, "L3ITCR3",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* L3OHCR */
       /* XXX : not implemented */
       spr_register(env, SPR_L3OHCR, "L3OHCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* LDSTCR */
       /* XXX : not implemented */
       spr_register(env, SPR_LDSTCR, "LDSTCR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* ICTRL */
       /* XXX : not implemented */
       spr_register(env, SPR_ICTRL, "ICTRL",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* MSSSR0 */
       /* XXX : not implemented */
       spr_register(env, SPR_MSSSR0, "MSSSR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* PMC */
       /* XXX : not implemented */
       spr_register(env, SPR_PMC5, "PMC5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UPMC5, "UPMC5",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_PMC6, "PMC6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_UPMC6, "UPMC6",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* SPRGs */
       spr_register(env, SPR_SPRG4, "SPRG4",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG4, "USPRG4",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_SPRG5, "SPRG5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG5, "USPRG5",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_SPRG6, "SPRG6",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG6, "USPRG6",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       spr_register(env, SPR_SPRG7, "SPRG7",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       spr_register(env, SPR_USPRG7, "USPRG7",
                    &spr_read_ureg, SPR_NOACCESS,
                    &spr_read_ureg, SPR_NOACCESS,
                    0x00000000);
       /* Memory management */
       gen_low_BATs(env);
       gen_high_BATs(env);
       gen_74xx_soft_tlb(env, 128, 2);
       init_excp_7450(env);
       env->dcache_line_size = 32;
       env->icache_line_size = 32;
       /* Allocate hardware IRQ controller */
       ppc6xx_irq_init(env);
   }
   
   #if defined (TARGET_PPC64)
   /* PowerPC 970                                                               */
   #define POWERPC_INSNS_970    (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZT |  \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_64B | PPC_ALTIVEC |                         \
                                 PPC_SEGMENT_64B | PPC_SLBI)
   #define POWERPC_MSRM_970     (0x900000000204FF36ULL)
   #define POWERPC_MMU_970      (POWERPC_MMU_64B)
   //#define POWERPC_EXCP_970     (POWERPC_EXCP_970)
   #define POWERPC_INPUT_970    (PPC_FLAGS_INPUT_970)
   #define POWERPC_BFDM_970     (bfd_mach_ppc64)
   #define POWERPC_FLAG_970     (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
                                 POWERPC_FLAG_BUS_CLK)
   
     return 0;  #if defined(CONFIG_USER_ONLY)
 }  #define POWERPC970_HID5_INIT 0x00000080
   #else
   #define POWERPC970_HID5_INIT 0x00000000
   #endif
   
 static int register_insn (opc_handler_t **ppc_opcodes, opcode_t *insn)  static int check_pow_970 (CPUPPCState *env)
 {  {
     if (insn->opc2 != 0xFF) {      if (env->spr[SPR_HID0] & 0x00600000)
         if (insn->opc3 != 0xFF) {          return 1;
             if (register_dblind_insn(ppc_opcodes, insn->opc1, insn->opc2,  
                                      insn->opc3, &insn->handler) < 0)  
                 return -1;  
         } else {  
             if (register_ind_insn(ppc_opcodes, insn->opc1,  
                                   insn->opc2, &insn->handler) < 0)  
                 return -1;  
         }  
     } else {  
         if (register_direct_insn(ppc_opcodes, insn->opc1, &insn->handler) < 0)  
             return -1;  
     }  
   
     return 0;      return 0;
 }  }
   
 static int test_opcode_table (opc_handler_t **table, int len)  static void init_proc_970 (CPUPPCState *env)
 {  
     int i, count, tmp;  
   
     for (i = 0, count = 0; i < len; i++) {  
         /* Consistency fixup */  
         if (table[i] == NULL)  
             table[i] = &invalid_handler;  
         if (table[i] != &invalid_handler) {  
             if (is_indirect_opcode(table[i])) {  
                 tmp = test_opcode_table(ind_table(table[i]), 0x20);  
                 if (tmp == 0) {  
                     free(table[i]);  
                     table[i] = &invalid_handler;  
                 } else {  
                     count++;  
                 }  
             } else {  
                 count++;  
             }  
         }  
     }  
   
     return count;  
 }  
   
 static void fix_opcode_tables (opc_handler_t **ppc_opcodes)  
 {  {
     if (test_opcode_table(ppc_opcodes, 0x40) == 0)      gen_spr_ne_601(env);
         printf("*** WARNING: no opcode defined !\n");      gen_spr_7xx(env);
 }      /* Time base */
       gen_tbl(env);
       /* Hardware implementation registers */
       /* XXX : not implemented */
       spr_register(env, SPR_HID0, "HID0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_clear,
                    0x60000000);
       /* XXX : not implemented */
       spr_register(env, SPR_HID1, "HID1",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_750FX_HID2, "HID2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_970_HID5, "HID5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    POWERPC970_HID5_INIT);
       /* XXX : not implemented */
       spr_register(env, SPR_L2CR, "L2CR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       /* XXX: not correct */
       gen_low_BATs(env);
       /* XXX : not implemented */
       spr_register(env, SPR_MMUCFG, "MMUCFG",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000); /* TOFIX */
       /* XXX : not implemented */
       spr_register(env, SPR_MMUCSR0, "MMUCSR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000); /* TOFIX */
       spr_register(env, SPR_HIOR, "SPR_HIOR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0xFFF00000); /* XXX: This is a hack */
   #if !defined(CONFIG_USER_ONLY)
       env->slb_nr = 32;
   #endif
       init_excp_970(env);
       env->dcache_line_size = 128;
       env->icache_line_size = 128;
       /* Allocate hardware IRQ controller */
       ppc970_irq_init(env);
   }
   
   /* PowerPC 970FX (aka G5)                                                    */
   #define POWERPC_INSNS_970FX  (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZT |  \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_64B | PPC_ALTIVEC |                         \
                                 PPC_SEGMENT_64B | PPC_SLBI)
   #define POWERPC_MSRM_970FX   (0x800000000204FF36ULL)
   #define POWERPC_MMU_970FX    (POWERPC_MMU_64B)
   #define POWERPC_EXCP_970FX   (POWERPC_EXCP_970)
   #define POWERPC_INPUT_970FX  (PPC_FLAGS_INPUT_970)
   #define POWERPC_BFDM_970FX   (bfd_mach_ppc64)
   #define POWERPC_FLAG_970FX   (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
                                 POWERPC_FLAG_BUS_CLK)
   
 /*****************************************************************************/  static int check_pow_970FX (CPUPPCState *env)
 static int create_ppc_opcodes (CPUPPCState *env, ppc_def_t *def)  
 {  {
     opcode_t *opc, *start, *end;      if (env->spr[SPR_HID0] & 0x00600000)
           return 1;
     fill_new_table(env->opcodes, 0x40);  
 #if defined(PPC_DUMP_CPU)  
     printf("* PPC instructions for PVR %08x: %s\n", def->pvr, def->name);  
 #endif  
     if (&opc_start < &opc_end) {  
         start = &opc_start;  
         end = &opc_end;  
     } else {  
         start = &opc_end;  
         end = &opc_start;  
     }  
     for (opc = start + 1; opc != end; opc++) {  
         if ((opc->handler.type & def->insns_flags) != 0) {  
             if (register_insn(env->opcodes, opc) < 0) {  
                 printf("*** ERROR initializing PPC instruction "  
                         "0x%02x 0x%02x 0x%02x\n", opc->opc1, opc->opc2,  
                         opc->opc3);  
                 return -1;  
             }  
 #if defined(PPC_DUMP_CPU)  
             if (opc1 != 0x00) {  
                 if (opc->opc3 == 0xFF) {  
                     if (opc->opc2 == 0xFF) {  
                         printf(" %02x -- -- (%2d ----) : %s\n",  
                                opc->opc1, opc->opc1, opc->oname);  
                     } else {  
                         printf(" %02x %02x -- (%2d %4d) : %s\n",  
                                opc->opc1, opc->opc2, opc->opc1, opc->opc2,  
                                     opc->oname);  
                     }  
                 } else {  
                     printf(" %02x %02x %02x (%2d %4d) : %s\n",  
                            opc->opc1, opc->opc2, opc->opc3,  
                            opc->opc1, (opc->opc3 << 5) | opc->opc2,  
                            opc->oname);  
                 }  
             }  
 #endif  
         }  
     }  
     fix_opcode_tables(env->opcodes);  
     fflush(stdout);  
     fflush(stderr);  
   
     return 0;      return 0;
 }  }
   
 int cpu_ppc_register (CPUPPCState *env, ppc_def_t *def)  static void init_proc_970FX (CPUPPCState *env)
 {  {
     env->msr_mask = def->msr_mask;      gen_spr_ne_601(env);
     env->flags = def->flags;      gen_spr_7xx(env);
     if (create_ppc_opcodes(env, def) < 0) {      /* Time base */
         printf("Error creating opcodes table\n");      gen_tbl(env);
         fflush(stdout);      /* Hardware implementation registers */
         fflush(stderr);      /* XXX : not implemented */
         return -1;      spr_register(env, SPR_HID0, "HID0",
     }                   SPR_NOACCESS, SPR_NOACCESS,
     init_ppc_proc(env, def);                   &spr_read_generic, &spr_write_clear,
 #if defined(PPC_DUMP_CPU)                   0x60000000);
     dump_sprs(env);      /* XXX : not implemented */
 #endif      spr_register(env, SPR_HID1, "HID1",
     fflush(stdout);                   SPR_NOACCESS, SPR_NOACCESS,
     fflush(stderr);                   &spr_read_generic, &spr_write_generic,
                    0x00000000);
     return 0;      /* XXX : not implemented */
 }      spr_register(env, SPR_750FX_HID2, "HID2",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* XXX : not implemented */
       spr_register(env, SPR_970_HID5, "HID5",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    POWERPC970_HID5_INIT);
       /* XXX : not implemented */
       spr_register(env, SPR_L2CR, "L2CR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000);
       /* Memory management */
       /* XXX: not correct */
       gen_low_BATs(env);
       /* XXX : not implemented */
       spr_register(env, SPR_MMUCFG, "MMUCFG",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, SPR_NOACCESS,
                    0x00000000); /* TOFIX */
       /* XXX : not implemented */
       spr_register(env, SPR_MMUCSR0, "MMUCSR0",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0x00000000); /* TOFIX */
       spr_register(env, SPR_HIOR, "SPR_HIOR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_generic,
                    0xFFF00000); /* XXX: This is a hack */
   #if !defined(CONFIG_USER_ONLY)
       env->slb_nr = 32;
   #endif
       init_excp_970(env);
       env->dcache_line_size = 128;
       env->icache_line_size = 128;
       /* Allocate hardware IRQ controller */
       ppc970_irq_init(env);
   }
   
   /* PowerPC 970 GX                                                            */
   #define POWERPC_INSNS_970GX  (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
                                 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
                                 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
                                 PPC_FLOAT_STFIWX |                              \
                                 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZT |  \
                                 PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
                                 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
                                 PPC_64B | PPC_ALTIVEC |                         \
                                 PPC_SEGMENT_64B | PPC_SLBI)
   #define POWERPC_MSRM_970GX   (0x800000000204FF36ULL)
   #define POWERPC_MMU_970GX    (POWERPC_MMU_64B)
   #define POWERPC_EXCP_970GX   (POWERPC_EXCP_970)
   #define POWERPC_INPUT_970GX  (PPC_FLAGS_INPUT_970)
   #define POWERPC_BFDM_970GX   (bfd_mach_ppc64)
   #define POWERPC_FLAG_970GX   (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
                                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
                                 POWERPC_FLAG_BUS_CLK)
   
 CPUPPCState *cpu_ppc_init(void)  static int check_pow_970GX (CPUPPCState *env)
 {  {
     CPUPPCState *env;      if (env->spr[SPR_HID0] & 0x00600000)
           return 1;
     env = qemu_mallocz(sizeof(CPUPPCState));  
     if (!env)  
         return NULL;  
     cpu_exec_init(env);  
     tlb_flush(env, 1);  
 #if defined (DO_SINGLE_STEP) && 0  
     /* Single step trace mode */  
     msr_se = 1;  
     msr_be = 1;  
 #endif  
     msr_fp = 1; /* Allow floating point exceptions */  
     msr_me = 1; /* Allow machine check exceptions  */  
 #if defined(CONFIG_USER_ONLY)  
     msr_pr = 1;  
 #else  
     env->nip = 0xFFFFFFFC;  
 #endif  
     do_compute_hflags(env);  
     env->reserve = -1;  
     return env;  
 }  
   
 void cpu_ppc_close(CPUPPCState *env)      return 0;
 {  
     /* Should also remove all opcode tables... */  
     free(env);  
 }  }
   
 /*****************************************************************************/  static void init_proc_970GX (CPUPPCState *env)
 /* PowerPC CPU definitions */  
 static ppc_def_t ppc_defs[] =  
 {  {
     /* Embedded PPC */      gen_spr_ne_601(env);
 #if defined (TODO)      gen_spr_7xx(env);
     /* PPC 401 */      /* Time base */
     {      gen_tbl(env);
         .name        = "401",      /* Hardware implementation registers */
         .pvr         = CPU_PPC_401,      /* XXX : not implemented */
         .pvr_mask    = 0xFFFF0000,      spr_register(env, SPR_HID0, "HID0",
         .insns_flags = PPC_INSNS_401,                   SPR_NOACCESS, SPR_NOACCESS,
         .flags       = PPC_FLAGS_401,                   &spr_read_generic, &spr_write_clear,
         .msr_mask    = xxx,                   0x60000000);
     },      /* XXX : not implemented */
 #endif      spr_register(env, SPR_HID1, "HID1",
 #if defined (TODO)                   SPR_NOACCESS, SPR_NOACCESS,
     /* IOP480 (401 microcontroler) */                   &spr_read_generic, &spr_write_generic,
     {                   0x00000000);
         .name        = "iop480",      /* XXX : not implemented */
         .pvr         = CPU_PPC_IOP480,      spr_register(env, SPR_750FX_HID2, "HID2",
         .pvr_mask    = 0xFFFF0000,                   SPR_NOACCESS, SPR_NOACCESS,
         .insns_flags = PPC_INSNS_401,                   &spr_read_generic, &spr_write_generic,
         .flags       = PPC_FLAGS_401,                   0x00000000);
         .msr_mask    = xxx,      /* XXX : not implemented */
     },      spr_register(env, SPR_970_HID5, "HID5",
 #endif                   SPR_NOACCESS, SPR_NOACCESS,
 #if defined (TODO)                   &spr_read_generic, &spr_write_generic,
     /* PPC 403 GA */                   POWERPC970_HID5_INIT);
     {      /* XXX : not implemented */
         .name        = "403ga",      spr_register(env, SPR_L2CR, "L2CR",
         .pvr         = CPU_PPC_403GA,                   SPR_NOACCESS, SPR_NOACCESS,
         .pvr_mask    = 0xFFFFFF00,                   &spr_read_generic, &spr_write_generic,
         .insns_flags = PPC_INSNS_403,                   0x00000000);
         .flags       = PPC_FLAGS_403,      /* Memory management */
         .msr_mask    = 0x000000000007D23D,      /* XXX: not correct */
     },      gen_low_BATs(env);
 #endif      /* XXX : not implemented */
 #if defined (TODO)      spr_register(env, SPR_MMUCFG, "MMUCFG",
     /* PPC 403 GB */                   SPR_NOACCESS, SPR_NOACCESS,
     {                   &spr_read_generic, SPR_NOACCESS,
         .name        = "403gb",                   0x00000000); /* TOFIX */
         .pvr         = CPU_PPC_403GB,      /* XXX : not implemented */
         .pvr_mask    = 0xFFFFFF00,      spr_register(env, SPR_MMUCSR0, "MMUCSR0",
         .insns_flags = PPC_INSNS_403,                   SPR_NOACCESS, SPR_NOACCESS,
         .flags       = PPC_FLAGS_403,                   &spr_read_generic, &spr_write_generic,
         .msr_mask    = 0x000000000007D23D,                   0x00000000); /* TOFIX */
     },      spr_register(env, SPR_HIOR, "SPR_HIOR",
 #endif                   SPR_NOACCESS, SPR_NOACCESS,
 #if defined (TODO)                   &spr_read_generic, &spr_write_generic,
     /* PPC 403 GC */                   0xFFF00000); /* XXX: This is a hack */
     {  #if !defined(CONFIG_USER_ONLY)
         .name        = "403gc",      env->slb_nr = 32;
         .pvr         = CPU_PPC_403GC,  #endif
         .pvr_mask    = 0xFFFFFF00,      init_excp_970(env);
         .insns_flags = PPC_INSNS_403,      env->dcache_line_size = 128;
         .flags       = PPC_FLAGS_403,      env->icache_line_size = 128;
         .msr_mask    = 0x000000000007D23D,      /* Allocate hardware IRQ controller */
     },      ppc970_irq_init(env);
 #endif  }
 #if defined (TODO)  
     /* PPC 403 GCX */  /* PowerPC 970 MP                                                            */
     {  #define POWERPC_INSNS_970MP  (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |        \
         .name        = "403gcx",                                PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |   \
         .pvr         = CPU_PPC_403GCX,                                PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |           \
         .pvr_mask    = 0xFFFFFF00,                                PPC_FLOAT_STFIWX |                              \
         .insns_flags = PPC_INSNS_403,                                PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZT |  \
         .flags       = PPC_FLAGS_403,                                PPC_MEM_SYNC | PPC_MEM_EIEIO |                  \
         .msr_mask    = 0x000000000007D23D,                                PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |               \
     },                                PPC_64B | PPC_ALTIVEC |                         \
 #endif                                PPC_SEGMENT_64B | PPC_SLBI)
 #if defined (TODO)  #define POWERPC_MSRM_970MP   (0x900000000204FF36ULL)
     /* PPC 405 CR */  #define POWERPC_MMU_970MP    (POWERPC_MMU_64B)
     {  #define POWERPC_EXCP_970MP   (POWERPC_EXCP_970)
         .name        = "405cr",  #define POWERPC_INPUT_970MP  (PPC_FLAGS_INPUT_970)
         .pvr         = CPU_PPC_405,  #define POWERPC_BFDM_970MP   (bfd_mach_ppc64)
         .pvr_mask    = 0xFFFF0000,  #define POWERPC_FLAG_970MP   (POWERPC_FLAG_VRE | POWERPC_FLAG_SE |            \
         .insns_flags = PPC_INSNS_405,                                POWERPC_FLAG_BE | POWERPC_FLAG_PMM |            \
         .flags       = PPC_FLAGS_405,                &nb