Diff for /qemu/target-ppc/translate_init.c between versions 1.1.1.11 and 1.1.1.12

version 1.1.1.11, 2018/04/24 19:30:53 version 1.1.1.12, 2018/04/24 19:51:29
Line 2 Line 2
  *  PowerPC CPU initialization for qemu.   *  PowerPC CPU initialization for qemu.
  *   *
  *  Copyright (c) 2003-2007 Jocelyn Mayer   *  Copyright (c) 2003-2007 Jocelyn Mayer
    *  Copyright 2011 Freescale Semiconductor, Inc.
  *   *
  * 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 267  static void spr_read_purr (void *opaque, Line 268  static void spr_read_purr (void *opaque,
 /* IBAT0L...IBAT7L */  /* IBAT0L...IBAT7L */
 static void spr_read_ibat (void *opaque, int gprn, int sprn)  static void spr_read_ibat (void *opaque, int gprn, int sprn)
 {  {
     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
 }  }
   
 static void spr_read_ibat_h (void *opaque, int gprn, int sprn)  static void spr_read_ibat_h (void *opaque, int gprn, int sprn)
 {  {
     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, IBAT[sprn & 1][(sprn - SPR_IBAT4U) / 2]));      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, IBAT[sprn & 1][(sprn - SPR_IBAT4U) / 2]));
 }  }
   
 static void spr_write_ibatu (void *opaque, int sprn, int gprn)  static void spr_write_ibatu (void *opaque, int sprn, int gprn)
Line 307  static void spr_write_ibatl_h (void *opa Line 308  static void spr_write_ibatl_h (void *opa
 /* DBAT0L...DBAT7L */  /* DBAT0L...DBAT7L */
 static void spr_read_dbat (void *opaque, int gprn, int sprn)  static void spr_read_dbat (void *opaque, int gprn, int sprn)
 {  {
     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, DBAT[sprn & 1][(sprn - SPR_DBAT0U) / 2]));      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, DBAT[sprn & 1][(sprn - SPR_DBAT0U) / 2]));
 }  }
   
 static void spr_read_dbat_h (void *opaque, int gprn, int sprn)  static void spr_read_dbat_h (void *opaque, int gprn, int sprn)
 {  {
     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, DBAT[sprn & 1][((sprn - SPR_DBAT4U) / 2) + 4]));      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, DBAT[sprn & 1][((sprn - SPR_DBAT4U) / 2) + 4]));
 }  }
   
 static void spr_write_dbatu (void *opaque, int sprn, int gprn)  static void spr_write_dbatu (void *opaque, int sprn, int gprn)
Line 354  static void spr_write_sdr1 (void *opaque Line 355  static void spr_write_sdr1 (void *opaque
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 static void spr_read_hior (void *opaque, int gprn, 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));      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, excp_prefix));
 }  }
   
 static void spr_write_hior (void *opaque, int sprn, int gprn)  static void spr_write_hior (void *opaque, int sprn, int gprn)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
     tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0x3FFFFF00000ULL);      tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0x3FFFFF00000ULL);
     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, excp_prefix));      tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_prefix));
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static void spr_read_asr (void *opaque, int gprn, int sprn)  static void spr_read_asr (void *opaque, int gprn, int sprn)
 {  {
     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, asr));      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, asr));
 }  }
   
 static void spr_write_asr (void *opaque, int sprn, int gprn)  static void spr_write_asr (void *opaque, int sprn, int gprn)
Line 414  static void spr_write_hid0_601 (void *op Line 415  static void spr_write_hid0_601 (void *op
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
 static void spr_read_601_ubat (void *opaque, int gprn, int sprn)  static void spr_read_601_ubat (void *opaque, int gprn, int sprn)
 {  {
     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
 }  }
   
 static void spr_write_601_ubatu (void *opaque, int sprn, int gprn)  static void spr_write_601_ubatu (void *opaque, int sprn, int gprn)
Line 474  static void spr_write_booke_tsr (void *o Line 475  static void spr_write_booke_tsr (void *o
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
 static void spr_read_403_pbr (void *opaque, int gprn, int sprn)  static void spr_read_403_pbr (void *opaque, int gprn, int sprn)
 {  {
     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, pb[sprn - SPR_403_PBL1]));      tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, pb[sprn - SPR_403_PBL1]));
 }  }
   
 static void spr_write_403_pbr (void *opaque, int sprn, int gprn)  static void spr_write_403_pbr (void *opaque, int sprn, int gprn)
