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

version 1.1.1.4, 2018/04/24 16:49:06 version 1.1.1.5, 2018/04/24 16:54:23
Line 15 Line 15
  *   *
  * You should have received a copy of the GNU Lesser General Public   * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software   * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA  02110-1301 USA
  */   */
   
 /* A lot of PowerPC definition have been included here.  /* A lot of PowerPC definition have been included here.
Line 24 Line 24
  */   */
   
 #include "dis-asm.h"  #include "dis-asm.h"
 #include "host-utils.h"  #include "gdbstub.h"
   
 //#define PPC_DUMP_CPU  //#define PPC_DUMP_CPU
 //#define PPC_DEBUG_SPR  //#define PPC_DEBUG_SPR
Line 34 Line 34
 #endif  #endif
   
 struct ppc_def_t {  struct ppc_def_t {
     const unsigned char *name;      const char *name;
     uint32_t pvr;      uint32_t pvr;
     uint32_t svr;      uint32_t svr;
     uint64_t insns_flags;      uint64_t insns_flags;
Line 62  void glue(glue(ppc, name),_irq_init) (CP Line 62  void glue(glue(ppc, name),_irq_init) (CP
 PPC_IRQ_INIT_FN(40x);  PPC_IRQ_INIT_FN(40x);
 PPC_IRQ_INIT_FN(6xx);  PPC_IRQ_INIT_FN(6xx);
 PPC_IRQ_INIT_FN(970);  PPC_IRQ_INIT_FN(970);
   PPC_IRQ_INIT_FN(e500);
   
 /* 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 gprn, int sprn)
 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)  
 {  {
     gen_op_load_spr(sprn);      gen_load_spr(cpu_gpr[gprn], sprn);
   #ifdef PPC_DUMP_SPR_ACCESSES
       {
           TCGv t0 = tcg_const_i32(sprn);
           gen_helper_load_dump_spr(t0);
           tcg_temp_free_i32(t0);
       }
   #endif
 }  }
   
 static void spr_write_generic (void *opaque, int sprn)  static void spr_write_generic (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_spr(sprn);      gen_store_spr(sprn, cpu_gpr[gprn]);
 }  #ifdef PPC_DUMP_SPR_ACCESSES
       {
           TCGv t0 = tcg_const_i32(sprn);
           gen_helper_store_dump_spr(t0);
           tcg_temp_free_i32(t0);
       }
 #endif  #endif
   }
   
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
 static void spr_write_clear (void *opaque, int sprn)  static void spr_write_clear (void *opaque, int sprn, int gprn)
 {  {
     gen_op_mask_spr(sprn);      TCGv t0 = tcg_temp_new();
       TCGv t1 = tcg_temp_new();
       gen_load_spr(t0, sprn);
       tcg_gen_neg_tl(t1, cpu_gpr[gprn]);
       tcg_gen_and_tl(t0, t0, t1);
       gen_store_spr(sprn, t0);
       tcg_temp_free(t0);
       tcg_temp_free(t1);
 }  }
 #endif  #endif
   
 /* SPR common to all PowerPC */  /* SPR common to all PowerPC */
 /* XER */  /* XER */
 static void spr_read_xer (void *opaque, int sprn)  static void spr_read_xer (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_xer();      tcg_gen_mov_tl(cpu_gpr[gprn], cpu_xer);
 }  }
   
 static void spr_write_xer (void *opaque, int sprn)  static void spr_write_xer (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_xer();      tcg_gen_mov_tl(cpu_xer, cpu_gpr[gprn]);
 }  }
   
 /* LR */  /* LR */
 static void spr_read_lr (void *opaque, int sprn)  static void spr_read_lr (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_lr();      tcg_gen_mov_tl(cpu_gpr[gprn], cpu_lr);
 }  }
   
 static void spr_write_lr (void *opaque, int sprn)  static void spr_write_lr (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_lr();      tcg_gen_mov_tl(cpu_lr, cpu_gpr[gprn]);
 }  }
   
 /* CTR */  /* CTR */
 static void spr_read_ctr (void *opaque, int sprn)  static void spr_read_ctr (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_ctr();      tcg_gen_mov_tl(cpu_gpr[gprn], cpu_ctr);
 }  }
   
 static void spr_write_ctr (void *opaque, int sprn)  static void spr_write_ctr (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_ctr();      tcg_gen_mov_tl(cpu_ctr, cpu_gpr[gprn]);
 }  }
   
 /* User read access to SPR */  /* User read access to SPR */