Line 497  static void spr_write_pir (void *opaque, Line 498  static void spr_write_pir (void *opaque,
 static void spr_read_spefscr (void *opaque, int gprn, int sprn)  static void spr_read_spefscr (void *opaque, int gprn, int sprn)
 {  {
     TCGv_i32 t0 = tcg_temp_new_i32();      TCGv_i32 t0 = tcg_temp_new_i32();
     tcg_gen_ld_i32(t0, cpu_env, offsetof(CPUState, spe_fscr));      tcg_gen_ld_i32(t0, cpu_env, offsetof(CPUPPCState, spe_fscr));
     tcg_gen_extu_i32_tl(cpu_gpr[gprn], t0);      tcg_gen_extu_i32_tl(cpu_gpr[gprn], t0);
     tcg_temp_free_i32(t0);      tcg_temp_free_i32(t0);
 }  }
Line 506  static void spr_write_spefscr (void *opa Line 507  static void spr_write_spefscr (void *opa
 {  {
     TCGv_i32 t0 = tcg_temp_new_i32();      TCGv_i32 t0 = tcg_temp_new_i32();
     tcg_gen_trunc_tl_i32(t0, cpu_gpr[gprn]);      tcg_gen_trunc_tl_i32(t0, cpu_gpr[gprn]);
     tcg_gen_st_i32(t0, cpu_env, offsetof(CPUState, spe_fscr));      tcg_gen_st_i32(t0, cpu_env, offsetof(CPUPPCState, spe_fscr));
     tcg_temp_free_i32(t0);      tcg_temp_free_i32(t0);
 }  }
   
Line 515  static void spr_write_spefscr (void *opa Line 516  static void spr_write_spefscr (void *opa
 static void spr_write_excp_prefix (void *opaque, int sprn, int gprn)  static void spr_write_excp_prefix (void *opaque, int sprn, int gprn)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
     tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, ivpr_mask));      tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUPPCState, ivpr_mask));
     tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);      tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, excp_prefix));      tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_prefix));
     gen_store_spr(sprn, t0);      gen_store_spr(sprn, t0);
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
Line 525  static void spr_write_excp_prefix (void  Line 526  static void spr_write_excp_prefix (void 
 static void spr_write_excp_vector (void *opaque, int sprn, int gprn)  static void spr_write_excp_vector (void *opaque, int sprn, int gprn)
 {  {
     DisasContext *ctx = opaque;      DisasContext *ctx = opaque;
       int sprn_offs;
   
     if (sprn >= SPR_BOOKE_IVOR0 && sprn <= SPR_BOOKE_IVOR15) {      if (sprn >= SPR_BOOKE_IVOR0 && sprn <= SPR_BOOKE_IVOR15) {
         TCGv t0 = tcg_temp_new();          sprn_offs = sprn - SPR_BOOKE_IVOR0;
         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) {
         TCGv t0 = tcg_temp_new();          sprn_offs = sprn - SPR_BOOKE_IVOR32 + 32;
         tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, ivor_mask));      } else if (sprn >= SPR_BOOKE_IVOR38 && sprn <= SPR_BOOKE_IVOR42) {
         tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);          sprn_offs = sprn - SPR_BOOKE_IVOR38 + 38;
         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_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);          gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
           return;
     }      }
   
       TCGv t0 = tcg_temp_new();
       tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUPPCState, ivor_mask));
       tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
       tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_vectors[sprn_offs]));
       gen_store_spr(sprn, t0);
       tcg_temp_free(t0);
 }  }
 #endif  #endif
   