Line 135  static void spr_write_ctr (void *opaque, Line 145  static void spr_write_ctr (void *opaque,
 /* UPMCx */  /* UPMCx */
 /* USIA */  /* USIA */
 /* UDECR */  /* UDECR */
 static void spr_read_ureg (void *opaque, int sprn)  static void spr_read_ureg (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_spr(sprn + 0x10);      gen_load_spr(cpu_gpr[gprn], sprn + 0x10);
 }  }
   
 /* SPR common to all non-embedded PowerPC */  /* SPR common to all non-embedded PowerPC */
 /* DECR */  /* DECR */
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
 static void spr_read_decr (void *opaque, int sprn)  static void spr_read_decr (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_decr();      gen_helper_load_decr(cpu_gpr[gprn]);
 }  }
   
 static void spr_write_decr (void *opaque, int sprn)  static void spr_write_decr (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_decr();      gen_helper_store_decr(cpu_gpr[gprn]);
 }  }
 #endif  #endif
   
 /* SPR common to all non-embedded PowerPC, 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 gprn, int sprn)
 {  {
     gen_op_load_tbl();      gen_helper_load_tbl(cpu_gpr[gprn]);
 }  }
   
 static void spr_read_tbu (void *opaque, int sprn)  static void spr_read_tbu (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_tbu();      gen_helper_load_tbu(cpu_gpr[gprn]);
 }  }
   
 __attribute__ (( unused ))  __attribute__ (( unused ))
 static void spr_read_atbl (void *opaque, int sprn)  static void spr_read_atbl (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_atbl();      gen_helper_load_atbl(cpu_gpr[gprn]);
 }  }
   
 __attribute__ (( unused ))  __attribute__ (( unused ))
 static void spr_read_atbu (void *opaque, int sprn)  static void spr_read_atbu (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_atbu();      gen_helper_load_atbu(cpu_gpr[gprn]);
 }  }
   
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
 static void spr_write_tbl (void *opaque, int sprn)  static void spr_write_tbl (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_tbl();      gen_helper_store_tbl(cpu_gpr[gprn]);
 }  }
   
 static void spr_write_tbu (void *opaque, int sprn)  static void spr_write_tbu (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_tbu();      gen_helper_store_tbu(cpu_gpr[gprn]);
 }  }
   
 __attribute__ (( unused ))  __attribute__ (( unused ))
 static void spr_write_atbl (void *opaque, int sprn)  static void spr_write_atbl (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_atbl();      gen_helper_store_atbl(cpu_gpr[gprn]);
 }  }
   
 __attribute__ (( unused ))  __attribute__ (( unused ))
 static void spr_write_atbu (void *opaque, int sprn)  static void spr_write_atbu (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_atbu();      gen_helper_store_atbu(cpu_gpr[gprn]);
 }  }
 #endif  #endif
   
 #if !defined(CONFIG_USER_ONLY)  #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 gprn, int sprn)
 {  {
     gen_op_load_ibat(sprn & 1, (sprn - SPR_IBAT0U) / 2);      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
 }  }
   
 static void spr_read_ibat_h (void *opaque, int sprn)  static void spr_read_ibat_h (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_ibat(sprn & 1, (sprn - SPR_IBAT4U) / 2);      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, IBAT[sprn & 1][(sprn - SPR_IBAT4U) / 2]));
 }  }
   
 static void spr_write_ibatu (void *opaque, int sprn)  static void spr_write_ibatu (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_ibatu((sprn - SPR_IBAT0U) / 2);      TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
       gen_helper_store_ibatu(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
   
 static void spr_write_ibatu_h (void *opaque, int sprn)  static void spr_write_ibatu_h (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_ibatu((sprn - SPR_IBAT4U) / 2);      TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT4U) / 2);
       gen_helper_store_ibatu(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
   
 static void spr_write_ibatl (void *opaque, int sprn)  static void spr_write_ibatl (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_ibatl((sprn - SPR_IBAT0L) / 2);      TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0L) / 2);
       gen_helper_store_ibatl(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
   
 static void spr_write_ibatl_h (void *opaque, int sprn)  static void spr_write_ibatl_h (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_ibatl((sprn - SPR_IBAT4L) / 2);      TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT4L) / 2);
       gen_helper_store_ibatl(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
   
 /* DBAT0U...DBAT7U */  /* DBAT0U...DBAT7U */
 /* DBAT0L...DBAT7L */  /* DBAT0L...DBAT7L */
 static void spr_read_dbat (void *opaque, int sprn)  static void spr_read_dbat (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_dbat(sprn & 1, (sprn - SPR_DBAT0U) / 2);      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, DBAT[sprn & 1][(sprn - SPR_DBAT0U) / 2]));
 }  }
   
 static void spr_read_dbat_h (void *opaque, int sprn)  static void spr_read_dbat_h (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_dbat(sprn & 1, ((sprn - SPR_DBAT4U) / 2) + 4);      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, 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, int gprn)
 {  {
     gen_op_store_dbatu((sprn - SPR_DBAT0U) / 2);      TCGv_i32 t0 = tcg_const_i32((sprn - SPR_DBAT0U) / 2);
       gen_helper_store_dbatu(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
   
 static void spr_write_dbatu_h (void *opaque, int sprn)  static void spr_write_dbatu_h (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_dbatu(((sprn - SPR_DBAT4U) / 2) + 4);      TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_DBAT4U) / 2) + 4);
       gen_helper_store_dbatu(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
   
 static void spr_write_dbatl (void *opaque, int sprn)  static void spr_write_dbatl (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_dbatl((sprn - SPR_DBAT0L) / 2);      TCGv_i32 t0 = tcg_const_i32((sprn - SPR_DBAT0L) / 2);
       gen_helper_store_dbatl(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
   
 static void spr_write_dbatl_h (void *opaque, int sprn)  static void spr_write_dbatl_h (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_dbatl(((sprn - SPR_DBAT4L) / 2) + 4);      TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_DBAT4L) / 2) + 4);
       gen_helper_store_dbatl(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
   
 /* SDR1 */  /* SDR1 */
 static void spr_read_sdr1 (void *opaque, int sprn)  static void spr_read_sdr1 (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_sdr1();      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, sdr1));
 }  }
   
 static void spr_write_sdr1 (void *opaque, int sprn)  static void spr_write_sdr1 (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_sdr1();      gen_helper_store_sdr1(cpu_gpr[gprn]);
 }  }
   
 /* 64 bits PowerPC specific SPRs */  /* 64 bits PowerPC specific SPRs */
 /* ASR */  /* ASR */
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 static void spr_read_asr (void *opaque, int sprn)  static void spr_read_hior (void *opaque, int gprn, int sprn)
   {
       tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, excp_prefix));
   }
   
   static void spr_write_hior (void *opaque, int sprn, int gprn)
 {  {
     gen_op_load_asr();      TCGv t0 = tcg_temp_new();
       tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0x3FFFFF00000ULL);
       tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, excp_prefix));
       tcg_temp_free(t0);
 }  }
   
 static void spr_write_asr (void *opaque, int sprn)  static void spr_read_asr (void *opaque, int gprn, int sprn)
 {  {
     gen_op_store_asr();      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, asr));
   }
   
   static void spr_write_asr (void *opaque, int sprn, int gprn)
   {
       gen_helper_store_asr(cpu_gpr[gprn]);
 }  }
 #endif  #endif
 #endif  #endif
   
 /* PowerPC 601 specific registers */  /* PowerPC 601 specific registers */
 /* RTC */  /* RTC */
 static void spr_read_601_rtcl (void *opaque, int sprn)  static void spr_read_601_rtcl (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_601_rtcl();      gen_helper_load_601_rtcl(cpu_gpr[gprn]);
 }  }
   
 static void spr_read_601_rtcu (void *opaque, int sprn)  static void spr_read_601_rtcu (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_601_rtcu();      gen_helper_load_601_rtcu(cpu_gpr[gprn]);
 }  }
   
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
 static void spr_write_601_rtcu (void *opaque, int sprn)  static void spr_write_601_rtcu (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_601_rtcu();      gen_helper_store_601_rtcu(cpu_gpr[gprn]);
 }  }
   
 static void spr_write_601_rtcl (void *opaque, int sprn)  static void spr_write_601_rtcl (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_601_rtcl();      gen_helper_store_601_rtcl(cpu_gpr[gprn]);
 }  }
   
 static void spr_write_hid0_601 (void *opaque, int sprn)  static void spr_write_hid0_601 (void *opaque, int sprn, int gprn)
 {  {
     DisasContext *ctx = opaque;      DisasContext *ctx = opaque;
   
     gen_op_store_hid0_601();      gen_helper_store_hid0_601(cpu_gpr[gprn]);
     /* Must stop the translation as endianness may have changed */      /* Must stop the translation as endianness may have changed */
     GEN_STOP(ctx);      gen_stop_exception(ctx);
 }  }
 #endif  #endif
   
 /* Unified bats */  /* Unified bats */
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
 static void spr_read_601_ubat (void *opaque, int sprn)  static void spr_read_601_ubat (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_601_bat(sprn & 1, (sprn - SPR_IBAT0U) / 2);      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
 }  }
   
 static void spr_write_601_ubatu (void *opaque, int sprn)  static void spr_write_601_ubatu (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_601_batu((sprn - SPR_IBAT0U) / 2);      TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
       gen_helper_store_601_batl(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
   
 static void spr_write_601_ubatl (void *opaque, int sprn)  static void spr_write_601_ubatl (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_601_batl((sprn - SPR_IBAT0L) / 2);      TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
       gen_helper_store_601_batu(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
 #endif  #endif
   
 /* PowerPC 40x specific registers */  /* PowerPC 40x specific registers */
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
 static void spr_read_40x_pit (void *opaque, int sprn)  static void spr_read_40x_pit (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_40x_pit();      gen_helper_load_40x_pit(cpu_gpr[gprn]);
 }  }
   
 static void spr_write_40x_pit (void *opaque, int sprn)  static void spr_write_40x_pit (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_40x_pit();      gen_helper_store_40x_pit(cpu_gpr[gprn]);
 }  }
   
 static void spr_write_40x_dbcr0 (void *opaque, int sprn)  static void spr_write_40x_dbcr0 (void *opaque, int sprn, int gprn)
 {  {
     DisasContext *ctx = opaque;      DisasContext *ctx = opaque;
   
     gen_op_store_40x_dbcr0();      gen_helper_store_40x_dbcr0(cpu_gpr[gprn]);
     /* We must stop translation as we may have rebooted */      /* We must stop translation as we may have rebooted */
     GEN_STOP(ctx);      gen_stop_exception(ctx);
 }  }
   
 static void spr_write_40x_sler (void *opaque, int sprn)  static void spr_write_40x_sler (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_40x_sler();      gen_helper_store_40x_sler(cpu_gpr[gprn]);
 }  }
   
 static void spr_write_booke_tcr (void *opaque, int sprn)  static void spr_write_booke_tcr (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_booke_tcr();      gen_helper_store_booke_tcr(cpu_gpr[gprn]);
 }  }
   
 static void spr_write_booke_tsr (void *opaque, int sprn)  static void spr_write_booke_tsr (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_booke_tsr();      gen_helper_store_booke_tsr(cpu_gpr[gprn]);
 }  }
 #endif  #endif
   
 /* PowerPC 403 specific registers */  /* PowerPC 403 specific registers */
 /* PBL1 / PBU1 / PBL2 / PBU2 */  /* PBL1 / PBU1 / PBL2 / PBU2 */
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
 static void spr_read_403_pbr (void *opaque, int sprn)  static void spr_read_403_pbr (void *opaque, int gprn, int sprn)
 {  {
     gen_op_load_403_pb(sprn - SPR_403_PBL1);      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, pb[sprn - SPR_403_PBL1]));
 }  }
   
 static void spr_write_403_pbr (void *opaque, int sprn)  static void spr_write_403_pbr (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_403_pb(sprn - SPR_403_PBL1);      TCGv_i32 t0 = tcg_const_i32(sprn - SPR_403_PBL1);
       gen_helper_store_403_pbr(t0, cpu_gpr[gprn]);
       tcg_temp_free_i32(t0);
 }  }
   
 static void spr_write_pir (void *opaque, int sprn)  static void spr_write_pir (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_pir();      TCGv t0 = tcg_temp_new();
       tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0xF);
       gen_store_spr(SPR_PIR, t0);
       tcg_temp_free(t0);
 }  }
 #endif  #endif
   
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
 /* Callback used to write the exception vector base */  /* Callback used to write the exception vector base */
 static void spr_write_excp_prefix (void *opaque, int sprn)  static void spr_write_excp_prefix (void *opaque, int sprn, int gprn)
 {  {
     gen_op_store_excp_prefix();      TCGv t0 = tcg_temp_new();
     gen_op_store_spr(sprn);      tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, ivpr_mask));
       tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
       tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, excp_prefix));
       gen_store_spr(sprn, t0);
 }  }
   
 static void spr_write_excp_vector (void *opaque, int sprn)  static void spr_write_excp_vector (void *opaque, int sprn, int gprn)
 {  {
     DisasContext *ctx = opaque;      DisasContext *ctx = opaque;
   
     if (sprn >= SPR_BOOKE_IVOR0 && sprn <= SPR_BOOKE_IVOR15) {      if (sprn >= SPR_BOOKE_IVOR0 && sprn <= SPR_BOOKE_IVOR15) {
         gen_op_store_excp_vector(sprn - SPR_BOOKE_IVOR0);          TCGv t0 = tcg_temp_new();
         gen_op_store_spr(sprn);          tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, ivor_mask));
           tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
           tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, excp_vectors[sprn - SPR_BOOKE_IVOR0]));
           gen_store_spr(sprn, t0);
           tcg_temp_free(t0);
     } else if (sprn >= SPR_BOOKE_IVOR32 && sprn <= SPR_BOOKE_IVOR37) {      } else if (sprn >= SPR_BOOKE_IVOR32 && sprn <= SPR_BOOKE_IVOR37) {
         gen_op_store_excp_vector(sprn - SPR_BOOKE_IVOR32 + 32);          TCGv t0 = tcg_temp_new();
         gen_op_store_spr(sprn);          tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, ivor_mask));
           tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
           tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, excp_vectors[sprn - SPR_BOOKE_IVOR32 + 32]));
           gen_store_spr(sprn, t0);
           tcg_temp_free(t0);
     } else {      } else {
         printf("Trying to write an unknown exception vector %d %03x\n",          printf("Trying to write an unknown exception vector %d %03x\n",
                sprn, sprn);                 sprn, sprn);
         GEN_EXCP_PRIVREG(ctx);          gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
     }      }
 }  }
 #endif  #endif
   
   static inline void vscr_init (CPUPPCState *env, uint32_t val)
   {
       env->vscr = val;
       /* Altivec always uses round-to-nearest */
       set_float_rounding_mode(float_round_nearest_even, &env->vec_status);
       set_flush_to_zero(vscr_nj, &env->vec_status);
   }
   
 #if defined(CONFIG_USER_ONLY)  #if defined(CONFIG_USER_ONLY)
 #define spr_register(env, num, name, uea_read, uea_write,                     \  #define spr_register(env, num, name, uea_read, uea_write,                     \
                      oea_read, oea_write, initial_value)                      \                       oea_read, oea_write, initial_value)                      \
Line 433  do {                                     Line 500  do {                                    
      _spr_register(env, num, name, uea_read, uea_write, initial_value);       \       _spr_register(env, num, name, uea_read, uea_write, initial_value);       \
 } while (0)  } while (0)
 static inline void _spr_register (CPUPPCState *env, int num,  static inline void _spr_register (CPUPPCState *env, int num,
                                   const unsigned char *name,                                    const char *name,
                                   void (*uea_read)(void *opaque, int sprn),                                    void (*uea_read)(void *opaque, int gprn, int sprn),
                                   void (*uea_write)(void *opaque, int sprn),                                    void (*uea_write)(void *opaque, int sprn, int gprn),
                                   target_ulong initial_value)                                    target_ulong initial_value)
 #else  #else
 static inline void spr_register (CPUPPCState *env, int num,  static inline void spr_register (CPUPPCState *env, int num,
                                  const unsigned char *name,                                   const char *name,
                                  void (*uea_read)(void *opaque, int sprn),                                   void (*uea_read)(void *opaque, int gprn, int sprn),
                                  void (*uea_write)(void *opaque, int sprn),                                   void (*uea_write)(void *opaque, int sprn, int gprn),
                                  void (*oea_read)(void *opaque, int sprn),                                   void (*oea_read)(void *opaque, int gprn, int sprn),
                                  void (*oea_write)(void *opaque, int sprn),                                   void (*oea_write)(void *opaque, int sprn, int gprn),
                                  target_ulong initial_value)                                   target_ulong initial_value)
 #endif  #endif
 {  {
Line 1174  static void gen_spr_74xx (CPUPPCState *e Line 1241  static void gen_spr_74xx (CPUPPCState *e
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   0x00000000);
       /* Not strictly an SPR */
       vscr_init(env, 0x00010000);
 }  }
   
 static void gen_l3_ctrl (CPUPPCState *env)  static void gen_l3_ctrl (CPUPPCState *env)
Line 1245  static void gen_spr_usprgh (CPUPPCState  Line 1314  static void gen_spr_usprgh (CPUPPCState 
 /* PowerPC BookE SPR */  /* PowerPC BookE SPR */
 static void gen_spr_BookE (CPUPPCState *env, uint64_t ivor_mask)  static void gen_spr_BookE (CPUPPCState *env, uint64_t ivor_mask)
 {  {
     const unsigned char *ivor_names[64] = {      const char *ivor_names[64] = {
         "IVOR0",  "IVOR1",  "IVOR2",  "IVOR3",          "IVOR0",  "IVOR1",  "IVOR2",  "IVOR3",
         "IVOR4",  "IVOR5",  "IVOR6",  "IVOR7",          "IVOR4",  "IVOR5",  "IVOR6",  "IVOR7",
         "IVOR8",  "IVOR9",  "IVOR10", "IVOR11",          "IVOR8",  "IVOR9",  "IVOR10", "IVOR11",
Line 1407  static void gen_spr_BookE (CPUPPCState * Line 1476  static void gen_spr_BookE (CPUPPCState *
 static void gen_spr_BookE_FSL (CPUPPCState *env, uint32_t mas_mask)  static void gen_spr_BookE_FSL (CPUPPCState *env, uint32_t mas_mask)
 {  {
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
     const unsigned char *mas_names[8] = {      const char *mas_names[8] = {
         "MAS0", "MAS1", "MAS2", "MAS3", "MAS4", "MAS5", "MAS6", "MAS7",          "MAS0", "MAS1", "MAS2", "MAS3", "MAS4", "MAS5", "MAS6", "MAS7",
     };      };
     int mas_sprn[8] = {      int mas_sprn[8] = {
Line 3928  static void init_proc_G2LE (CPUPPCState  Line 3997  static void init_proc_G2LE (CPUPPCState 
  * all SPE multiply-accumulate instructions   * all SPE multiply-accumulate instructions
  */   */
 #define POWERPC_INSNS_e200   (PPC_INSNS_BASE | PPC_ISEL |                     \  #define POWERPC_INSNS_e200   (PPC_INSNS_BASE | PPC_ISEL |                     \
                               PPC_SPE | PPC_SPEFPU |                          \                                PPC_SPE | PPC_SPE_SINGLE |                      \
                               PPC_WRTEE | PPC_RFDI |                          \                                PPC_WRTEE | PPC_RFDI |                          \
                               PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |   \                                PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |   \
                               PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \                                PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
Line 4091  static void init_proc_e300 (CPUPPCState  Line 4160  static void init_proc_e300 (CPUPPCState 
     ppc6xx_irq_init(env);      ppc6xx_irq_init(env);
 }  }
   
 /* e500 core                                                                 */  /* e500v1 core                                                               */
 #define POWERPC_INSNS_e500   (PPC_INSNS_BASE | PPC_ISEL |                     \  #define POWERPC_INSNS_e500v1   (PPC_INSNS_BASE | PPC_ISEL |             \
                               PPC_SPE | PPC_SPEFPU |                          \                                  PPC_SPE | PPC_SPE_SINGLE |              \
                               PPC_WRTEE | PPC_RFDI |                          \                                  PPC_WRTEE | PPC_RFDI |                  \
                               PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |   \                                  PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI | \
                               PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \                                  PPC_CACHE_DCBZ | PPC_CACHE_DCBA |       \
                               PPC_MEM_TLBSYNC | PPC_TLBIVAX |                 \                                  PPC_MEM_TLBSYNC | PPC_TLBIVAX |         \
                               PPC_BOOKE)                                  PPC_BOOKE)
 #define POWERPC_MSRM_e500    (0x000000000606FF30ULL)  #define POWERPC_MSRM_e500v1    (0x000000000606FF30ULL)
 #define POWERPC_MMU_e500     (POWERPC_MMU_BOOKE_FSL)  #define POWERPC_MMU_e500v1     (POWERPC_MMU_BOOKE_FSL)
 #define POWERPC_EXCP_e500    (POWERPC_EXCP_BOOKE)  #define POWERPC_EXCP_e500v1    (POWERPC_EXCP_BOOKE)
 #define POWERPC_INPUT_e500   (PPC_FLAGS_INPUT_BookE)  #define POWERPC_INPUT_e500v1   (PPC_FLAGS_INPUT_BookE)
 #define POWERPC_BFDM_e500    (bfd_mach_ppc_860)  #define POWERPC_BFDM_e500v1    (bfd_mach_ppc_860)
 #define POWERPC_FLAG_e500    (POWERPC_FLAG_SPE | POWERPC_FLAG_CE |            \  #define POWERPC_FLAG_e500v1    (POWERPC_FLAG_SPE | POWERPC_FLAG_CE |    \
                               POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |           \                                  POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |   \
                               POWERPC_FLAG_BUS_CLK)                                  POWERPC_FLAG_BUS_CLK)
 #define check_pow_e500       check_pow_hid0  #define check_pow_e500v1       check_pow_hid0
   #define init_proc_e500v1       init_proc_e500
   
   /* e500v2 core                                                               */
   #define POWERPC_INSNS_e500v2   (PPC_INSNS_BASE | PPC_ISEL |             \
                                   PPC_SPE | PPC_SPE_SINGLE | PPC_SPE_DOUBLE |   \
                                   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_e500v2    (0x000000000606FF30ULL)
   #define POWERPC_MMU_e500v2     (POWERPC_MMU_BOOKE_FSL)
   #define POWERPC_EXCP_e500v2    (POWERPC_EXCP_BOOKE)
   #define POWERPC_INPUT_e500v2   (PPC_FLAGS_INPUT_BookE)
   #define POWERPC_BFDM_e500v2    (bfd_mach_ppc_860)
   #define POWERPC_FLAG_e500v2    (POWERPC_FLAG_SPE | POWERPC_FLAG_CE |    \
                                   POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |   \
                                   POWERPC_FLAG_BUS_CLK)
   #define check_pow_e500v2       check_pow_hid0
   #define init_proc_e500v2       init_proc_e500
   
 __attribute__ (( unused ))  
 static void init_proc_e500 (CPUPPCState *env)  static void init_proc_e500 (CPUPPCState *env)
 {  {
     /* Time base */      /* Time base */
Line 4211  static void init_proc_e500 (CPUPPCState  Line 4299  static void init_proc_e500 (CPUPPCState 
     init_excp_e200(env);      init_excp_e200(env);
     env->dcache_line_size = 32;      env->dcache_line_size = 32;
     env->icache_line_size = 32;      env->icache_line_size = 32;
     /* XXX: TODO: allocate internal IRQ controller */      /* Allocate hardware IRQ controller */
       ppce500_irq_init(env);
 }  }
   
 /* Non-embedded PowerPC                                                      */  /* Non-embedded PowerPC                                                      */
Line 5863  static void init_proc_970 (CPUPPCState * Line 5952  static void init_proc_970 (CPUPPCState *
                  0x00000000); /* TOFIX */                   0x00000000); /* TOFIX */
     spr_register(env, SPR_HIOR, "SPR_HIOR",      spr_register(env, SPR_HIOR, "SPR_HIOR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_hior, &spr_write_hior,
                  0xFFF00000); /* XXX: This is a hack */                   0x00000000);
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
     env->slb_nr = 32;      env->slb_nr = 32;
 #endif  #endif
Line 5873  static void init_proc_970 (CPUPPCState * Line 5962  static void init_proc_970 (CPUPPCState *
     env->icache_line_size = 128;      env->icache_line_size = 128;
     /* Allocate hardware IRQ controller */      /* Allocate hardware IRQ controller */
     ppc970_irq_init(env);      ppc970_irq_init(env);
       /* Can't find information on what this should be on reset.  This
        * value is the one used by 74xx processors. */
       vscr_init(env, 0x00010000);
 }  }
   
 /* PowerPC 970FX (aka G5)                                                    */  /* PowerPC 970FX (aka G5)                                                    */
Line 5949  static void init_proc_970FX (CPUPPCState Line 6041  static void init_proc_970FX (CPUPPCState
                  0x00000000); /* TOFIX */                   0x00000000); /* TOFIX */
     spr_register(env, SPR_HIOR, "SPR_HIOR",      spr_register(env, SPR_HIOR, "SPR_HIOR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_hior, &spr_write_hior,
                  0xFFF00000); /* XXX: This is a hack */                   0x00000000);
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
     env->slb_nr = 32;      env->slb_nr = 32;
 #endif  #endif
Line 5959  static void init_proc_970FX (CPUPPCState Line 6051  static void init_proc_970FX (CPUPPCState
     env->icache_line_size = 128;      env->icache_line_size = 128;
     /* Allocate hardware IRQ controller */      /* Allocate hardware IRQ controller */
     ppc970_irq_init(env);      ppc970_irq_init(env);
       /* Can't find information on what this should be on reset.  This
        * value is the one used by 74xx processors. */
       vscr_init(env, 0x00010000);
 }  }
   
 /* PowerPC 970 GX                                                            */  /* PowerPC 970 GX                                                            */
Line 6035  static void init_proc_970GX (CPUPPCState Line 6130  static void init_proc_970GX (CPUPPCState
                  0x00000000); /* TOFIX */                   0x00000000); /* TOFIX */
     spr_register(env, SPR_HIOR, "SPR_HIOR",      spr_register(env, SPR_HIOR, "SPR_HIOR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_hior, &spr_write_hior,
                  0xFFF00000); /* XXX: This is a hack */                   0x00000000);
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
     env->slb_nr = 32;      env->slb_nr = 32;
 #endif  #endif
Line 6045  static void init_proc_970GX (CPUPPCState Line 6140  static void init_proc_970GX (CPUPPCState
     env->icache_line_size = 128;      env->icache_line_size = 128;
     /* Allocate hardware IRQ controller */      /* Allocate hardware IRQ controller */
     ppc970_irq_init(env);      ppc970_irq_init(env);
       /* Can't find information on what this should be on reset.  This
        * value is the one used by 74xx processors. */
       vscr_init(env, 0x00010000);
 }  }
   
 /* PowerPC 970 MP                                                            */  /* PowerPC 970 MP                                                            */
Line 6121  static void init_proc_970MP (CPUPPCState Line 6219  static void init_proc_970MP (CPUPPCState
                  0x00000000); /* TOFIX */                   0x00000000); /* TOFIX */
     spr_register(env, SPR_HIOR, "SPR_HIOR",      spr_register(env, SPR_HIOR, "SPR_HIOR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_hior, &spr_write_hior,
                  0xFFF00000); /* XXX: This is a hack */                   0x00000000);
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
     env->slb_nr = 32;      env->slb_nr = 32;
 #endif  #endif
Line 6131  static void init_proc_970MP (CPUPPCState Line 6229  static void init_proc_970MP (CPUPPCState
     env->icache_line_size = 128;      env->icache_line_size = 128;
     /* Allocate hardware IRQ controller */      /* Allocate hardware IRQ controller */
     ppc970_irq_init(env);      ppc970_irq_init(env);
       /* Can't find information on what this should be on reset.  This
        * value is the one used by 74xx processors. */
       vscr_init(env, 0x00010000);
 }  }
   
 /* PowerPC 620                                                               */  /* PowerPC 620                                                               */
Line 6623  enum { Line 6724  enum {
     /* e500 family */      /* e500 family */
     /* e500 cores  */      /* e500 cores  */
 #define CPU_POWERPC_e500             CPU_POWERPC_e500v2_v22  #define CPU_POWERPC_e500             CPU_POWERPC_e500v2_v22
   #define CPU_POWERPC_e500v1           CPU_POWERPC_e500v1_v20
 #define CPU_POWERPC_e500v2           CPU_POWERPC_e500v2_v22  #define CPU_POWERPC_e500v2           CPU_POWERPC_e500v2_v22
     CPU_POWERPC_e500_v10           = 0x80200010,      CPU_POWERPC_e500v1_v10         = 0x80200010,
     CPU_POWERPC_e500_v20           = 0x80200020,      CPU_POWERPC_e500v1_v20         = 0x80200020,
     CPU_POWERPC_e500v2_v10         = 0x80210010,      CPU_POWERPC_e500v2_v10         = 0x80210010,
     CPU_POWERPC_e500v2_v11         = 0x80210011,      CPU_POWERPC_e500v2_v11         = 0x80210011,
     CPU_POWERPC_e500v2_v20         = 0x80210020,      CPU_POWERPC_e500v2_v20         = 0x80210020,
Line 6640  enum { Line 6742  enum {
 #define CPU_POWERPC_MPC8533E_v10     CPU_POWERPC_e500v2_v21  #define CPU_POWERPC_MPC8533E_v10     CPU_POWERPC_e500v2_v21
 #define CPU_POWERPC_MPC8533E_v11     CPU_POWERPC_e500v2_v22  #define CPU_POWERPC_MPC8533E_v11     CPU_POWERPC_e500v2_v22
 #define CPU_POWERPC_MPC8540          CPU_POWERPC_MPC8540_v21  #define CPU_POWERPC_MPC8540          CPU_POWERPC_MPC8540_v21
 #define CPU_POWERPC_MPC8540_v10      CPU_POWERPC_e500_v10  #define CPU_POWERPC_MPC8540_v10      CPU_POWERPC_e500v1_v10
 #define CPU_POWERPC_MPC8540_v20      CPU_POWERPC_e500_v20  #define CPU_POWERPC_MPC8540_v20      CPU_POWERPC_e500v1_v20
 #define CPU_POWERPC_MPC8540_v21      CPU_POWERPC_e500_v20  #define CPU_POWERPC_MPC8540_v21      CPU_POWERPC_e500v1_v20
 #define CPU_POWERPC_MPC8541          CPU_POWERPC_MPC8541_v11  #define CPU_POWERPC_MPC8541          CPU_POWERPC_MPC8541_v11
 #define CPU_POWERPC_MPC8541_v10      CPU_POWERPC_e500_v20  #define CPU_POWERPC_MPC8541_v10      CPU_POWERPC_e500v1_v20
 #define CPU_POWERPC_MPC8541_v11      CPU_POWERPC_e500_v20  #define CPU_POWERPC_MPC8541_v11      CPU_POWERPC_e500v1_v20
 #define CPU_POWERPC_MPC8541E         CPU_POWERPC_MPC8541E_v11  #define CPU_POWERPC_MPC8541E         CPU_POWERPC_MPC8541E_v11
 #define CPU_POWERPC_MPC8541E_v10     CPU_POWERPC_e500_v20  #define CPU_POWERPC_MPC8541E_v10     CPU_POWERPC_e500v1_v20
 #define CPU_POWERPC_MPC8541E_v11     CPU_POWERPC_e500_v20  #define CPU_POWERPC_MPC8541E_v11     CPU_POWERPC_e500v1_v20
 #define CPU_POWERPC_MPC8543          CPU_POWERPC_MPC8543_v21  #define CPU_POWERPC_MPC8543          CPU_POWERPC_MPC8543_v21
 #define CPU_POWERPC_MPC8543_v10      CPU_POWERPC_e500v2_v10  #define CPU_POWERPC_MPC8543_v10      CPU_POWERPC_e500v2_v10
 #define CPU_POWERPC_MPC8543_v11      CPU_POWERPC_e500v2_v11  #define CPU_POWERPC_MPC8543_v11      CPU_POWERPC_e500v2_v11
Line 7975  static const ppc_def_t ppc_defs[] = { Line 8077  static const ppc_def_t ppc_defs[] = {
                     CPU_POWERPC_MPC8379E,     POWERPC_SVR_8379E,     e300),                      CPU_POWERPC_MPC8379E,     POWERPC_SVR_8379E,     e300),
     /* e500 family                                                           */      /* e500 family                                                           */
     /* PowerPC e500 core                                                     */      /* PowerPC e500 core                                                     */
     POWERPC_DEF("e500",          CPU_POWERPC_e500,                   e500),      POWERPC_DEF("e500",          CPU_POWERPC_e500v2_v22,             e500v2),
       /* PowerPC e500v1 core                                                   */
       POWERPC_DEF("e500v1",        CPU_POWERPC_e500v1,                 e500v1),
     /* PowerPC e500 v1.0 core                                                */      /* PowerPC e500 v1.0 core                                                */
     POWERPC_DEF("e500_v10",      CPU_POWERPC_e500_v10,               e500),      POWERPC_DEF("e500_v10",      CPU_POWERPC_e500v1_v10,             e500v1),
     /* PowerPC e500 v2.0 core                                                */      /* PowerPC e500 v2.0 core                                                */
     POWERPC_DEF("e500_v20",      CPU_POWERPC_e500_v20,               e500),      POWERPC_DEF("e500_v20",      CPU_POWERPC_e500v1_v20,             e500v1),
     /* PowerPC e500v2 core                                                   */      /* PowerPC e500v2 core                                                   */
     POWERPC_DEF("e500v2",        CPU_POWERPC_e500v2,                 e500),      POWERPC_DEF("e500v2",        CPU_POWERPC_e500v2,                 e500v2),
     /* PowerPC e500v2 v1.0 core                                              */      /* PowerPC e500v2 v1.0 core                                              */
     POWERPC_DEF("e500v2_v10",    CPU_POWERPC_e500v2_v10,             e500),      POWERPC_DEF("e500v2_v10",    CPU_POWERPC_e500v2_v10,             e500v2),
     /* PowerPC e500v2 v2.0 core                                              */      /* PowerPC e500v2 v2.0 core                                              */
     POWERPC_DEF("e500v2_v20",    CPU_POWERPC_e500v2_v20,             e500),      POWERPC_DEF("e500v2_v20",    CPU_POWERPC_e500v2_v20,             e500v2),
     /* PowerPC e500v2 v2.1 core                                              */      /* PowerPC e500v2 v2.1 core                                              */
     POWERPC_DEF("e500v2_v21",    CPU_POWERPC_e500v2_v21,             e500),      POWERPC_DEF("e500v2_v21",    CPU_POWERPC_e500v2_v21,             e500v2),
     /* PowerPC e500v2 v2.2 core                                              */      /* PowerPC e500v2 v2.2 core                                              */
     POWERPC_DEF("e500v2_v22",    CPU_POWERPC_e500v2_v22,             e500),      POWERPC_DEF("e500v2_v22",    CPU_POWERPC_e500v2_v22,             e500v2),
     /* PowerPC e500v2 v3.0 core                                              */      /* PowerPC e500v2 v3.0 core                                              */
     POWERPC_DEF("e500v2_v30",    CPU_POWERPC_e500v2_v30,             e500),      POWERPC_DEF("e500v2_v30",    CPU_POWERPC_e500v2_v30,             e500v2),
     /* PowerPC e500 microcontrollers                                         */      /* PowerPC e500 microcontrollers                                         */
     /* MPC8533                                                               */      /* MPC8533                                                               */
     POWERPC_DEF_SVR("MPC8533",      POWERPC_DEF_SVR("MPC8533",
                     CPU_POWERPC_MPC8533,      POWERPC_SVR_8533,      e500),                      CPU_POWERPC_MPC8533,      POWERPC_SVR_8533,      e500v2),
     /* MPC8533 v1.0                                                          */      /* MPC8533 v1.0                                                          */
     POWERPC_DEF_SVR("MPC8533_v10",      POWERPC_DEF_SVR("MPC8533_v10",
                     CPU_POWERPC_MPC8533_v10,  POWERPC_SVR_8533_v10,  e500),                      CPU_POWERPC_MPC8533_v10,  POWERPC_SVR_8533_v10,  e500v2),
     /* MPC8533 v1.1                                                          */      /* MPC8533 v1.1                                                          */
     POWERPC_DEF_SVR("MPC8533_v11",      POWERPC_DEF_SVR("MPC8533_v11",
                     CPU_POWERPC_MPC8533_v11,  POWERPC_SVR_8533_v11,  e500),                      CPU_POWERPC_MPC8533_v11,  POWERPC_SVR_8533_v11,  e500v2),
     /* MPC8533E                                                              */      /* MPC8533E                                                              */
     POWERPC_DEF_SVR("MPC8533E",      POWERPC_DEF_SVR("MPC8533E",
                     CPU_POWERPC_MPC8533E,     POWERPC_SVR_8533E,     e500),                      CPU_POWERPC_MPC8533E,     POWERPC_SVR_8533E,     e500v2),
     /* MPC8533E v1.0                                                         */      /* MPC8533E v1.0                                                         */
     POWERPC_DEF_SVR("MPC8533E_v10",      POWERPC_DEF_SVR("MPC8533E_v10",
                     CPU_POWERPC_MPC8533E_v10, POWERPC_SVR_8533E_v10, e500),                      CPU_POWERPC_MPC8533E_v10, POWERPC_SVR_8533E_v10, e500v2),
     POWERPC_DEF_SVR("MPC8533E_v11",      POWERPC_DEF_SVR("MPC8533E_v11",
                     CPU_POWERPC_MPC8533E_v11, POWERPC_SVR_8533E_v11, e500),                      CPU_POWERPC_MPC8533E_v11, POWERPC_SVR_8533E_v11, e500v2),
     /* MPC8540                                                               */      /* MPC8540                                                               */
     POWERPC_DEF_SVR("MPC8540",      POWERPC_DEF_SVR("MPC8540",
                     CPU_POWERPC_MPC8540,      POWERPC_SVR_8540,      e500),                      CPU_POWERPC_MPC8540,      POWERPC_SVR_8540,      e500v1),
     /* MPC8540 v1.0                                                          */      /* MPC8540 v1.0                                                          */
     POWERPC_DEF_SVR("MPC8540_v10",      POWERPC_DEF_SVR("MPC8540_v10",
                     CPU_POWERPC_MPC8540_v10,  POWERPC_SVR_8540_v10,  e500),                      CPU_POWERPC_MPC8540_v10,  POWERPC_SVR_8540_v10,  e500v1),
     /* MPC8540 v2.0                                                          */      /* MPC8540 v2.0                                                          */
     POWERPC_DEF_SVR("MPC8540_v20",      POWERPC_DEF_SVR("MPC8540_v20",
                     CPU_POWERPC_MPC8540_v20,  POWERPC_SVR_8540_v20,  e500),                      CPU_POWERPC_MPC8540_v20,  POWERPC_SVR_8540_v20,  e500v1),
     /* MPC8540 v2.1                                                          */      /* MPC8540 v2.1                                                          */
     POWERPC_DEF_SVR("MPC8540_v21",      POWERPC_DEF_SVR("MPC8540_v21",
                     CPU_POWERPC_MPC8540_v21,  POWERPC_SVR_8540_v21,  e500),                      CPU_POWERPC_MPC8540_v21,  POWERPC_SVR_8540_v21,  e500v1),
     /* MPC8541                                                               */      /* MPC8541                                                               */
     POWERPC_DEF_SVR("MPC8541",      POWERPC_DEF_SVR("MPC8541",
                     CPU_POWERPC_MPC8541,      POWERPC_SVR_8541,      e500),                      CPU_POWERPC_MPC8541,      POWERPC_SVR_8541,      e500v1),
     /* MPC8541 v1.0                                                          */      /* MPC8541 v1.0                                                          */
     POWERPC_DEF_SVR("MPC8541_v10",      POWERPC_DEF_SVR("MPC8541_v10",
                     CPU_POWERPC_MPC8541_v10,  POWERPC_SVR_8541_v10,  e500),                      CPU_POWERPC_MPC8541_v10,  POWERPC_SVR_8541_v10,  e500v1),
     /* MPC8541 v1.1                                                          */      /* MPC8541 v1.1                                                          */
     POWERPC_DEF_SVR("MPC8541_v11",      POWERPC_DEF_SVR("MPC8541_v11",
                     CPU_POWERPC_MPC8541_v11,  POWERPC_SVR_8541_v11,  e500),                      CPU_POWERPC_MPC8541_v11,  POWERPC_SVR_8541_v11,  e500v1),
     /* MPC8541E                                                              */      /* MPC8541E                                                              */
     POWERPC_DEF_SVR("MPC8541E",      POWERPC_DEF_SVR("MPC8541E",
                     CPU_POWERPC_MPC8541E,     POWERPC_SVR_8541E,     e500),                      CPU_POWERPC_MPC8541E,     POWERPC_SVR_8541E,     e500v1),
     /* MPC8541E v1.0                                                         */      /* MPC8541E v1.0                                                         */
     POWERPC_DEF_SVR("MPC8541E_v10",      POWERPC_DEF_SVR("MPC8541E_v10",
                     CPU_POWERPC_MPC8541E_v10, POWERPC_SVR_8541E_v10, e500),                      CPU_POWERPC_MPC8541E_v10, POWERPC_SVR_8541E_v10, e500v1),
     /* MPC8541E v1.1                                                         */      /* MPC8541E v1.1                                                         */
     POWERPC_DEF_SVR("MPC8541E_v11",      POWERPC_DEF_SVR("MPC8541E_v11",
                     CPU_POWERPC_MPC8541E_v11, POWERPC_SVR_8541E_v11, e500),                      CPU_POWERPC_MPC8541E_v11, POWERPC_SVR_8541E_v11, e500v1),
     /* MPC8543                                                               */      /* MPC8543                                                               */
     POWERPC_DEF_SVR("MPC8543",      POWERPC_DEF_SVR("MPC8543",
                     CPU_POWERPC_MPC8543,      POWERPC_SVR_8543,      e500),                      CPU_POWERPC_MPC8543,      POWERPC_SVR_8543,      e500v2),
     /* MPC8543 v1.0                                                          */      /* MPC8543 v1.0                                                          */
     POWERPC_DEF_SVR("MPC8543_v10",      POWERPC_DEF_SVR("MPC8543_v10",
                     CPU_POWERPC_MPC8543_v10,  POWERPC_SVR_8543_v10,  e500),                      CPU_POWERPC_MPC8543_v10,  POWERPC_SVR_8543_v10,  e500v2),
     /* MPC8543 v1.1                                                          */      /* MPC8543 v1.1                                                          */
     POWERPC_DEF_SVR("MPC8543_v11",      POWERPC_DEF_SVR("MPC8543_v11",
                     CPU_POWERPC_MPC8543_v11,  POWERPC_SVR_8543_v11,  e500),                      CPU_POWERPC_MPC8543_v11,  POWERPC_SVR_8543_v11,  e500v2),
     /* MPC8543 v2.0                                                          */      /* MPC8543 v2.0                                                          */
     POWERPC_DEF_SVR("MPC8543_v20",      POWERPC_DEF_SVR("MPC8543_v20",
                     CPU_POWERPC_MPC8543_v20,  POWERPC_SVR_8543_v20,  e500),                      CPU_POWERPC_MPC8543_v20,  POWERPC_SVR_8543_v20,  e500v2),
     /* MPC8543 v2.1                                                          */      /* MPC8543 v2.1                                                          */
     POWERPC_DEF_SVR("MPC8543_v21",      POWERPC_DEF_SVR("MPC8543_v21",
                     CPU_POWERPC_MPC8543_v21,  POWERPC_SVR_8543_v21,  e500),                      CPU_POWERPC_MPC8543_v21,  POWERPC_SVR_8543_v21,  e500v2),
     /* MPC8543E                                                              */      /* MPC8543E                                                              */
     POWERPC_DEF_SVR("MPC8543E",      POWERPC_DEF_SVR("MPC8543E",
                     CPU_POWERPC_MPC8543E,     POWERPC_SVR_8543E,     e500),                      CPU_POWERPC_MPC8543E,     POWERPC_SVR_8543E,     e500v2),
     /* MPC8543E v1.0                                                         */      /* MPC8543E v1.0                                                         */
     POWERPC_DEF_SVR("MPC8543E_v10",      POWERPC_DEF_SVR("MPC8543E_v10",
                     CPU_POWERPC_MPC8543E_v10, POWERPC_SVR_8543E_v10, e500),                      CPU_POWERPC_MPC8543E_v10, POWERPC_SVR_8543E_v10, e500v2),
     /* MPC8543E v1.1                                                         */      /* MPC8543E v1.1                                                         */
     POWERPC_DEF_SVR("MPC8543E_v11",      POWERPC_DEF_SVR("MPC8543E_v11",
                     CPU_POWERPC_MPC8543E_v11, POWERPC_SVR_8543E_v11, e500),                      CPU_POWERPC_MPC8543E_v11, POWERPC_SVR_8543E_v11, e500v2),
     /* MPC8543E v2.0                                                         */      /* MPC8543E v2.0                                                         */
     POWERPC_DEF_SVR("MPC8543E_v20",      POWERPC_DEF_SVR("MPC8543E_v20",
                     CPU_POWERPC_MPC8543E_v20, POWERPC_SVR_8543E_v20, e500),                      CPU_POWERPC_MPC8543E_v20, POWERPC_SVR_8543E_v20, e500v2),
     /* MPC8543E v2.1                                                         */      /* MPC8543E v2.1                                                         */
     POWERPC_DEF_SVR("MPC8543E_v21",      POWERPC_DEF_SVR("MPC8543E_v21",
                     CPU_POWERPC_MPC8543E_v21, POWERPC_SVR_8543E_v21, e500),                      CPU_POWERPC_MPC8543E_v21, POWERPC_SVR_8543E_v21, e500v2),
     /* MPC8544                                                               */      /* MPC8544                                                               */
     POWERPC_DEF_SVR("MPC8544",      POWERPC_DEF_SVR("MPC8544",
                     CPU_POWERPC_MPC8544,      POWERPC_SVR_8544,      e500),                      CPU_POWERPC_MPC8544,      POWERPC_SVR_8544,      e500v2),
     /* MPC8544 v1.0                                                          */      /* MPC8544 v1.0                                                          */
     POWERPC_DEF_SVR("MPC8544_v10",      POWERPC_DEF_SVR("MPC8544_v10",
                     CPU_POWERPC_MPC8544_v10,  POWERPC_SVR_8544_v10,  e500),                      CPU_POWERPC_MPC8544_v10,  POWERPC_SVR_8544_v10,  e500v2),
     /* MPC8544 v1.1                                                          */      /* MPC8544 v1.1                                                          */
     POWERPC_DEF_SVR("MPC8544_v11",      POWERPC_DEF_SVR("MPC8544_v11",
                     CPU_POWERPC_MPC8544_v11,  POWERPC_SVR_8544_v11,  e500),                      CPU_POWERPC_MPC8544_v11,  POWERPC_SVR_8544_v11,  e500v2),
     /* MPC8544E                                                              */      /* MPC8544E                                                              */
     POWERPC_DEF_SVR("MPC8544E",      POWERPC_DEF_SVR("MPC8544E",
                     CPU_POWERPC_MPC8544E,     POWERPC_SVR_8544E,     e500),                      CPU_POWERPC_MPC8544E,     POWERPC_SVR_8544E,     e500v2),
     /* MPC8544E v1.0                                                         */      /* MPC8544E v1.0                                                         */
     POWERPC_DEF_SVR("MPC8544E_v10",      POWERPC_DEF_SVR("MPC8544E_v10",
                     CPU_POWERPC_MPC8544E_v10, POWERPC_SVR_8544E_v10, e500),                      CPU_POWERPC_MPC8544E_v10, POWERPC_SVR_8544E_v10, e500v2),
     /* MPC8544E v1.1                                                         */      /* MPC8544E v1.1                                                         */
     POWERPC_DEF_SVR("MPC8544E_v11",      POWERPC_DEF_SVR("MPC8544E_v11",
                     CPU_POWERPC_MPC8544E_v11, POWERPC_SVR_8544E_v11, e500),                      CPU_POWERPC_MPC8544E_v11, POWERPC_SVR_8544E_v11, e500v2),
     /* MPC8545                                                               */      /* MPC8545                                                               */
     POWERPC_DEF_SVR("MPC8545",      POWERPC_DEF_SVR("MPC8545",
                     CPU_POWERPC_MPC8545,      POWERPC_SVR_8545,      e500),                      CPU_POWERPC_MPC8545,      POWERPC_SVR_8545,      e500v2),
     /* MPC8545 v2.0                                                          */      /* MPC8545 v2.0                                                          */
     POWERPC_DEF_SVR("MPC8545_v20",      POWERPC_DEF_SVR("MPC8545_v20",
                     CPU_POWERPC_MPC8545_v20,  POWERPC_SVR_8545_v20,  e500),                      CPU_POWERPC_MPC8545_v20,  POWERPC_SVR_8545_v20,  e500v2),
     /* MPC8545 v2.1                                                          */      /* MPC8545 v2.1                                                          */
     POWERPC_DEF_SVR("MPC8545_v21",      POWERPC_DEF_SVR("MPC8545_v21",
                     CPU_POWERPC_MPC8545_v21,  POWERPC_SVR_8545_v21,  e500),                      CPU_POWERPC_MPC8545_v21,  POWERPC_SVR_8545_v21,  e500v2),
     /* MPC8545E                                                              */      /* MPC8545E                                                              */
     POWERPC_DEF_SVR("MPC8545E",      POWERPC_DEF_SVR("MPC8545E",
                     CPU_POWERPC_MPC8545E,     POWERPC_SVR_8545E,     e500),                      CPU_POWERPC_MPC8545E,     POWERPC_SVR_8545E,     e500v2),
     /* MPC8545E v2.0                                                         */      /* MPC8545E v2.0                                                         */
     POWERPC_DEF_SVR("MPC8545E_v20",      POWERPC_DEF_SVR("MPC8545E_v20",
                     CPU_POWERPC_MPC8545E_v20, POWERPC_SVR_8545E_v20, e500),                      CPU_POWERPC_MPC8545E_v20, POWERPC_SVR_8545E_v20, e500v2),
     /* MPC8545E v2.1                                                         */      /* MPC8545E v2.1                                                         */
     POWERPC_DEF_SVR("MPC8545E_v21",      POWERPC_DEF_SVR("MPC8545E_v21",
                     CPU_POWERPC_MPC8545E_v21, POWERPC_SVR_8545E_v21, e500),                      CPU_POWERPC_MPC8545E_v21, POWERPC_SVR_8545E_v21, e500v2),
     /* MPC8547E                                                              */      /* MPC8547E                                                              */
     POWERPC_DEF_SVR("MPC8547E",      POWERPC_DEF_SVR("MPC8547E",
                     CPU_POWERPC_MPC8547E,     POWERPC_SVR_8547E,     e500),                      CPU_POWERPC_MPC8547E,     POWERPC_SVR_8547E,     e500v2),
     /* MPC8547E v2.0                                                         */      /* MPC8547E v2.0                                                         */
     POWERPC_DEF_SVR("MPC8547E_v20",      POWERPC_DEF_SVR("MPC8547E_v20",
                     CPU_POWERPC_MPC8547E_v20, POWERPC_SVR_8547E_v20, e500),                      CPU_POWERPC_MPC8547E_v20, POWERPC_SVR_8547E_v20, e500v2),
     /* MPC8547E v2.1                                                         */      /* MPC8547E v2.1                                                         */
     POWERPC_DEF_SVR("MPC8547E_v21",      POWERPC_DEF_SVR("MPC8547E_v21",
                     CPU_POWERPC_MPC8547E_v21, POWERPC_SVR_8547E_v21, e500),                      CPU_POWERPC_MPC8547E_v21, POWERPC_SVR_8547E_v21, e500v2),
     /* MPC8548                                                               */      /* MPC8548                                                               */
     POWERPC_DEF_SVR("MPC8548",      POWERPC_DEF_SVR("MPC8548",
                     CPU_POWERPC_MPC8548,      POWERPC_SVR_8548,      e500),                      CPU_POWERPC_MPC8548,      POWERPC_SVR_8548,      e500v2),
     /* MPC8548 v1.0                                                          */      /* MPC8548 v1.0                                                          */
     POWERPC_DEF_SVR("MPC8548_v10",      POWERPC_DEF_SVR("MPC8548_v10",
                     CPU_POWERPC_MPC8548_v10,  POWERPC_SVR_8548_v10,  e500),                      CPU_POWERPC_MPC8548_v10,  POWERPC_SVR_8548_v10,  e500v2),
     /* MPC8548 v1.1                                                          */      /* MPC8548 v1.1                                                          */
     POWERPC_DEF_SVR("MPC8548_v11",      POWERPC_DEF_SVR("MPC8548_v11",
                     CPU_POWERPC_MPC8548_v11,  POWERPC_SVR_8548_v11,  e500),                      CPU_POWERPC_MPC8548_v11,  POWERPC_SVR_8548_v11,  e500v2),
     /* MPC8548 v2.0                                                          */      /* MPC8548 v2.0                                                          */
     POWERPC_DEF_SVR("MPC8548_v20",      POWERPC_DEF_SVR("MPC8548_v20",
                     CPU_POWERPC_MPC8548_v20,  POWERPC_SVR_8548_v20,  e500),                      CPU_POWERPC_MPC8548_v20,  POWERPC_SVR_8548_v20,  e500v2),
     /* MPC8548 v2.1                                                          */      /* MPC8548 v2.1                                                          */
     POWERPC_DEF_SVR("MPC8548_v21",      POWERPC_DEF_SVR("MPC8548_v21",
                     CPU_POWERPC_MPC8548_v21,  POWERPC_SVR_8548_v21,  e500),                      CPU_POWERPC_MPC8548_v21,  POWERPC_SVR_8548_v21,  e500v2),
     /* MPC8548E                                                              */      /* MPC8548E                                                              */
     POWERPC_DEF_SVR("MPC8548E",      POWERPC_DEF_SVR("MPC8548E",
                     CPU_POWERPC_MPC8548E,     POWERPC_SVR_8548E,     e500),                      CPU_POWERPC_MPC8548E,     POWERPC_SVR_8548E,     e500v2),
     /* MPC8548E v1.0                                                         */      /* MPC8548E v1.0                                                         */
     POWERPC_DEF_SVR("MPC8548E_v10",      POWERPC_DEF_SVR("MPC8548E_v10",
                     CPU_POWERPC_MPC8548E_v10, POWERPC_SVR_8548E_v10, e500),                      CPU_POWERPC_MPC8548E_v10, POWERPC_SVR_8548E_v10, e500v2),
     /* MPC8548E v1.1                                                         */      /* MPC8548E v1.1                                                         */
     POWERPC_DEF_SVR("MPC8548E_v11",      POWERPC_DEF_SVR("MPC8548E_v11",
                     CPU_POWERPC_MPC8548E_v11, POWERPC_SVR_8548E_v11, e500),                      CPU_POWERPC_MPC8548E_v11, POWERPC_SVR_8548E_v11, e500v2),
     /* MPC8548E v2.0                                                         */      /* MPC8548E v2.0                                                         */
     POWERPC_DEF_SVR("MPC8548E_v20",      POWERPC_DEF_SVR("MPC8548E_v20",
                     CPU_POWERPC_MPC8548E_v20, POWERPC_SVR_8548E_v20, e500),                      CPU_POWERPC_MPC8548E_v20, POWERPC_SVR_8548E_v20, e500v2),
     /* MPC8548E v2.1                                                         */      /* MPC8548E v2.1                                                         */
     POWERPC_DEF_SVR("MPC8548E_v21",      POWERPC_DEF_SVR("MPC8548E_v21",
                     CPU_POWERPC_MPC8548E_v21, POWERPC_SVR_8548E_v21, e500),                      CPU_POWERPC_MPC8548E_v21, POWERPC_SVR_8548E_v21, e500v2),
     /* MPC8555                                                               */      /* MPC8555                                                               */
     POWERPC_DEF_SVR("MPC8555",      POWERPC_DEF_SVR("MPC8555",
                     CPU_POWERPC_MPC8555,      POWERPC_SVR_8555,      e500),                      CPU_POWERPC_MPC8555,      POWERPC_SVR_8555,      e500v2),
     /* MPC8555 v1.0                                                          */      /* MPC8555 v1.0                                                          */
     POWERPC_DEF_SVR("MPC8555_v10",      POWERPC_DEF_SVR("MPC8555_v10",
                     CPU_POWERPC_MPC8555_v10,  POWERPC_SVR_8555_v10,  e500),                      CPU_POWERPC_MPC8555_v10,  POWERPC_SVR_8555_v10,  e500v2),
     /* MPC8555 v1.1                                                          */      /* MPC8555 v1.1                                                          */
     POWERPC_DEF_SVR("MPC8555_v11",      POWERPC_DEF_SVR("MPC8555_v11",
                     CPU_POWERPC_MPC8555_v11,  POWERPC_SVR_8555_v11,  e500),                      CPU_POWERPC_MPC8555_v11,  POWERPC_SVR_8555_v11,  e500v2),
     /* MPC8555E                                                              */      /* MPC8555E                                                              */
     POWERPC_DEF_SVR("MPC8555E",      POWERPC_DEF_SVR("MPC8555E",
                     CPU_POWERPC_MPC8555E,     POWERPC_SVR_8555E,     e500),                      CPU_POWERPC_MPC8555E,     POWERPC_SVR_8555E,     e500v2),
     /* MPC8555E v1.0                                                         */      /* MPC8555E v1.0                                                         */
     POWERPC_DEF_SVR("MPC8555E_v10",      POWERPC_DEF_SVR("MPC8555E_v10",
                     CPU_POWERPC_MPC8555E_v10, POWERPC_SVR_8555E_v10, e500),                      CPU_POWERPC_MPC8555E_v10, POWERPC_SVR_8555E_v10, e500v2),
     /* MPC8555E v1.1                                                         */      /* MPC8555E v1.1                                                         */
     POWERPC_DEF_SVR("MPC8555E_v11",      POWERPC_DEF_SVR("MPC8555E_v11",
                     CPU_POWERPC_MPC8555E_v11, POWERPC_SVR_8555E_v11, e500),                      CPU_POWERPC_MPC8555E_v11, POWERPC_SVR_8555E_v11, e500v2),
     /* MPC8560                                                               */      /* MPC8560                                                               */
     POWERPC_DEF_SVR("MPC8560",      POWERPC_DEF_SVR("MPC8560",
                     CPU_POWERPC_MPC8560,      POWERPC_SVR_8560,      e500),                      CPU_POWERPC_MPC8560,      POWERPC_SVR_8560,      e500v2),
     /* MPC8560 v1.0                                                          */      /* MPC8560 v1.0                                                          */
     POWERPC_DEF_SVR("MPC8560_v10",      POWERPC_DEF_SVR("MPC8560_v10",
                     CPU_POWERPC_MPC8560_v10,  POWERPC_SVR_8560_v10,  e500),                      CPU_POWERPC_MPC8560_v10,  POWERPC_SVR_8560_v10,  e500v2),
     /* MPC8560 v2.0                                                          */      /* MPC8560 v2.0                                                          */
     POWERPC_DEF_SVR("MPC8560_v20",      POWERPC_DEF_SVR("MPC8560_v20",
                     CPU_POWERPC_MPC8560_v20,  POWERPC_SVR_8560_v20,  e500),                      CPU_POWERPC_MPC8560_v20,  POWERPC_SVR_8560_v20,  e500v2),
     /* MPC8560 v2.1                                                          */      /* MPC8560 v2.1                                                          */
     POWERPC_DEF_SVR("MPC8560_v21",      POWERPC_DEF_SVR("MPC8560_v21",
                     CPU_POWERPC_MPC8560_v21,  POWERPC_SVR_8560_v21,  e500),                      CPU_POWERPC_MPC8560_v21,  POWERPC_SVR_8560_v21,  e500v2),
     /* MPC8567                                                               */      /* MPC8567                                                               */
     POWERPC_DEF_SVR("MPC8567",      POWERPC_DEF_SVR("MPC8567",
                     CPU_POWERPC_MPC8567,      POWERPC_SVR_8567,      e500),                      CPU_POWERPC_MPC8567,      POWERPC_SVR_8567,      e500v2),
     /* MPC8567E                                                              */      /* MPC8567E                                                              */
     POWERPC_DEF_SVR("MPC8567E",      POWERPC_DEF_SVR("MPC8567E",
                     CPU_POWERPC_MPC8567E,     POWERPC_SVR_8567E,     e500),                      CPU_POWERPC_MPC8567E,     POWERPC_SVR_8567E,     e500v2),
     /* MPC8568                                                               */      /* MPC8568                                                               */
     POWERPC_DEF_SVR("MPC8568",      POWERPC_DEF_SVR("MPC8568",
                     CPU_POWERPC_MPC8568,      POWERPC_SVR_8568,      e500),                      CPU_POWERPC_MPC8568,      POWERPC_SVR_8568,      e500v2),
     /* MPC8568E                                                              */      /* MPC8568E                                                              */
     POWERPC_DEF_SVR("MPC8568E",      POWERPC_DEF_SVR("MPC8568E",
                     CPU_POWERPC_MPC8568E,     POWERPC_SVR_8568E,     e500),                      CPU_POWERPC_MPC8568E,     POWERPC_SVR_8568E,     e500v2),
     /* MPC8572                                                               */      /* MPC8572                                                               */
     POWERPC_DEF_SVR("MPC8572",      POWERPC_DEF_SVR("MPC8572",
                     CPU_POWERPC_MPC8572,      POWERPC_SVR_8572,      e500),                      CPU_POWERPC_MPC8572,      POWERPC_SVR_8572,      e500v2),
     /* MPC8572E                                                              */      /* MPC8572E                                                              */
     POWERPC_DEF_SVR("MPC8572E",      POWERPC_DEF_SVR("MPC8572E",
                     CPU_POWERPC_MPC8572E,     POWERPC_SVR_8572E,     e500),                      CPU_POWERPC_MPC8572E,     POWERPC_SVR_8572E,     e500v2),
     /* e600 family                                                           */      /* e600 family                                                           */
     /* PowerPC e600 core                                                     */      /* PowerPC e600 core                                                     */
     POWERPC_DEF("e600",          CPU_POWERPC_e600,                   7400),      POWERPC_DEF("e600",          CPU_POWERPC_e600,                   7400),
Line 8941  static void dump_ppc_sprs (CPUPPCState * Line 9045  static void dump_ppc_sprs (CPUPPCState *
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   
 int fflush (FILE *stream);  
   
 /* Opcode types */  /* Opcode types */
 enum {  enum {
     PPC_DIRECT   = 0, /* Opcode routine        */      PPC_DIRECT   = 0, /* Opcode routine        */
Line 8974  static int create_new_table (opc_handler Line 9076  static int create_new_table (opc_handler
     opc_handler_t **tmp;      opc_handler_t **tmp;
   
     tmp = malloc(0x20 * sizeof(opc_handler_t));      tmp = malloc(0x20 * sizeof(opc_handler_t));
     if (tmp == NULL)  
         return -1;  
     fill_new_table(tmp, 0x20);      fill_new_table(tmp, 0x20);
     table[idx] = (opc_handler_t *)((unsigned long)tmp | PPC_INDIRECT);      table[idx] = (opc_handler_t *)((unsigned long)tmp | PPC_INDIRECT);
   
Line 9159  static int create_ppc_opcodes (CPUPPCSta Line 9259  static int create_ppc_opcodes (CPUPPCSta
 static void dump_ppc_insns (CPUPPCState *env)  static void dump_ppc_insns (CPUPPCState *env)
 {  {
     opc_handler_t **table, *handler;      opc_handler_t **table, *handler;
     const unsigned char *p, *q;      const char *p, *q;
     uint8_t opc1, opc2, opc3;      uint8_t opc1, opc2, opc3;
   
     printf("Instructions set:\n");      printf("Instructions set:\n");
Line 9228  static void dump_ppc_insns (CPUPPCState  Line 9328  static void dump_ppc_insns (CPUPPCState 
 }  }
 #endif  #endif
   
   static int gdb_get_float_reg(CPUState *env, uint8_t *mem_buf, int n)
   {
       if (n < 32) {
           stfq_p(mem_buf, env->fpr[n]);
           return 8;
       }
       if (n == 32) {
           /* FPSCR not implemented  */
           memset(mem_buf, 0, 4);
           return 4;
       }
       return 0;
   }
   
   static int gdb_set_float_reg(CPUState *env, uint8_t *mem_buf, int n)
   {
       if (n < 32) {
           env->fpr[n] = ldfq_p(mem_buf);
           return 8;
       }
       if (n == 32) {
           /* FPSCR not implemented  */
           return 4;
       }
       return 0;
   }
   
   static int gdb_get_avr_reg(CPUState *env, uint8_t *mem_buf, int n)
   {
       if (n < 32) {
   #ifdef WORDS_BIGENDIAN
           stq_p(mem_buf, env->avr[n].u64[0]);
           stq_p(mem_buf+8, env->avr[n].u64[1]);
   #else
           stq_p(mem_buf, env->avr[n].u64[1]);
           stq_p(mem_buf+8, env->avr[n].u64[0]);
   #endif
           return 16;
       }
       if (n == 33) {
           stl_p(mem_buf, env->vscr);
           return 4;
       }
       if (n == 34) {
           stl_p(mem_buf, (uint32_t)env->spr[SPR_VRSAVE]);
           return 4;
       }
       return 0;
   }
   
   static int gdb_set_avr_reg(CPUState *env, uint8_t *mem_buf, int n)
   {
       if (n < 32) {
   #ifdef WORDS_BIGENDIAN
           env->avr[n].u64[0] = ldq_p(mem_buf);
           env->avr[n].u64[1] = ldq_p(mem_buf+8);
   #else
           env->avr[n].u64[1] = ldq_p(mem_buf);
           env->avr[n].u64[0] = ldq_p(mem_buf+8);
   #endif
           return 16;
       }
       if (n == 33) {
           env->vscr = ldl_p(mem_buf);
           return 4;
       }
       if (n == 34) {
           env->spr[SPR_VRSAVE] = (target_ulong)ldl_p(mem_buf);
           return 4;
       }
       return 0;
   }
   
   static int gdb_get_spe_reg(CPUState *env, uint8_t *mem_buf, int n)
   {
       if (n < 32) {
   #if defined(TARGET_PPC64)
           stl_p(mem_buf, env->gpr[n] >> 32);
   #else
           stl_p(mem_buf, env->gprh[n]);
   #endif
           return 4;
       }
       if (n == 33) {
           stq_p(mem_buf, env->spe_acc);
           return 8;
       }
       if (n == 34) {
           /* SPEFSCR not implemented */
           memset(mem_buf, 0, 4);
           return 4;
       }
       return 0;
   }
   
   static int gdb_set_spe_reg(CPUState *env, uint8_t *mem_buf, int n)
   {
       if (n < 32) {
   #if defined(TARGET_PPC64)
           target_ulong lo = (uint32_t)env->gpr[n];
           target_ulong hi = (target_ulong)ldl_p(mem_buf) << 32;
           env->gpr[n] = lo | hi;
   #else
           env->gprh[n] = ldl_p(mem_buf);
   #endif
           return 4;
       }
       if (n == 33) {
           env->spe_acc = ldq_p(mem_buf);
           return 8;
       }
       if (n == 34) {
           /* SPEFSCR not implemented */
           return 4;
       }
       return 0;
   }
   
 int cpu_ppc_register_internal (CPUPPCState *env, const ppc_def_t *def)  int cpu_ppc_register_internal (CPUPPCState *env, const ppc_def_t *def)
 {  {
     env->msr_mask = def->msr_mask;      env->msr_mask = def->msr_mask;
Line 9240  int cpu_ppc_register_internal (CPUPPCSta Line 9458  int cpu_ppc_register_internal (CPUPPCSta
     if (create_ppc_opcodes(env, def) < 0)      if (create_ppc_opcodes(env, def) < 0)
         return -1;          return -1;
     init_ppc_proc(env, def);      init_ppc_proc(env, def);
   
       if (def->insns_flags & PPC_FLOAT) {
           gdb_register_coprocessor(env, gdb_get_float_reg, gdb_set_float_reg,
                                    33, "power-fpu.xml", 0);
       }
       if (def->insns_flags & PPC_ALTIVEC) {
           gdb_register_coprocessor(env, gdb_get_avr_reg, gdb_set_avr_reg,
                                    34, "power-altivec.xml", 0);
       }
       if (def->insns_flags & PPC_SPE) {
           gdb_register_coprocessor(env, gdb_get_spe_reg, gdb_set_spe_reg,
                                    34, "power-spe.xml", 0);
       }
   
 #if defined(PPC_DUMP_CPU)  #if defined(PPC_DUMP_CPU)
     {      {
         const unsigned char *mmu_model, *excp_model, *bus_model;          const char *mmu_model, *excp_model, *bus_model;
         switch (env->mmu_model) {          switch (env->mmu_model) {
         case POWERPC_MMU_32B:          case POWERPC_MMU_32B:
             mmu_model = "PowerPC 32";              mmu_model = "PowerPC 32";
Line 9412  static const ppc_def_t *ppc_find_by_pvr  Line 9644  static const ppc_def_t *ppc_find_by_pvr 
     int i, best, match, best_match, max;      int i, best, match, best_match, max;
   
     ret = NULL;      ret = NULL;
     max = sizeof(ppc_defs) / sizeof(ppc_def_t);      max = ARRAY_SIZE(ppc_defs);
     best = -1;      best = -1;
     pvr_rev = pvr & 0xFFFF;      pvr_rev = pvr & 0xFFFF;
     /* We want all specified bits to match */      /* We want all specified bits to match */
Line 9445  static const ppc_def_t *ppc_find_by_pvr  Line 9677  static const ppc_def_t *ppc_find_by_pvr 
   
 #include <ctype.h>  #include <ctype.h>
   
 const ppc_def_t *cpu_ppc_find_by_name (const unsigned char *name)  const ppc_def_t *cpu_ppc_find_by_name (const char *name)
 {  {
     const ppc_def_t *ret;      const ppc_def_t *ret;
     const unsigned char *p;      const char *p;
     int i, max, len;      int i, max, len;
   
     /* Check if the given name is a PVR */      /* Check if the given name is a PVR */
Line 9460  const ppc_def_t *cpu_ppc_find_by_name (c Line 9692  const ppc_def_t *cpu_ppc_find_by_name (c
         p = name;          p = name;
     check_pvr:      check_pvr:
         for (i = 0; i < 8; i++) {          for (i = 0; i < 8; i++) {
             if (!isxdigit(*p++))              if (!qemu_isxdigit(*p++))
                 break;                  break;
         }          }
         if (i == 8)          if (i == 8)
             return ppc_find_by_pvr(strtoul(name, NULL, 16));              return ppc_find_by_pvr(strtoul(name, NULL, 16));
     }      }
     ret = NULL;      ret = NULL;
     max = sizeof(ppc_defs) / sizeof(ppc_def_t);      max = ARRAY_SIZE(ppc_defs);
     for (i = 0; i < max; i++) {      for (i = 0; i < max; i++) {
         if (strcasecmp(name, ppc_defs[i].name) == 0) {          if (strcasecmp(name, ppc_defs[i].name) == 0) {
             ret = &ppc_defs[i];              ret = &ppc_defs[i];
Line 9482  void ppc_cpu_list (FILE *f, int (*cpu_fp Line 9714  void ppc_cpu_list (FILE *f, int (*cpu_fp
 {  {
     int i, max;      int i, max;
   
     max = sizeof(ppc_defs) / sizeof(ppc_def_t);      max = ARRAY_SIZE(ppc_defs);
     for (i = 0; i < max; i++) {      for (i = 0; i < max; i++) {
         (*cpu_fprintf)(f, "PowerPC %-16s PVR %08x\n",          (*cpu_fprintf)(f, "PowerPC %-16s PVR %08x\n",
                        ppc_defs[i].name, ppc_defs[i].pvr);                         ppc_defs[i].name, ppc_defs[i].pvr);

Removed from v.1.1.1.4  
changed lines
  Added in v.1.1.1.5


unix.superglobalmegacorp.com