Line 1433  static void gen_spr_BookE (CPUPPCState * Line 1435  static void gen_spr_BookE (CPUPPCState *
         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_IVOR32, SPR_BOOKE_IVOR33, SPR_BOOKE_IVOR34, SPR_BOOKE_IVOR35,
         SPR_BOOKE_IVOR36, SPR_BOOKE_IVOR37, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,          SPR_BOOKE_IVOR36, SPR_BOOKE_IVOR37, SPR_BOOKE_IVOR38, SPR_BOOKE_IVOR39,
         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,          SPR_BOOKE_IVOR40, SPR_BOOKE_IVOR41, SPR_BOOKE_IVOR42, 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,
Line 1794  static void gen_spr_440 (CPUPPCState *en Line 1796  static void gen_spr_440 (CPUPPCState *en
 static void gen_spr_40x (CPUPPCState *env)  static void gen_spr_40x (CPUPPCState *env)
 {  {
     /* Cache */      /* Cache */
     /* not emulated, as Qemu do not emulate caches */      /* not emulated, as QEMU do not emulate caches */
     spr_register(env, SPR_40x_DCCR, "DCCR",      spr_register(env, SPR_40x_DCCR, "DCCR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   0x00000000);
     /* not emulated, as Qemu do not emulate caches */      /* not emulated, as QEMU do not emulate caches */
     spr_register(env, SPR_40x_ICCR, "ICCR",      spr_register(env, SPR_40x_ICCR, "ICCR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   0x00000000);
     /* not emulated, as Qemu do not emulate caches */      /* not emulated, as QEMU do not emulate caches */
     spr_register(env, SPR_BOOKE_ICDBDR, "ICDBDR",      spr_register(env, SPR_BOOKE_ICDBDR, "ICDBDR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, SPR_NOACCESS,                   &spr_read_generic, SPR_NOACCESS,
Line 1972  static void gen_spr_401_403 (CPUPPCState Line 1974  static void gen_spr_401_403 (CPUPPCState
                  SPR_NOACCESS, &spr_write_tbu,                   SPR_NOACCESS, &spr_write_tbu,
                  0x00000000);                   0x00000000);
     /* Debug */      /* Debug */
     /* not emulated, as Qemu do not emulate caches */      /* not emulated, as QEMU do not emulate caches */
     spr_register(env, SPR_403_CDBCR, "CDBCR",      spr_register(env, SPR_403_CDBCR, "CDBCR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
Line 2010  static void gen_spr_401 (CPUPPCState *en Line 2012  static void gen_spr_401 (CPUPPCState *en
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_40x_sler,                   &spr_read_generic, &spr_write_40x_sler,
                  0x00000000);                   0x00000000);
     /* not emulated, as Qemu never does speculative access */      /* not emulated, as QEMU never does speculative access */
     spr_register(env, SPR_40x_SGR, "SGR",      spr_register(env, SPR_40x_SGR, "SGR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0xFFFFFFFF);                   0xFFFFFFFF);
     /* not emulated, as Qemu do not emulate caches */      /* not emulated, as QEMU do not emulate caches */
     spr_register(env, SPR_40x_DCWR, "DCWR",      spr_register(env, SPR_40x_DCWR, "DCWR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
Line 3434  static void init_proc_403GCX (CPUPPCStat Line 3436  static void init_proc_403GCX (CPUPPCStat
     gen_spr_403_real(env);      gen_spr_403_real(env);
     gen_spr_403_mmu(env);      gen_spr_403_mmu(env);
     /* Bus access control */      /* Bus access control */
     /* not emulated, as Qemu never does speculative access */      /* not emulated, as QEMU never does speculative access */
     spr_register(env, SPR_40x_SGR, "SGR",      spr_register(env, SPR_40x_SGR, "SGR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0xFFFFFFFF);                   0xFFFFFFFF);
     /* not emulated, as Qemu do not emulate caches */      /* not emulated, as QEMU do not emulate caches */
     spr_register(env, SPR_40x_DCWR, "DCWR",      spr_register(env, SPR_40x_DCWR, "DCWR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
Line 3486  static void init_proc_405 (CPUPPCState * Line 3488  static void init_proc_405 (CPUPPCState *
     gen_spr_40x(env);      gen_spr_40x(env);
     gen_spr_405(env);      gen_spr_405(env);
     /* Bus access control */      /* Bus access control */
     /* not emulated, as Qemu never does speculative access */      /* not emulated, as QEMU never does speculative access */
     spr_register(env, SPR_40x_SGR, "SGR",      spr_register(env, SPR_40x_SGR, "SGR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0xFFFFFFFF);                   0xFFFFFFFF);
     /* not emulated, as Qemu do not emulate caches */      /* not emulated, as QEMU do not emulate caches */
     spr_register(env, SPR_40x_DCWR, "DCWR",      spr_register(env, SPR_40x_DCWR, "DCWR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
Line 3515  static void init_proc_405 (CPUPPCState * Line 3517  static void init_proc_405 (CPUPPCState *
   
 /* PowerPC 440 EP                                                            */  /* PowerPC 440 EP                                                            */
 #define POWERPC_INSNS_440EP  (PPC_INSNS_BASE | PPC_STRING |                   \  #define POWERPC_INSNS_440EP  (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_WRTEE | PPC_RFMCI |               \                                PPC_DCR | PPC_WRTEE | PPC_RFMCI |               \
                               PPC_CACHE | PPC_CACHE_ICBI |                    \                                PPC_CACHE | PPC_CACHE_ICBI |                    \
                               PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \                                PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
Line 3522  static void init_proc_405 (CPUPPCState * Line 3527  static void init_proc_405 (CPUPPCState *
                               PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |      \                                PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |      \
                               PPC_440_SPEC)                                PPC_440_SPEC)
 #define POWERPC_INSNS2_440EP (PPC_NONE)  #define POWERPC_INSNS2_440EP (PPC_NONE)
 #define POWERPC_MSRM_440EP   (0x000000000006D630ULL)  #define POWERPC_MSRM_440EP   (0x000000000006FF30ULL)
 #define POWERPC_MMU_440EP    (POWERPC_MMU_BOOKE)  #define POWERPC_MMU_440EP    (POWERPC_MMU_BOOKE)
 #define POWERPC_EXCP_440EP   (POWERPC_EXCP_BOOKE)  #define POWERPC_EXCP_440EP   (POWERPC_EXCP_BOOKE)
 #define POWERPC_INPUT_440EP  (PPC_FLAGS_INPUT_BookE)  #define POWERPC_INPUT_440EP  (PPC_FLAGS_INPUT_BookE)
Line 3531  static void init_proc_405 (CPUPPCState * Line 3536  static void init_proc_405 (CPUPPCState *
                               POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)                                POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
 #define check_pow_440EP      check_pow_nocheck  #define check_pow_440EP      check_pow_nocheck
   
 __attribute__ (( unused ))  
 static void init_proc_440EP (CPUPPCState *env)  static void init_proc_440EP (CPUPPCState *env)
 {  {
     /* Time base */      /* Time base */
Line 3592  static void init_proc_440EP (CPUPPCState Line 3596  static void init_proc_440EP (CPUPPCState
     init_excp_BookE(env);      init_excp_BookE(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 */      ppc40x_irq_init(env);
   
     SET_FIT_PERIOD(12, 16, 20, 24);      SET_FIT_PERIOD(12, 16, 20, 24);
     SET_WDT_PERIOD(20, 24, 28, 32);      SET_WDT_PERIOD(20, 24, 28, 32);
Line 4367  static void init_proc_e300 (CPUPPCState  Line 4371  static void init_proc_e300 (CPUPPCState 
                                 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_MEM_SYNC)
 #define POWERPC_INSNS2_e500v1  (PPC2_BOOKE206)  #define POWERPC_INSNS2_e500v1  (PPC2_BOOKE206)
 #define POWERPC_MSRM_e500v1    (0x000000000606FF30ULL)  #define POWERPC_MSRM_e500v1    (0x000000000606FF30ULL)
 #define POWERPC_MMU_e500v1     (POWERPC_MMU_BOOKE206)  #define POWERPC_MMU_e500v1     (POWERPC_MMU_BOOKE206)
Line 4386  static void init_proc_e300 (CPUPPCState  Line 4390  static void init_proc_e300 (CPUPPCState 
                                 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_MEM_SYNC)
 #define POWERPC_INSNS2_e500v2  (PPC2_BOOKE206)  #define POWERPC_INSNS2_e500v2  (PPC2_BOOKE206)
 #define POWERPC_MSRM_e500v2    (0x000000000606FF30ULL)  #define POWERPC_MSRM_e500v2    (0x000000000606FF30ULL)
 #define POWERPC_MMU_e500v2     (POWERPC_MMU_BOOKE206)  #define POWERPC_MMU_e500v2     (POWERPC_MMU_BOOKE206)
Line 4399  static void init_proc_e300 (CPUPPCState  Line 4403  static void init_proc_e300 (CPUPPCState 
 #define check_pow_e500v2       check_pow_hid0  #define check_pow_e500v2       check_pow_hid0
 #define init_proc_e500v2       init_proc_e500v2  #define init_proc_e500v2       init_proc_e500v2
   
   /* e500mc core                                                               */
   #define POWERPC_INSNS_e500mc   (PPC_INSNS_BASE | PPC_ISEL |                 \
                                   PPC_WRTEE | PPC_RFDI | PPC_RFMCI |          \
                                   PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI | \
                                   PPC_CACHE_DCBZ | PPC_CACHE_DCBA |           \
                                   PPC_FLOAT | PPC_FLOAT_FRES |                \
                                   PPC_FLOAT_FRSQRTE | PPC_FLOAT_FSEL |        \
                                   PPC_FLOAT_STFIWX | PPC_WAIT |               \
                                   PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC)
   #define POWERPC_INSNS2_e500mc  (PPC2_BOOKE206 | PPC2_PRCNTL)
   #define POWERPC_MSRM_e500mc    (0x000000001402FB36ULL)
   #define POWERPC_MMU_e500mc     (POWERPC_MMU_BOOKE206)
   #define POWERPC_EXCP_e500mc    (POWERPC_EXCP_BOOKE)
   #define POWERPC_INPUT_e500mc   (PPC_FLAGS_INPUT_BookE)
   /* Fixme: figure out the correct flag for e500mc */
   #define POWERPC_BFDM_e500mc    (bfd_mach_ppc_e500)
   #define POWERPC_FLAG_e500mc    (POWERPC_FLAG_CE | POWERPC_FLAG_DE | \
                                   POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
   #define check_pow_e500mc       check_pow_none
   #define init_proc_e500mc       init_proc_e500mc
   
   enum fsl_e500_version {
       fsl_e500v1,
       fsl_e500v2,
       fsl_e500mc,
   };
   
 static void init_proc_e500 (CPUPPCState *env, int version)  static void init_proc_e500 (CPUPPCState *env, int version)
 {  {
     uint32_t tlbncfg[2];      uint32_t tlbncfg[2];
       uint64_t ivor_mask = 0x0000000F0000FFFFULL;
       uint32_t l1cfg0 = 0x3800  /* 8 ways */
                       | 0x0020; /* 32 kb */
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
     int i;      int i;
 #endif  #endif
Line 4413  static void init_proc_e500 (CPUPPCState  Line 4447  static void init_proc_e500 (CPUPPCState 
      *     complain when accessing them.       *     complain when accessing them.
      * gen_spr_BookE(env, 0x0000000F0000FD7FULL);       * gen_spr_BookE(env, 0x0000000F0000FD7FULL);
      */       */
     gen_spr_BookE(env, 0x0000000F0000FFFFULL);      if (version == fsl_e500mc) {
           ivor_mask = 0x000003FE0000FFFFULL;
       }
       gen_spr_BookE(env, ivor_mask);
     /* Processor identification */      /* Processor identification */
     spr_register(env, SPR_BOOKE_PIR, "PIR",      spr_register(env, SPR_BOOKE_PIR, "PIR",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
Line 4424  static void init_proc_e500 (CPUPPCState  Line 4461  static void init_proc_e500 (CPUPPCState 
                  &spr_read_spefscr, &spr_write_spefscr,                   &spr_read_spefscr, &spr_write_spefscr,
                  &spr_read_spefscr, &spr_write_spefscr,                   &spr_read_spefscr, &spr_write_spefscr,
                  0x00000000);                   0x00000000);
     /* Memory management */  
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
       /* Memory management */
     env->nb_pids = 3;      env->nb_pids = 3;
     env->nb_ways = 2;      env->nb_ways = 2;
     env->id_tlbs = 0;      env->id_tlbs = 0;
     switch (version) {      switch (version) {
     case 1:      case fsl_e500v1:
         /* e500v1 */  
         tlbncfg[0] = gen_tlbncfg(2, 1, 1, 0, 256);          tlbncfg[0] = gen_tlbncfg(2, 1, 1, 0, 256);
         tlbncfg[1] = gen_tlbncfg(16, 1, 9, TLBnCFG_AVAIL | TLBnCFG_IPROT, 16);          tlbncfg[1] = gen_tlbncfg(16, 1, 9, TLBnCFG_AVAIL | TLBnCFG_IPROT, 16);
         break;          break;
     case 2:      case fsl_e500v2:
         /* e500v2 */  
         tlbncfg[0] = gen_tlbncfg(4, 1, 1, 0, 512);          tlbncfg[0] = gen_tlbncfg(4, 1, 1, 0, 512);
         tlbncfg[1] = gen_tlbncfg(16, 1, 12, TLBnCFG_AVAIL | TLBnCFG_IPROT, 16);          tlbncfg[1] = gen_tlbncfg(16, 1, 12, TLBnCFG_AVAIL | TLBnCFG_IPROT, 16);
         break;          break;
       case fsl_e500mc:
           tlbncfg[0] = gen_tlbncfg(4, 1, 1, 0, 512);
           tlbncfg[1] = gen_tlbncfg(64, 1, 12, TLBnCFG_AVAIL | TLBnCFG_IPROT, 64);
           break;
     default:      default:
         cpu_abort(env, "Unknown CPU: " TARGET_FMT_lx "\n", env->spr[SPR_PVR]);          cpu_abort(env, "Unknown CPU: " TARGET_FMT_lx "\n", env->spr[SPR_PVR]);
     }      }
 #endif  #endif
       /* Cache sizes */
       switch (version) {
       case fsl_e500v1:
       case fsl_e500v2:
           env->dcache_line_size = 32;
           env->icache_line_size = 32;
           break;
       case fsl_e500mc:
           env->dcache_line_size = 64;
           env->icache_line_size = 64;
           l1cfg0 |= 0x1000000; /* 64 byte cache block size */
           break;
       default:
           cpu_abort(env, "Unknown CPU: " TARGET_FMT_lx "\n", env->spr[SPR_PVR]);
       }
     gen_spr_BookE206(env, 0x000000DF, tlbncfg);      gen_spr_BookE206(env, 0x000000DF, tlbncfg);
     /* XXX : not implemented */      /* XXX : not implemented */
     spr_register(env, SPR_HID0, "HID0",      spr_register(env, SPR_HID0, "HID0",
Line 4489  static void init_proc_e500 (CPUPPCState  Line 4543  static void init_proc_e500 (CPUPPCState 
     spr_register(env, SPR_Exxx_L1CFG0, "L1CFG0",      spr_register(env, SPR_Exxx_L1CFG0, "L1CFG0",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
                  &spr_read_generic, &spr_write_generic,                   &spr_read_generic, &spr_write_generic,
                  0x00000000);                   l1cfg0);
     /* XXX : not implemented */      /* XXX : not implemented */
     spr_register(env, SPR_Exxx_L1CSR0, "L1CSR0",      spr_register(env, SPR_Exxx_L1CSR0, "L1CSR0",
                  SPR_NOACCESS, SPR_NOACCESS,                   SPR_NOACCESS, SPR_NOACCESS,
Line 4522  static void init_proc_e500 (CPUPPCState  Line 4576  static void init_proc_e500 (CPUPPCState 
 #endif  #endif
   
     init_excp_e200(env);      init_excp_e200(env);
     env->dcache_line_size = 32;  
     env->icache_line_size = 32;  
     /* Allocate hardware IRQ controller */      /* Allocate hardware IRQ controller */
     ppce500_irq_init(env);      ppce500_irq_init(env);
 }  }
   
 static void init_proc_e500v1(CPUPPCState *env)  static void init_proc_e500v1(CPUPPCState *env)
 {  {
     init_proc_e500(env, 1);      init_proc_e500(env, fsl_e500v1);
 }  }
   
 static void init_proc_e500v2(CPUPPCState *env)  static void init_proc_e500v2(CPUPPCState *env)
 {  {
     init_proc_e500(env, 2);      init_proc_e500(env, fsl_e500v2);
   }
   
   static void init_proc_e500mc(CPUPPCState *env)
   {
       init_proc_e500(env, fsl_e500mc);
 }  }
   
 /* Non-embedded PowerPC                                                      */  /* Non-embedded PowerPC                                                      */
Line 6519  static void init_proc_970MP (CPUPPCState Line 6576  static void init_proc_970MP (CPUPPCState
                               PPC_64B | PPC_ALTIVEC |                         \                                PPC_64B | PPC_ALTIVEC |                         \
                               PPC_SEGMENT_64B | PPC_SLBI |                    \                                PPC_SEGMENT_64B | PPC_SLBI |                    \
                               PPC_POPCNTB | PPC_POPCNTWD)                                PPC_POPCNTB | PPC_POPCNTWD)
 #define POWERPC_INSNS2_POWER7 (PPC2_VSX | PPC2_DFP)  #define POWERPC_INSNS2_POWER7 (PPC2_VSX | PPC2_DFP | PPC2_DBRX)
 #define POWERPC_MSRM_POWER7   (0x800000000204FF36ULL)  #define POWERPC_MSRM_POWER7   (0x800000000204FF36ULL)
 #define POWERPC_MMU_POWER7    (POWERPC_MMU_2_06)  #define POWERPC_MMU_POWER7    (POWERPC_MMU_2_06)
 #define POWERPC_EXCP_POWER7   (POWERPC_EXCP_POWER7)  #define POWERPC_EXCP_POWER7   (POWERPC_EXCP_POWER7)
Line 6536  static void init_proc_POWER7 (CPUPPCStat Line 6593  static void init_proc_POWER7 (CPUPPCStat
     gen_spr_7xx(env);      gen_spr_7xx(env);
     /* Time base */      /* Time base */
     gen_tbl(env);      gen_tbl(env);
       /* Processor identification */
       spr_register(env, SPR_PIR, "PIR",
                    SPR_NOACCESS, SPR_NOACCESS,
                    &spr_read_generic, &spr_write_pir,
                    0x00000000);
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
     /* PURR & SPURR: Hack - treat these as aliases for the TB for now */      /* PURR & SPURR: Hack - treat these as aliases for the TB for now */
     spr_register(env, SPR_PURR,   "PURR",      spr_register(env, SPR_PURR,   "PURR",
Line 6661  static void init_proc_620 (CPUPPCState * Line 6723  static void init_proc_620 (CPUPPCState *
 #if defined (TARGET_PPC64) && 0 // XXX: TODO  #if defined (TARGET_PPC64) && 0 // XXX: TODO
 #define CPU_POWERPC_DEFAULT    CPU_POWERPC_PPC64  #define CPU_POWERPC_DEFAULT    CPU_POWERPC_PPC64
 #define POWERPC_INSNS_DEFAULT  POWERPC_INSNS_PPC64  #define POWERPC_INSNS_DEFAULT  POWERPC_INSNS_PPC64
 #define POWERPC_INSNS2_DEFAULT POWERPC_INSNS_PPC64  #define POWERPC_INSNS2_DEFAULT POWERPC_INSNS2_PPC64
 #define POWERPC_MSRM_DEFAULT   POWERPC_MSRM_PPC64  #define POWERPC_MSRM_DEFAULT   POWERPC_MSRM_PPC64
 #define POWERPC_MMU_DEFAULT    POWERPC_MMU_PPC64  #define POWERPC_MMU_DEFAULT    POWERPC_MMU_PPC64
 #define POWERPC_EXCP_DEFAULT   POWERPC_EXCP_PPC64  #define POWERPC_EXCP_DEFAULT   POWERPC_EXCP_PPC64
Line 6673  static void init_proc_620 (CPUPPCState * Line 6735  static void init_proc_620 (CPUPPCState *
 #else  #else
 #define CPU_POWERPC_DEFAULT    CPU_POWERPC_PPC32  #define CPU_POWERPC_DEFAULT    CPU_POWERPC_PPC32
 #define POWERPC_INSNS_DEFAULT  POWERPC_INSNS_PPC32  #define POWERPC_INSNS_DEFAULT  POWERPC_INSNS_PPC32
 #define POWERPC_INSNS2_DEFAULT POWERPC_INSNS_PPC32  #define POWERPC_INSNS2_DEFAULT POWERPC_INSNS2_PPC32
 #define POWERPC_MSRM_DEFAULT   POWERPC_MSRM_PPC32  #define POWERPC_MSRM_DEFAULT   POWERPC_MSRM_PPC32
 #define POWERPC_MMU_DEFAULT    POWERPC_MMU_PPC32  #define POWERPC_MMU_DEFAULT    POWERPC_MMU_PPC32
 #define POWERPC_EXCP_DEFAULT   POWERPC_EXCP_PPC32  #define POWERPC_EXCP_DEFAULT   POWERPC_EXCP_PPC32
Line 7070  enum { Line 7132  enum {
     CPU_POWERPC_e500v2_v21         = 0x80210021,      CPU_POWERPC_e500v2_v21         = 0x80210021,
     CPU_POWERPC_e500v2_v22         = 0x80210022,      CPU_POWERPC_e500v2_v22         = 0x80210022,
     CPU_POWERPC_e500v2_v30         = 0x80210030,      CPU_POWERPC_e500v2_v30         = 0x80210030,
       CPU_POWERPC_e500mc             = 0x80230020,
     /* MPC85xx microcontrollers */      /* MPC85xx microcontrollers */
 #define CPU_POWERPC_MPC8533          CPU_POWERPC_MPC8533_v11  #define CPU_POWERPC_MPC8533          CPU_POWERPC_MPC8533_v11
 #define CPU_POWERPC_MPC8533_v10      CPU_POWERPC_e500v2_v21  #define CPU_POWERPC_MPC8533_v10      CPU_POWERPC_e500v2_v21
Line 7826  static const ppc_def_t ppc_defs[] = { Line 7889  static const ppc_def_t ppc_defs[] = {
     POWERPC_DEF("440H6",         CPU_POWERPC_440H6,                  440Gx5),      POWERPC_DEF("440H6",         CPU_POWERPC_440H6,                  440Gx5),
 #endif  #endif
     /* PowerPC 440 microcontrolers                                           */      /* PowerPC 440 microcontrolers                                           */
 #if defined(TODO_USER_ONLY)  
     /* PowerPC 440 EP                                                        */      /* PowerPC 440 EP                                                        */
     POWERPC_DEF("440EP",         CPU_POWERPC_440EP,                  440EP),      POWERPC_DEF("440EP",         CPU_POWERPC_440EP,                  440EP),
 #endif  
 #if defined(TODO_USER_ONLY)  
     /* PowerPC 440 EPa                                                       */      /* PowerPC 440 EPa                                                       */
     POWERPC_DEF("440EPa",        CPU_POWERPC_440EPa,                 440EP),      POWERPC_DEF("440EPa",        CPU_POWERPC_440EPa,                 440EP),
 #endif  
 #if defined(TODO_USER_ONLY)  
     /* PowerPC 440 EPb                                                       */      /* PowerPC 440 EPb                                                       */
     POWERPC_DEF("440EPb",        CPU_POWERPC_440EPb,                 440EP),      POWERPC_DEF("440EPb",        CPU_POWERPC_440EPb,                 440EP),
 #endif  
 #if defined(TODO_USER_ONLY)  
     /* PowerPC 440 EPX                                                       */      /* PowerPC 440 EPX                                                       */
     POWERPC_DEF("440EPX",        CPU_POWERPC_440EPX,                 440EP),      POWERPC_DEF("440EPX",        CPU_POWERPC_440EPX,                 440EP),
 #endif  
 #if defined(TODO_USER_ONLY)  #if defined(TODO_USER_ONLY)
     /* PowerPC 440 GP                                                        */      /* PowerPC 440 GP                                                        */
     POWERPC_DEF("440GP",         CPU_POWERPC_440GP,                  440GP),      POWERPC_DEF("440GP",         CPU_POWERPC_440GP,                  440GP),
Line 8471  static const ppc_def_t ppc_defs[] = { Line 8526  static const ppc_def_t ppc_defs[] = {
     POWERPC_DEF("e500v2_v22",    CPU_POWERPC_e500v2_v22,             e500v2),      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,             e500v2),      POWERPC_DEF("e500v2_v30",    CPU_POWERPC_e500v2_v30,             e500v2),
       POWERPC_DEF("e500mc",        CPU_POWERPC_e500mc,                 e500mc),
     /* PowerPC e500 microcontrollers                                         */      /* PowerPC e500 microcontrollers                                         */
     /* MPC8533                                                               */      /* MPC8533                                                               */
     POWERPC_DEF_SVR("MPC8533",      POWERPC_DEF_SVR("MPC8533",
Line 9391  static void init_ppc_proc (CPUPPCState * Line 9447  static void init_ppc_proc (CPUPPCState *
     }      }
     if (env->irq_inputs == NULL) {      if (env->irq_inputs == NULL) {
         fprintf(stderr, "WARNING: no internal IRQ controller registered.\n"          fprintf(stderr, "WARNING: no internal IRQ controller registered.\n"
                 " Attempt Qemu to crash very soon !\n");                  " Attempt QEMU to crash very soon !\n");
     }      }
 #endif  #endif
     if (env->check_pow == NULL) {      if (env->check_pow == NULL) {
         fprintf(stderr, "WARNING: no power management check handler "          fprintf(stderr, "WARNING: no power management check handler "
                 "registered.\n"                  "registered.\n"
                 " Attempt Qemu to crash very soon !\n");                  " Attempt QEMU to crash very soon !\n");
     }      }
 }  }
   
Line 9453  enum { Line 9509  enum {
   
 static inline int is_indirect_opcode (void *handler)  static inline int is_indirect_opcode (void *handler)
 {  {
     return ((unsigned long)handler & 0x03) == PPC_INDIRECT;      return ((uintptr_t)handler & 0x03) == PPC_INDIRECT;
 }  }
   
 static inline opc_handler_t **ind_table(void *handler)  static inline opc_handler_t **ind_table(void *handler)
 {  {
     return (opc_handler_t **)((unsigned long)handler & ~3);      return (opc_handler_t **)((uintptr_t)handler & ~3);
 }  }
   
 /* Instruction table creation */  /* Instruction table creation */
Line 9477  static int create_new_table (opc_handler Line 9533  static int create_new_table (opc_handler
   
     tmp = malloc(0x20 * sizeof(opc_handler_t));      tmp = malloc(0x20 * sizeof(opc_handler_t));
     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 *)((uintptr_t)tmp | PPC_INDIRECT);
   
     return 0;      return 0;
 }  }
Line 9722  static void dump_ppc_insns (CPUPPCState  Line 9778  static void dump_ppc_insns (CPUPPCState 
 }  }
 #endif  #endif
   
 static int gdb_get_float_reg(CPUState *env, uint8_t *mem_buf, int n)  static int gdb_get_float_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
 {  {
     if (n < 32) {      if (n < 32) {
         stfq_p(mem_buf, env->fpr[n]);          stfq_p(mem_buf, env->fpr[n]);
Line 9735  static int gdb_get_float_reg(CPUState *e Line 9791  static int gdb_get_float_reg(CPUState *e
     return 0;      return 0;
 }  }
   
 static int gdb_set_float_reg(CPUState *env, uint8_t *mem_buf, int n)  static int gdb_set_float_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
 {  {
     if (n < 32) {      if (n < 32) {
         env->fpr[n] = ldfq_p(mem_buf);          env->fpr[n] = ldfq_p(mem_buf);
Line 9748  static int gdb_set_float_reg(CPUState *e Line 9804  static int gdb_set_float_reg(CPUState *e
     return 0;      return 0;
 }  }
   
 static int gdb_get_avr_reg(CPUState *env, uint8_t *mem_buf, int n)  static int gdb_get_avr_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
 {  {
     if (n < 32) {      if (n < 32) {
 #ifdef HOST_WORDS_BIGENDIAN  #ifdef HOST_WORDS_BIGENDIAN
Line 9771  static int gdb_get_avr_reg(CPUState *env Line 9827  static int gdb_get_avr_reg(CPUState *env
     return 0;      return 0;
 }  }
   
 static int gdb_set_avr_reg(CPUState *env, uint8_t *mem_buf, int n)  static int gdb_set_avr_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
 {  {
     if (n < 32) {      if (n < 32) {
 #ifdef HOST_WORDS_BIGENDIAN  #ifdef HOST_WORDS_BIGENDIAN
Line 9794  static int gdb_set_avr_reg(CPUState *env Line 9850  static int gdb_set_avr_reg(CPUState *env
     return 0;      return 0;
 }  }
   
 static int gdb_get_spe_reg(CPUState *env, uint8_t *mem_buf, int n)  static int gdb_get_spe_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
 {  {
     if (n < 32) {      if (n < 32) {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
Line 9815  static int gdb_get_spe_reg(CPUState *env Line 9871  static int gdb_get_spe_reg(CPUState *env
     return 0;      return 0;
 }  }
   
 static int gdb_set_spe_reg(CPUState *env, uint8_t *mem_buf, int n)  static int gdb_set_spe_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
 {  {
     if (n < 32) {      if (n < 32) {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
Line 9838  static int gdb_set_spe_reg(CPUState *env Line 9894  static int gdb_set_spe_reg(CPUState *env
     return 0;      return 0;
 }  }
   
   static int ppc_fixup_cpu(CPUPPCState *env)
   {
       /* TCG doesn't (yet) emulate some groups of instructions that
        * are implemented on some otherwise supported CPUs (e.g. VSX
        * and decimal floating point instructions on POWER7).  We
        * remove unsupported instruction groups from the cpu state's
        * instruction masks and hope the guest can cope.  For at
        * least the pseries machine, the unavailability of these
        * instructions can be advertised to the guest via the device
        * tree. */
       if ((env->insns_flags & ~PPC_TCG_INSNS)
           || (env->insns_flags2 & ~PPC_TCG_INSNS2)) {
           fprintf(stderr, "Warning: Disabling some instructions which are not "
                   "emulated by TCG (0x%" PRIx64 ", 0x%" PRIx64 ")\n",
                   env->insns_flags & ~PPC_TCG_INSNS,
                   env->insns_flags2 & ~PPC_TCG_INSNS2);
       }
       env->insns_flags &= PPC_TCG_INSNS;
       env->insns_flags2 &= PPC_TCG_INSNS2;
       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 9846  int cpu_ppc_register_internal (CPUPPCSta Line 9924  int cpu_ppc_register_internal (CPUPPCSta
     env->bus_model = def->bus_model;      env->bus_model = def->bus_model;
     env->insns_flags = def->insns_flags;      env->insns_flags = def->insns_flags;
     env->insns_flags2 = def->insns_flags2;      env->insns_flags2 = def->insns_flags2;
     if (!kvm_enabled()) {  
         /* TCG doesn't (yet) emulate some groups of instructions that  
          * are implemented on some otherwise supported CPUs (e.g. VSX  
          * and decimal floating point instructions on POWER7).  We  
          * remove unsupported instruction groups from the cpu state's  
          * instruction masks and hope the guest can cope.  For at  
          * least the pseries machine, the unavailability of these  
          * instructions can be advertise to the guest via the device  
          * tree.  
          *  
          * FIXME: we should have a similar masking for CPU features  
          * not accessible under KVM, but so far, there aren't any of  
          * those. */  
         env->insns_flags &= PPC_TCG_INSNS;  
         env->insns_flags2 &= PPC_TCG_INSNS2;  
     }  
     env->flags = def->flags;      env->flags = def->flags;
     env->bfd_mach = def->bfd_mach;      env->bfd_mach = def->bfd_mach;
     env->check_pow = def->check_pow;      env->check_pow = def->check_pow;
   
       if (kvm_enabled()) {
           if (kvmppc_fixup_cpu(env) != 0) {
               fprintf(stderr, "Unable to virtualize selected CPU with KVM\n");
               exit(1);
           }
       } else {
           if (ppc_fixup_cpu(env) != 0) {
               fprintf(stderr, "Unable to emulate selected CPU with TCG\n");
               exit(1);
           }
       }
   
     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);
Line 10134  void ppc_cpu_list (FILE *f, fprintf_func Line 10209  void ppc_cpu_list (FILE *f, fprintf_func
                        ppc_defs[i].name, ppc_defs[i].pvr);                         ppc_defs[i].name, ppc_defs[i].pvr);
     }      }
 }  }
   
   /* CPUClass::reset() */
   static void ppc_cpu_reset(CPUState *s)
   {
       PowerPCCPU *cpu = POWERPC_CPU(s);
       PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
       CPUPPCState *env = &cpu->env;
       target_ulong msr;
   
       if (qemu_loglevel_mask(CPU_LOG_RESET)) {
           qemu_log("CPU Reset (CPU %d)\n", env->cpu_index);
           log_cpu_state(env, 0);
       }
   
       pcc->parent_reset(s);
   
       msr = (target_ulong)0;
       if (0) {
           /* XXX: find a suitable condition to enable the hypervisor mode */
           msr |= (target_ulong)MSR_HVB;
       }
       msr |= (target_ulong)0 << MSR_AP; /* TO BE CHECKED */
       msr |= (target_ulong)0 << MSR_SA; /* TO BE CHECKED */
       msr |= (target_ulong)1 << MSR_EP;
   #if defined(DO_SINGLE_STEP) && 0
       /* Single step trace mode */
       msr |= (target_ulong)1 << MSR_SE;
       msr |= (target_ulong)1 << MSR_BE;
   #endif
   #if defined(CONFIG_USER_ONLY)
       msr |= (target_ulong)1 << MSR_FP; /* Allow floating point usage */
       msr |= (target_ulong)1 << MSR_VR; /* Allow altivec usage */
       msr |= (target_ulong)1 << MSR_SPE; /* Allow SPE usage */
       msr |= (target_ulong)1 << MSR_PR;
   #else
       env->excp_prefix = env->hreset_excp_prefix;
       env->nip = env->hreset_vector | env->excp_prefix;
       if (env->mmu_model != POWERPC_MMU_REAL) {
           ppc_tlb_invalidate_all(env);
       }
   #endif
       env->msr = msr & env->msr_mask;
   #if defined(TARGET_PPC64)
       if (env->mmu_model & POWERPC_MMU_64) {
           env->msr |= (1ULL << MSR_SF);
       }
   #endif
       hreg_compute_hflags(env);
       env->reserve_addr = (target_ulong)-1ULL;
       /* Be sure no exception or interrupt is pending */
       env->pending_interrupts = 0;
       env->exception_index = POWERPC_EXCP_NONE;
       env->error_code = 0;
       /* Flush all TLBs */
       tlb_flush(env, 1);
   }
   
   static void ppc_cpu_initfn(Object *obj)
   {
       PowerPCCPU *cpu = POWERPC_CPU(obj);
       CPUPPCState *env = &cpu->env;
   
       cpu_exec_init(env);
   }
   
   static void ppc_cpu_class_init(ObjectClass *oc, void *data)
   {
       PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
       CPUClass *cc = CPU_CLASS(oc);
   
       pcc->parent_reset = cc->reset;
       cc->reset = ppc_cpu_reset;
   }
   
   static const TypeInfo ppc_cpu_type_info = {
       .name = TYPE_POWERPC_CPU,
       .parent = TYPE_CPU,
       .instance_size = sizeof(PowerPCCPU),
       .instance_init = ppc_cpu_initfn,
       .abstract = false,
       .class_size = sizeof(PowerPCCPUClass),
       .class_init = ppc_cpu_class_init,
   };
   
   static void ppc_cpu_register_types(void)
   {
       type_register_static(&ppc_cpu_type_info);
   }
   
   type_init(ppc_cpu_register_types)

Removed from v.1.1.1.11  
changed lines
  Added in v.1.1.1.12


unix.superglobalmegacorp.com