Diff for /qemu/target-ppc/translate.c between versions 1.1.1.7 and 1.1.1.8

version 1.1.1.7, 2018/04/24 17:25:29 version 1.1.1.8, 2018/04/24 17:40:49
Line 120  void ppc_translate_init(void) Line 120  void ppc_translate_init(void)
         cpu_reg_names_size -= (i < 10) ? 4 : 5;          cpu_reg_names_size -= (i < 10) ? 4 : 5;
   
         snprintf(p, cpu_reg_names_size, "avr%dH", i);          snprintf(p, cpu_reg_names_size, "avr%dH", i);
 #ifdef WORDS_BIGENDIAN  #ifdef HOST_WORDS_BIGENDIAN
         cpu_avrh[i] = tcg_global_mem_new_i64(TCG_AREG0,          cpu_avrh[i] = tcg_global_mem_new_i64(TCG_AREG0,
                                              offsetof(CPUState, avr[i].u64[0]), p);                                               offsetof(CPUState, avr[i].u64[0]), p);
 #else  #else
Line 131  void ppc_translate_init(void) Line 131  void ppc_translate_init(void)
         cpu_reg_names_size -= (i < 10) ? 6 : 7;          cpu_reg_names_size -= (i < 10) ? 6 : 7;
   
         snprintf(p, cpu_reg_names_size, "avr%dL", i);          snprintf(p, cpu_reg_names_size, "avr%dL", i);
 #ifdef WORDS_BIGENDIAN  #ifdef HOST_WORDS_BIGENDIAN
         cpu_avrl[i] = tcg_global_mem_new_i64(TCG_AREG0,          cpu_avrl[i] = tcg_global_mem_new_i64(TCG_AREG0,
                                              offsetof(CPUState, avr[i].u64[1]), p);                                               offsetof(CPUState, avr[i].u64[1]), p);
 #else  #else
Line 158  void ppc_translate_init(void) Line 158  void ppc_translate_init(void)
                                  offsetof(CPUState, xer), "xer");                                   offsetof(CPUState, xer), "xer");
   
     cpu_reserve = tcg_global_mem_new(TCG_AREG0,      cpu_reserve = tcg_global_mem_new(TCG_AREG0,
                                      offsetof(CPUState, reserve), "reserve");                                       offsetof(CPUState, reserve_addr),
                                        "reserve_addr");
   
     cpu_fpscr = tcg_global_mem_new_i32(TCG_AREG0,      cpu_fpscr = tcg_global_mem_new_i32(TCG_AREG0,
                                        offsetof(CPUState, fpscr), "fpscr");                                         offsetof(CPUState, fpscr), "fpscr");
Line 209  struct opc_handler_t { Line 210  struct opc_handler_t {
 #endif  #endif
 };  };
   
 static always_inline void gen_reset_fpstatus (void)  static inline void gen_reset_fpstatus(void)
 {  {
 #ifdef CONFIG_SOFTFLOAT  #ifdef CONFIG_SOFTFLOAT
     gen_helper_reset_fpstatus();      gen_helper_reset_fpstatus();
 #endif  #endif
 }  }
   
 static always_inline void gen_compute_fprf (TCGv_i64 arg, int set_fprf, int set_rc)  static inline void gen_compute_fprf(TCGv_i64 arg, int set_fprf, int set_rc)
 {  {
     TCGv_i32 t0 = tcg_temp_new_i32();      TCGv_i32 t0 = tcg_temp_new_i32();
   
Line 238  static always_inline void gen_compute_fp Line 239  static always_inline void gen_compute_fp
     tcg_temp_free_i32(t0);      tcg_temp_free_i32(t0);
 }  }
   
 static always_inline void gen_set_access_type (DisasContext *ctx, int access_type)  static inline void gen_set_access_type(DisasContext *ctx, int access_type)
 {  {
     if (ctx->access_type != access_type) {      if (ctx->access_type != access_type) {
         tcg_gen_movi_i32(cpu_access_type, access_type);          tcg_gen_movi_i32(cpu_access_type, access_type);
Line 246  static always_inline void gen_set_access Line 247  static always_inline void gen_set_access
     }      }
 }  }
   
 static always_inline void gen_update_nip (DisasContext *ctx, target_ulong nip)  static inline void gen_update_nip(DisasContext *ctx, target_ulong nip)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     if (ctx->sf_mode)      if (ctx->sf_mode)
Line 256  static always_inline void gen_update_nip Line 257  static always_inline void gen_update_nip
         tcg_gen_movi_tl(cpu_nip, (uint32_t)nip);          tcg_gen_movi_tl(cpu_nip, (uint32_t)nip);
 }  }
   
 static always_inline void gen_exception_err (DisasContext *ctx, uint32_t excp, uint32_t error)  static inline void gen_exception_err(DisasContext *ctx, uint32_t excp, uint32_t error)
 {  {
     TCGv_i32 t0, t1;      TCGv_i32 t0, t1;
     if (ctx->exception == POWERPC_EXCP_NONE) {      if (ctx->exception == POWERPC_EXCP_NONE) {
Line 270  static always_inline void gen_exception_ Line 271  static always_inline void gen_exception_
     ctx->exception = (excp);      ctx->exception = (excp);
 }  }
   
 static always_inline void gen_exception (DisasContext *ctx, uint32_t excp)  static inline void gen_exception(DisasContext *ctx, uint32_t excp)
 {  {
     TCGv_i32 t0;      TCGv_i32 t0;
     if (ctx->exception == POWERPC_EXCP_NONE) {      if (ctx->exception == POWERPC_EXCP_NONE) {
Line 282  static always_inline void gen_exception  Line 283  static always_inline void gen_exception 
     ctx->exception = (excp);      ctx->exception = (excp);
 }  }
   
 static always_inline void gen_debug_exception (DisasContext *ctx)  static inline void gen_debug_exception(DisasContext *ctx)
 {  {
     TCGv_i32 t0;      TCGv_i32 t0;
   
Line 293  static always_inline void gen_debug_exce Line 294  static always_inline void gen_debug_exce
     tcg_temp_free_i32(t0);      tcg_temp_free_i32(t0);
 }  }
   
 static always_inline void gen_inval_exception (DisasContext *ctx, uint32_t error)  static inline void gen_inval_exception(DisasContext *ctx, uint32_t error)
 {  {
     gen_exception_err(ctx, POWERPC_EXCP_PROGRAM, POWERPC_EXCP_INVAL | error);      gen_exception_err(ctx, POWERPC_EXCP_PROGRAM, POWERPC_EXCP_INVAL | error);
 }  }
   
 /* Stop translation */  /* Stop translation */
 static always_inline void gen_stop_exception (DisasContext *ctx)  static inline void gen_stop_exception(DisasContext *ctx)
 {  {
     gen_update_nip(ctx, ctx->nip);      gen_update_nip(ctx, ctx->nip);
     ctx->exception = POWERPC_EXCP_STOP;      ctx->exception = POWERPC_EXCP_STOP;
 }  }
   
 /* No need to update nip here, as execution flow will change */  /* No need to update nip here, as execution flow will change */
 static always_inline void gen_sync_exception (DisasContext *ctx)  static inline void gen_sync_exception(DisasContext *ctx)
 {  {
     ctx->exception = POWERPC_EXCP_SYNC;      ctx->exception = POWERPC_EXCP_SYNC;
 }  }
Line 331  typedef struct opcode_t { Line 332  typedef struct opcode_t {
 /*****************************************************************************/  /*****************************************************************************/
 /***                           Instruction decoding                        ***/  /***                           Instruction decoding                        ***/
 #define EXTRACT_HELPER(name, shift, nb)                                       \  #define EXTRACT_HELPER(name, shift, nb)                                       \
 static always_inline uint32_t name (uint32_t opcode)                          \  static inline uint32_t name(uint32_t opcode)                                  \
 {                                                                             \  {                                                                             \
     return (opcode >> (shift)) & ((1 << (nb)) - 1);                           \      return (opcode >> (shift)) & ((1 << (nb)) - 1);                           \
 }  }
   
 #define EXTRACT_SHELPER(name, shift, nb)                                      \  #define EXTRACT_SHELPER(name, shift, nb)                                      \
 static always_inline int32_t name (uint32_t opcode)                           \  static inline int32_t name(uint32_t opcode)                                   \
 {                                                                             \  {                                                                             \
     return (int16_t)((opcode >> (shift)) & ((1 << (nb)) - 1));                \      return (int16_t)((opcode >> (shift)) & ((1 << (nb)) - 1));                \
 }  }
Line 368  EXTRACT_HELPER(crbA, 16, 5); Line 369  EXTRACT_HELPER(crbA, 16, 5);
 EXTRACT_HELPER(crbB, 11, 5);  EXTRACT_HELPER(crbB, 11, 5);
 /* SPR / TBL */  /* SPR / TBL */
 EXTRACT_HELPER(_SPR, 11, 10);  EXTRACT_HELPER(_SPR, 11, 10);
 static always_inline uint32_t SPR (uint32_t opcode)  static inline uint32_t SPR(uint32_t opcode)
 {  {
     uint32_t sprn = _SPR(opcode);      uint32_t sprn = _SPR(opcode);
   
Line 406  EXTRACT_HELPER(FPIMM, 12, 4); Line 407  EXTRACT_HELPER(FPIMM, 12, 4);
 /* Displacement */  /* Displacement */
 EXTRACT_SHELPER(d, 0, 16);  EXTRACT_SHELPER(d, 0, 16);
 /* Immediate address */  /* Immediate address */
 static always_inline target_ulong LI (uint32_t opcode)  static inline target_ulong LI(uint32_t opcode)
 {  {
     return (opcode >> 0) & 0x03FFFFFC;      return (opcode >> 0) & 0x03FFFFFC;
 }  }
   
 static always_inline uint32_t BD (uint32_t opcode)  static inline uint32_t BD(uint32_t opcode)
 {  {
     return (opcode >> 0) & 0xFFFC;      return (opcode >> 0) & 0xFFFC;
 }  }
Line 424  EXTRACT_HELPER(AA, 1, 1); Line 425  EXTRACT_HELPER(AA, 1, 1);
 EXTRACT_HELPER(LK, 0, 1);  EXTRACT_HELPER(LK, 0, 1);
   
 /* Create a mask between <start> and <end> bits */  /* Create a mask between <start> and <end> bits */
 static always_inline target_ulong MASK (uint32_t start, uint32_t end)  static inline target_ulong MASK(uint32_t start, uint32_t end)
 {  {
     target_ulong ret;      target_ulong ret;
   
Line 513  static always_inline target_ulong MASK ( Line 514  static always_inline target_ulong MASK (
 #endif  #endif
   
 /* SPR load/store helpers */  /* SPR load/store helpers */
 static always_inline void gen_load_spr(TCGv t, int reg)  static inline void gen_load_spr(TCGv t, int reg)
 {  {
     tcg_gen_ld_tl(t, cpu_env, offsetof(CPUState, spr[reg]));      tcg_gen_ld_tl(t, cpu_env, offsetof(CPUState, spr[reg]));
 }  }
   
 static always_inline void gen_store_spr(int reg, TCGv t)  static inline void gen_store_spr(int reg, TCGv t)
 {  {
     tcg_gen_st_tl(t, cpu_env, offsetof(CPUState, spr[reg]));      tcg_gen_st_tl(t, cpu_env, offsetof(CPUState, spr[reg]));
 }  }
Line 537  static opc_handler_t invalid_handler = { Line 538  static opc_handler_t invalid_handler = {
   
 /***                           Integer comparison                          ***/  /***                           Integer comparison                          ***/
   
 static always_inline void gen_op_cmp(TCGv arg0, TCGv arg1, int s, int crf)  static inline void gen_op_cmp(TCGv arg0, TCGv arg1, int s, int crf)
 {  {
     int l1, l2, l3;      int l1, l2, l3;
   
Line 565  static always_inline void gen_op_cmp(TCG Line 566  static always_inline void gen_op_cmp(TCG
     gen_set_label(l3);      gen_set_label(l3);
 }  }
   
 static always_inline void gen_op_cmpi(TCGv arg0, target_ulong arg1, int s, int crf)  static inline void gen_op_cmpi(TCGv arg0, target_ulong arg1, int s, int crf)
 {  {
     TCGv t0 = tcg_const_local_tl(arg1);      TCGv t0 = tcg_const_local_tl(arg1);
     gen_op_cmp(arg0, t0, s, crf);      gen_op_cmp(arg0, t0, s, crf);
Line 573  static always_inline void gen_op_cmpi(TC Line 574  static always_inline void gen_op_cmpi(TC
 }  }
   
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 static always_inline void gen_op_cmp32(TCGv arg0, TCGv arg1, int s, int crf)  static inline void gen_op_cmp32(TCGv arg0, TCGv arg1, int s, int crf)
 {  {
     TCGv t0, t1;      TCGv t0, t1;
     t0 = tcg_temp_local_new();      t0 = tcg_temp_local_new();
Line 590  static always_inline void gen_op_cmp32(T Line 591  static always_inline void gen_op_cmp32(T
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static always_inline void gen_op_cmpi32(TCGv arg0, target_ulong arg1, int s, int crf)  static inline void gen_op_cmpi32(TCGv arg0, target_ulong arg1, int s, int crf)
 {  {
     TCGv t0 = tcg_const_local_tl(arg1);      TCGv t0 = tcg_const_local_tl(arg1);
     gen_op_cmp32(arg0, t0, s, crf);      gen_op_cmp32(arg0, t0, s, crf);
Line 598  static always_inline void gen_op_cmpi32( Line 599  static always_inline void gen_op_cmpi32(
 }  }
 #endif  #endif
   
 static always_inline void gen_set_Rc0 (DisasContext *ctx, TCGv reg)  static inline void gen_set_Rc0(DisasContext *ctx, TCGv reg)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     if (!(ctx->sf_mode))      if (!(ctx->sf_mode))
Line 688  static void gen_isel(DisasContext *ctx) Line 689  static void gen_isel(DisasContext *ctx)
   
 /***                           Integer arithmetic                          ***/  /***                           Integer arithmetic                          ***/
   
 static always_inline void gen_op_arith_compute_ov(DisasContext *ctx, TCGv arg0, TCGv arg1, TCGv arg2, int sub)  static inline void gen_op_arith_compute_ov(DisasContext *ctx, TCGv arg0,
                                              TCGv arg1, TCGv arg2, int sub)
 {  {
     int l1;      int l1;
     TCGv t0;      TCGv t0;
Line 720  static always_inline void gen_op_arith_c Line 722  static always_inline void gen_op_arith_c
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static always_inline void gen_op_arith_compute_ca(DisasContext *ctx, TCGv arg1, TCGv arg2, int sub)  static inline void gen_op_arith_compute_ca(DisasContext *ctx, TCGv arg1,
                                              TCGv arg2, int sub)
 {  {
     int l1 = gen_new_label();      int l1 = gen_new_label();
   
Line 755  static always_inline void gen_op_arith_c Line 758  static always_inline void gen_op_arith_c
 }  }
   
 /* Common add function */  /* Common add function */
 static always_inline void gen_op_arith_add(DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2,  static inline void gen_op_arith_add(DisasContext *ctx, TCGv ret, TCGv arg1,
                                            int add_ca, int compute_ca, int compute_ov)                                      TCGv arg2, int add_ca, int compute_ca,
                                       int compute_ov)
 {  {
     TCGv t0, t1;      TCGv t0, t1;
   
Line 856  static void gen_addi(DisasContext *ctx) Line 860  static void gen_addi(DisasContext *ctx)
     }      }
 }  }
 /* addic  addic.*/  /* addic  addic.*/
 static always_inline void gen_op_addic (DisasContext *ctx, TCGv ret, TCGv arg1,  static inline void gen_op_addic(DisasContext *ctx, TCGv ret, TCGv arg1,
                                         int compute_Rc0)                                  int compute_Rc0)
 {  {
     target_long simm = SIMM(ctx->opcode);      target_long simm = SIMM(ctx->opcode);
   
Line 901  static void gen_addis(DisasContext *ctx) Line 905  static void gen_addis(DisasContext *ctx)
     }      }
 }  }
   
 static always_inline void gen_op_arith_divw (DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2,  static inline void gen_op_arith_divw(DisasContext *ctx, TCGv ret, TCGv arg1,
                                              int sign, int compute_ov)                                       TCGv arg2, int sign, int compute_ov)
 {  {
     int l1 = gen_new_label();      int l1 = gen_new_label();
     int l2 = gen_new_label();      int l2 = gen_new_label();
Line 956  GEN_INT_ARITH_DIVW(divwuo, 0x1E, 0, 1); Line 960  GEN_INT_ARITH_DIVW(divwuo, 0x1E, 0, 1);
 GEN_INT_ARITH_DIVW(divw, 0x0F, 1, 0);  GEN_INT_ARITH_DIVW(divw, 0x0F, 1, 0);
 GEN_INT_ARITH_DIVW(divwo, 0x1F, 1, 1);  GEN_INT_ARITH_DIVW(divwo, 0x1F, 1, 1);
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 static always_inline void gen_op_arith_divd (DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2,  static inline void gen_op_arith_divd(DisasContext *ctx, TCGv ret, TCGv arg1,
                                              int sign, int compute_ov)                                       TCGv arg2, int sign, int compute_ov)
 {  {
     int l1 = gen_new_label();      int l1 = gen_new_label();
     int l2 = gen_new_label();      int l2 = gen_new_label();
Line 1132  GEN_INT_ARITH_MUL_HELPER(mulldo, 0x17); Line 1136  GEN_INT_ARITH_MUL_HELPER(mulldo, 0x17);
 #endif  #endif
   
 /* neg neg. nego nego. */  /* neg neg. nego nego. */
 static always_inline void gen_op_arith_neg (DisasContext *ctx, TCGv ret, TCGv arg1, int ov_check)  static inline void gen_op_arith_neg(DisasContext *ctx, TCGv ret, TCGv arg1,
                                       int ov_check)
 {  {
     int l1 = gen_new_label();      int l1 = gen_new_label();
     int l2 = gen_new_label();      int l2 = gen_new_label();
Line 1174  static void gen_nego(DisasContext *ctx) Line 1179  static void gen_nego(DisasContext *ctx)
 }  }
   
 /* Common subf function */  /* Common subf function */
 static always_inline void gen_op_arith_subf(DisasContext *ctx, TCGv ret, TCGv arg1, TCGv arg2,  static inline void gen_op_arith_subf(DisasContext *ctx, TCGv ret, TCGv arg1,
                                             int add_ca, int compute_ca, int compute_ov)                                       TCGv arg2, int add_ca, int compute_ca,
                                        int compute_ov)
 {  {
     TCGv t0, t1;      TCGv t0, t1;
   
Line 1657  static void glue(gen_, name##3)(DisasCon Line 1663  static void glue(gen_, name##3)(DisasCon
     gen_##name(ctx, 1, 1);                                                    \      gen_##name(ctx, 1, 1);                                                    \
 }  }
   
 static always_inline void gen_rldinm (DisasContext *ctx, uint32_t mb,  static inline void gen_rldinm(DisasContext *ctx, uint32_t mb, uint32_t me,
                                       uint32_t me, uint32_t sh)                                uint32_t sh)
 {  {
     if (likely(sh != 0 && mb == 0 && me == (63 - sh))) {      if (likely(sh != 0 && mb == 0 && me == (63 - sh))) {
         tcg_gen_shli_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], sh);          tcg_gen_shli_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], sh);
Line 1678  static always_inline void gen_rldinm (Di Line 1684  static always_inline void gen_rldinm (Di
         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);          gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
 }  }
 /* rldicl - rldicl. */  /* rldicl - rldicl. */
 static always_inline void gen_rldicl (DisasContext *ctx, int mbn, int shn)  static inline void gen_rldicl(DisasContext *ctx, int mbn, int shn)
 {  {
     uint32_t sh, mb;      uint32_t sh, mb;
   
Line 1688  static always_inline void gen_rldicl (Di Line 1694  static always_inline void gen_rldicl (Di
 }  }
 GEN_PPC64_R4(rldicl, 0x1E, 0x00);  GEN_PPC64_R4(rldicl, 0x1E, 0x00);
 /* rldicr - rldicr. */  /* rldicr - rldicr. */
 static always_inline void gen_rldicr (DisasContext *ctx, int men, int shn)  static inline void gen_rldicr(DisasContext *ctx, int men, int shn)
 {  {
     uint32_t sh, me;      uint32_t sh, me;
   
Line 1698  static always_inline void gen_rldicr (Di Line 1704  static always_inline void gen_rldicr (Di
 }  }
 GEN_PPC64_R4(rldicr, 0x1E, 0x02);  GEN_PPC64_R4(rldicr, 0x1E, 0x02);
 /* rldic - rldic. */  /* rldic - rldic. */
 static always_inline void gen_rldic (DisasContext *ctx, int mbn, int shn)  static inline void gen_rldic(DisasContext *ctx, int mbn, int shn)
 {  {
     uint32_t sh, mb;      uint32_t sh, mb;
   
Line 1708  static always_inline void gen_rldic (Dis Line 1714  static always_inline void gen_rldic (Dis
 }  }
 GEN_PPC64_R4(rldic, 0x1E, 0x04);  GEN_PPC64_R4(rldic, 0x1E, 0x04);
   
 static always_inline void gen_rldnm (DisasContext *ctx, uint32_t mb,  static inline void gen_rldnm(DisasContext *ctx, uint32_t mb, uint32_t me)
                                      uint32_t me)  
 {  {
     TCGv t0;      TCGv t0;
   
Line 1729  static always_inline void gen_rldnm (Dis Line 1734  static always_inline void gen_rldnm (Dis
 }  }
   
 /* rldcl - rldcl. */  /* rldcl - rldcl. */
 static always_inline void gen_rldcl (DisasContext *ctx, int mbn)  static inline void gen_rldcl(DisasContext *ctx, int mbn)
 {  {
     uint32_t mb;      uint32_t mb;
   
Line 1738  static always_inline void gen_rldcl (Dis Line 1743  static always_inline void gen_rldcl (Dis
 }  }
 GEN_PPC64_R2(rldcl, 0x1E, 0x08);  GEN_PPC64_R2(rldcl, 0x1E, 0x08);
 /* rldcr - rldcr. */  /* rldcr - rldcr. */
 static always_inline void gen_rldcr (DisasContext *ctx, int men)  static inline void gen_rldcr(DisasContext *ctx, int men)
 {  {
     uint32_t me;      uint32_t me;
   
Line 1747  static always_inline void gen_rldcr (Dis Line 1752  static always_inline void gen_rldcr (Dis
 }  }
 GEN_PPC64_R2(rldcr, 0x1E, 0x09);  GEN_PPC64_R2(rldcr, 0x1E, 0x09);
 /* rldimi - rldimi. */  /* rldimi - rldimi. */
 static always_inline void gen_rldimi (DisasContext *ctx, int mbn, int shn)  static inline void gen_rldimi(DisasContext *ctx, int mbn, int shn)
 {  {
     uint32_t sh, mb, me;      uint32_t sh, mb, me;
   
Line 1781  GEN_PPC64_R4(rldimi, 0x1E, 0x06); Line 1786  GEN_PPC64_R4(rldimi, 0x1E, 0x06);
 /* slw & slw. */  /* slw & slw. */
 static void gen_slw(DisasContext *ctx)  static void gen_slw(DisasContext *ctx)
 {  {
     TCGv t0;      TCGv t0, t1;
     int l1, l2;  
     l1 = gen_new_label();  
     l2 = gen_new_label();  
   
     t0 = tcg_temp_local_new();      t0 = tcg_temp_new();
     tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x3f);      /* AND rS with a mask that is 0 when rB >= 0x20 */
     tcg_gen_brcondi_tl(TCG_COND_LT, t0, 0x20, l1);  #if defined(TARGET_PPC64)
     tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);      tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x3a);
     tcg_gen_br(l2);      tcg_gen_sari_tl(t0, t0, 0x3f);
     gen_set_label(l1);  #else
     tcg_gen_shl_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], t0);      tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1a);
     tcg_gen_ext32u_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);      tcg_gen_sari_tl(t0, t0, 0x1f);
     gen_set_label(l2);  #endif
       tcg_gen_andc_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
       t1 = tcg_temp_new();
       tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x1f);
       tcg_gen_shl_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
       tcg_temp_free(t1);
     tcg_temp_free(t0);      tcg_temp_free(t0);
       tcg_gen_ext32u_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
     if (unlikely(Rc(ctx->opcode) != 0))      if (unlikely(Rc(ctx->opcode) != 0))
         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);          gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
 }  }
Line 1843  static void gen_srawi(DisasContext *ctx) Line 1851  static void gen_srawi(DisasContext *ctx)
 static void gen_srw(DisasContext *ctx)  static void gen_srw(DisasContext *ctx)
 {  {
     TCGv t0, t1;      TCGv t0, t1;
     int l1, l2;  
     l1 = gen_new_label();  
     l2 = gen_new_label();  
   
     t0 = tcg_temp_local_new();      t0 = tcg_temp_new();
     tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x3f);      /* AND rS with a mask that is 0 when rB >= 0x20 */
     tcg_gen_brcondi_tl(TCG_COND_LT, t0, 0x20, l1);  #if defined(TARGET_PPC64)
     tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);      tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x3a);
     tcg_gen_br(l2);      tcg_gen_sari_tl(t0, t0, 0x3f);
     gen_set_label(l1);  #else
       tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1a);
       tcg_gen_sari_tl(t0, t0, 0x1f);
   #endif
       tcg_gen_andc_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
       tcg_gen_ext32u_tl(t0, t0);
     t1 = tcg_temp_new();      t1 = tcg_temp_new();
     tcg_gen_ext32u_tl(t1, cpu_gpr[rS(ctx->opcode)]);      tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x1f);
     tcg_gen_shr_tl(cpu_gpr[rA(ctx->opcode)], t1, t0);      tcg_gen_shr_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
     tcg_temp_free(t1);      tcg_temp_free(t1);
     gen_set_label(l2);  
     tcg_temp_free(t0);      tcg_temp_free(t0);
     if (unlikely(Rc(ctx->opcode) != 0))      if (unlikely(Rc(ctx->opcode) != 0))
         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);          gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
Line 1867  static void gen_srw(DisasContext *ctx) Line 1876  static void gen_srw(DisasContext *ctx)
 /* sld & sld. */  /* sld & sld. */
 static void gen_sld(DisasContext *ctx)  static void gen_sld(DisasContext *ctx)
 {  {
     TCGv t0;      TCGv t0, t1;
     int l1, l2;  
     l1 = gen_new_label();  
     l2 = gen_new_label();  
   
     t0 = tcg_temp_local_new();      t0 = tcg_temp_new();
     tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x7f);      /* AND rS with a mask that is 0 when rB >= 0x40 */
     tcg_gen_brcondi_tl(TCG_COND_LT, t0, 0x40, l1);      tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x39);
     tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);      tcg_gen_sari_tl(t0, t0, 0x3f);
     tcg_gen_br(l2);      tcg_gen_andc_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
     gen_set_label(l1);      t1 = tcg_temp_new();
     tcg_gen_shl_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], t0);      tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x3f);
     gen_set_label(l2);      tcg_gen_shl_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
       tcg_temp_free(t1);
     tcg_temp_free(t0);      tcg_temp_free(t0);
     if (unlikely(Rc(ctx->opcode) != 0))      if (unlikely(Rc(ctx->opcode) != 0))
         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);          gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
Line 1894  static void gen_srad(DisasContext *ctx) Line 1901  static void gen_srad(DisasContext *ctx)
         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);          gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
 }  }
 /* sradi & sradi. */  /* sradi & sradi. */
 static always_inline void gen_sradi (DisasContext *ctx, int n)  static inline void gen_sradi(DisasContext *ctx, int n)
 {  {
     int sh = SH(ctx->opcode) + (n << 5);      int sh = SH(ctx->opcode) + (n << 5);
     if (sh != 0) {      if (sh != 0) {
Line 1934  static void gen_sradi1(DisasContext *ctx Line 1941  static void gen_sradi1(DisasContext *ctx
 /* srd & srd. */  /* srd & srd. */
 static void gen_srd(DisasContext *ctx)  static void gen_srd(DisasContext *ctx)
 {  {
     TCGv t0;      TCGv t0, t1;
     int l1, l2;  
     l1 = gen_new_label();  
     l2 = gen_new_label();  
   
     t0 = tcg_temp_local_new();      t0 = tcg_temp_new();
     tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x7f);      /* AND rS with a mask that is 0 when rB >= 0x40 */
     tcg_gen_brcondi_tl(TCG_COND_LT, t0, 0x40, l1);      tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x39);
     tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);      tcg_gen_sari_tl(t0, t0, 0x3f);
     tcg_gen_br(l2);      tcg_gen_andc_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
     gen_set_label(l1);      t1 = tcg_temp_new();
     tcg_gen_shr_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], t0);      tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x3f);
     gen_set_label(l2);      tcg_gen_shr_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
       tcg_temp_free(t1);
     tcg_temp_free(t0);      tcg_temp_free(t0);
     if (unlikely(Rc(ctx->opcode) != 0))      if (unlikely(Rc(ctx->opcode) != 0))
         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);          gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
Line 2347  static void gen_mtfsfi(DisasContext *ctx Line 2352  static void gen_mtfsfi(DisasContext *ctx
   
 /***                           Addressing modes                            ***/  /***                           Addressing modes                            ***/
 /* Register indirect with immediate index : EA = (rA|0) + SIMM */  /* Register indirect with immediate index : EA = (rA|0) + SIMM */
 static always_inline void gen_addr_imm_index (DisasContext *ctx, TCGv EA, target_long maskl)  static inline void gen_addr_imm_index(DisasContext *ctx, TCGv EA,
                                         target_long maskl)
 {  {
     target_long simm = SIMM(ctx->opcode);      target_long simm = SIMM(ctx->opcode);
   
Line 2376  static always_inline void gen_addr_imm_i Line 2382  static always_inline void gen_addr_imm_i
     }      }
 }  }
   
 static always_inline void gen_addr_reg_index (DisasContext *ctx, TCGv EA)  static inline void gen_addr_reg_index(DisasContext *ctx, TCGv EA)
 {  {
     if (rA(ctx->opcode) == 0) {      if (rA(ctx->opcode) == 0) {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
Line 2395  static always_inline void gen_addr_reg_i Line 2401  static always_inline void gen_addr_reg_i
     }      }
 }  }
   
 static always_inline void gen_addr_register (DisasContext *ctx, TCGv EA)  static inline void gen_addr_register(DisasContext *ctx, TCGv EA)
 {  {
     if (rA(ctx->opcode) == 0) {      if (rA(ctx->opcode) == 0) {
         tcg_gen_movi_tl(EA, 0);          tcg_gen_movi_tl(EA, 0);
Line 2409  static always_inline void gen_addr_regis Line 2415  static always_inline void gen_addr_regis
     }      }
 }  }
   
 static always_inline void gen_addr_add (DisasContext *ctx, TCGv ret, TCGv arg1, target_long val)  static inline void gen_addr_add(DisasContext *ctx, TCGv ret, TCGv arg1,
                                   target_long val)
 {  {
     tcg_gen_addi_tl(ret, arg1, val);      tcg_gen_addi_tl(ret, arg1, val);
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
Line 2419  static always_inline void gen_addr_add ( Line 2426  static always_inline void gen_addr_add (
 #endif  #endif
 }  }
   
 static always_inline void gen_check_align (DisasContext *ctx, TCGv EA, int mask)  static inline void gen_check_align(DisasContext *ctx, TCGv EA, int mask)
 {  {
     int l1 = gen_new_label();      int l1 = gen_new_label();
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
Line 2438  static always_inline void gen_check_alig Line 2445  static always_inline void gen_check_alig
 }  }
   
 /***                             Integer load                              ***/  /***                             Integer load                              ***/
 static always_inline void gen_qemu_ld8u(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_ld8u(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     tcg_gen_qemu_ld8u(arg1, arg2, ctx->mem_idx);      tcg_gen_qemu_ld8u(arg1, arg2, ctx->mem_idx);
 }  }
   
 static always_inline void gen_qemu_ld8s(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_ld8s(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     tcg_gen_qemu_ld8s(arg1, arg2, ctx->mem_idx);      tcg_gen_qemu_ld8s(arg1, arg2, ctx->mem_idx);
 }  }
   
 static always_inline void gen_qemu_ld16u(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_ld16u(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     tcg_gen_qemu_ld16u(arg1, arg2, ctx->mem_idx);      tcg_gen_qemu_ld16u(arg1, arg2, ctx->mem_idx);
     if (unlikely(ctx->le_mode)) {      if (unlikely(ctx->le_mode)) {
Line 2456  static always_inline void gen_qemu_ld16u Line 2463  static always_inline void gen_qemu_ld16u
     }      }
 }  }
   
 static always_inline void gen_qemu_ld16s(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_ld16s(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     if (unlikely(ctx->le_mode)) {      if (unlikely(ctx->le_mode)) {
         tcg_gen_qemu_ld16u(arg1, arg2, ctx->mem_idx);          tcg_gen_qemu_ld16u(arg1, arg2, ctx->mem_idx);
Line 2467  static always_inline void gen_qemu_ld16s Line 2474  static always_inline void gen_qemu_ld16s
     }      }
 }  }
   
 static always_inline void gen_qemu_ld32u(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_ld32u(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx);      tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx);
     if (unlikely(ctx->le_mode)) {      if (unlikely(ctx->le_mode)) {
Line 2476  static always_inline void gen_qemu_ld32u Line 2483  static always_inline void gen_qemu_ld32u
 }  }
   
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 static always_inline void gen_qemu_ld32s(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_ld32s(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     if (unlikely(ctx->le_mode)) {      if (unlikely(ctx->le_mode)) {
         tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx);          tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx);
Line 2487  static always_inline void gen_qemu_ld32s Line 2494  static always_inline void gen_qemu_ld32s
 }  }
 #endif  #endif
   
 static always_inline void gen_qemu_ld64(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)  static inline void gen_qemu_ld64(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)
 {  {
     tcg_gen_qemu_ld64(arg1, arg2, ctx->mem_idx);      tcg_gen_qemu_ld64(arg1, arg2, ctx->mem_idx);
     if (unlikely(ctx->le_mode)) {      if (unlikely(ctx->le_mode)) {
Line 2495  static always_inline void gen_qemu_ld64( Line 2502  static always_inline void gen_qemu_ld64(
     }      }
 }  }
   
 static always_inline void gen_qemu_st8(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_st8(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     tcg_gen_qemu_st8(arg1, arg2, ctx->mem_idx);      tcg_gen_qemu_st8(arg1, arg2, ctx->mem_idx);
 }  }
   
 static always_inline void gen_qemu_st16(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_st16(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     if (unlikely(ctx->le_mode)) {      if (unlikely(ctx->le_mode)) {
         TCGv t0 = tcg_temp_new();          TCGv t0 = tcg_temp_new();
Line 2513  static always_inline void gen_qemu_st16( Line 2520  static always_inline void gen_qemu_st16(
     }      }
 }  }
   
 static always_inline void gen_qemu_st32(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_st32(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     if (unlikely(ctx->le_mode)) {      if (unlikely(ctx->le_mode)) {
         TCGv t0 = tcg_temp_new();          TCGv t0 = tcg_temp_new();
Line 2526  static always_inline void gen_qemu_st32( Line 2533  static always_inline void gen_qemu_st32(
     }      }
 }  }
   
 static always_inline void gen_qemu_st64(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)  static inline void gen_qemu_st64(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)
 {  {
     if (unlikely(ctx->le_mode)) {      if (unlikely(ctx->le_mode)) {
         TCGv_i64 t0 = tcg_temp_new_i64();          TCGv_i64 t0 = tcg_temp_new_i64();
Line 2807  static void gen_std(DisasContext *ctx) Line 2814  static void gen_std(DisasContext *ctx)
 #endif  #endif
 /***                Integer load and store with byte reverse               ***/  /***                Integer load and store with byte reverse               ***/
 /* lhbrx */  /* lhbrx */
 static void always_inline gen_qemu_ld16ur(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_ld16ur(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     tcg_gen_qemu_ld16u(arg1, arg2, ctx->mem_idx);      tcg_gen_qemu_ld16u(arg1, arg2, ctx->mem_idx);
     if (likely(!ctx->le_mode)) {      if (likely(!ctx->le_mode)) {
Line 2817  static void always_inline gen_qemu_ld16u Line 2824  static void always_inline gen_qemu_ld16u
 GEN_LDX(lhbr, ld16ur, 0x16, 0x18, PPC_INTEGER);  GEN_LDX(lhbr, ld16ur, 0x16, 0x18, PPC_INTEGER);
   
 /* lwbrx */  /* lwbrx */
 static void always_inline gen_qemu_ld32ur(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_ld32ur(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx);      tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx);
     if (likely(!ctx->le_mode)) {      if (likely(!ctx->le_mode)) {
Line 2827  static void always_inline gen_qemu_ld32u Line 2834  static void always_inline gen_qemu_ld32u
 GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER);  GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER);
   
 /* sthbrx */  /* sthbrx */
 static void always_inline gen_qemu_st16r(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_st16r(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     if (likely(!ctx->le_mode)) {      if (likely(!ctx->le_mode)) {
         TCGv t0 = tcg_temp_new();          TCGv t0 = tcg_temp_new();
Line 2842  static void always_inline gen_qemu_st16r Line 2849  static void always_inline gen_qemu_st16r
 GEN_STX(sthbr, st16r, 0x16, 0x1C, PPC_INTEGER);  GEN_STX(sthbr, st16r, 0x16, 0x1C, PPC_INTEGER);
   
 /* stwbrx */  /* stwbrx */
 static void always_inline gen_qemu_st32r(DisasContext *ctx, TCGv arg1, TCGv arg2)  static inline void gen_qemu_st32r(DisasContext *ctx, TCGv arg1, TCGv arg2)
 {  {
     if (likely(!ctx->le_mode)) {      if (likely(!ctx->le_mode)) {
         TCGv t0 = tcg_temp_new();          TCGv t0 = tcg_temp_new();
Line 3006  static void gen_isync(DisasContext *ctx) Line 3013  static void gen_isync(DisasContext *ctx)
 static void gen_lwarx(DisasContext *ctx)  static void gen_lwarx(DisasContext *ctx)
 {  {
     TCGv t0;      TCGv t0;
       TCGv gpr = cpu_gpr[rD(ctx->opcode)];
     gen_set_access_type(ctx, ACCESS_RES);      gen_set_access_type(ctx, ACCESS_RES);
     t0 = tcg_temp_local_new();      t0 = tcg_temp_local_new();
     gen_addr_reg_index(ctx, t0);      gen_addr_reg_index(ctx, t0);
     gen_check_align(ctx, t0, 0x03);      gen_check_align(ctx, t0, 0x03);
     gen_qemu_ld32u(ctx, cpu_gpr[rD(ctx->opcode)], t0);      gen_qemu_ld32u(ctx, gpr, t0);
     tcg_gen_mov_tl(cpu_reserve, t0);      tcg_gen_mov_tl(cpu_reserve, t0);
       tcg_gen_st_tl(gpr, cpu_env, offsetof(CPUState, reserve_val));
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
   #if defined(CONFIG_USER_ONLY)
   static void gen_conditional_store (DisasContext *ctx, TCGv EA,
                                      int reg, int size)
   {
       TCGv t0 = tcg_temp_new();
       uint32_t save_exception = ctx->exception;
   
       tcg_gen_st_tl(EA, cpu_env, offsetof(CPUState, reserve_ea));
       tcg_gen_movi_tl(t0, (size << 5) | reg);
       tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, reserve_info));
       tcg_temp_free(t0);
       gen_update_nip(ctx, ctx->nip-4);
       ctx->exception = POWERPC_EXCP_BRANCH;
       gen_exception(ctx, POWERPC_EXCP_STCX);
       ctx->exception = save_exception;
   }
   #endif
   
 /* stwcx. */  /* stwcx. */
 static void gen_stwcx_(DisasContext *ctx)  static void gen_stwcx_(DisasContext *ctx)
 {  {
     int l1;  
     TCGv t0;      TCGv t0;
     gen_set_access_type(ctx, ACCESS_RES);      gen_set_access_type(ctx, ACCESS_RES);
     t0 = tcg_temp_local_new();      t0 = tcg_temp_local_new();
     gen_addr_reg_index(ctx, t0);      gen_addr_reg_index(ctx, t0);
     gen_check_align(ctx, t0, 0x03);      gen_check_align(ctx, t0, 0x03);
     tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_xer);  #if defined(CONFIG_USER_ONLY)
     tcg_gen_shri_i32(cpu_crf[0], cpu_crf[0], XER_SO);      gen_conditional_store(ctx, t0, rS(ctx->opcode), 4);
     tcg_gen_andi_i32(cpu_crf[0], cpu_crf[0], 1);  #else
     l1 = gen_new_label();      {
     tcg_gen_brcond_tl(TCG_COND_NE, t0, cpu_reserve, l1);          int l1;
     tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 1 << CRF_EQ);  
     gen_qemu_st32(ctx, cpu_gpr[rS(ctx->opcode)], t0);          tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_xer);
     gen_set_label(l1);          tcg_gen_shri_i32(cpu_crf[0], cpu_crf[0], XER_SO);
     tcg_gen_movi_tl(cpu_reserve, -1);          tcg_gen_andi_i32(cpu_crf[0], cpu_crf[0], 1);
           l1 = gen_new_label();
           tcg_gen_brcond_tl(TCG_COND_NE, t0, cpu_reserve, l1);
           tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 1 << CRF_EQ);
           gen_qemu_st32(ctx, cpu_gpr[rS(ctx->opcode)], t0);
           gen_set_label(l1);
           tcg_gen_movi_tl(cpu_reserve, -1);
       }
   #endif
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
Line 3041  static void gen_stwcx_(DisasContext *ctx Line 3075  static void gen_stwcx_(DisasContext *ctx
 static void gen_ldarx(DisasContext *ctx)  static void gen_ldarx(DisasContext *ctx)
 {  {
     TCGv t0;      TCGv t0;
       TCGv gpr = cpu_gpr[rD(ctx->opcode)];
     gen_set_access_type(ctx, ACCESS_RES);      gen_set_access_type(ctx, ACCESS_RES);
     t0 = tcg_temp_local_new();      t0 = tcg_temp_local_new();
     gen_addr_reg_index(ctx, t0);      gen_addr_reg_index(ctx, t0);
     gen_check_align(ctx, t0, 0x07);      gen_check_align(ctx, t0, 0x07);
     gen_qemu_ld64(ctx, cpu_gpr[rD(ctx->opcode)], t0);      gen_qemu_ld64(ctx, gpr, t0);
     tcg_gen_mov_tl(cpu_reserve, t0);      tcg_gen_mov_tl(cpu_reserve, t0);
       tcg_gen_st_tl(gpr, cpu_env, offsetof(CPUState, reserve_val));
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 /* stdcx. */  /* stdcx. */
 static void gen_stdcx_(DisasContext *ctx)  static void gen_stdcx_(DisasContext *ctx)
 {  {
     int l1;  
     TCGv t0;      TCGv t0;
     gen_set_access_type(ctx, ACCESS_RES);      gen_set_access_type(ctx, ACCESS_RES);
     t0 = tcg_temp_local_new();      t0 = tcg_temp_local_new();
     gen_addr_reg_index(ctx, t0);      gen_addr_reg_index(ctx, t0);
     gen_check_align(ctx, t0, 0x07);      gen_check_align(ctx, t0, 0x07);
     tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_xer);  #if defined(CONFIG_USER_ONLY)
     tcg_gen_shri_i32(cpu_crf[0], cpu_crf[0], XER_SO);      gen_conditional_store(ctx, t0, rS(ctx->opcode), 8);
     tcg_gen_andi_i32(cpu_crf[0], cpu_crf[0], 1);  #else
     l1 = gen_new_label();      {
     tcg_gen_brcond_tl(TCG_COND_NE, t0, cpu_reserve, l1);          int l1;
     tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 1 << CRF_EQ);          tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_xer);
     gen_qemu_st64(ctx, cpu_gpr[rS(ctx->opcode)], t0);          tcg_gen_shri_i32(cpu_crf[0], cpu_crf[0], XER_SO);
     gen_set_label(l1);          tcg_gen_andi_i32(cpu_crf[0], cpu_crf[0], 1);
     tcg_gen_movi_tl(cpu_reserve, -1);          l1 = gen_new_label();
           tcg_gen_brcond_tl(TCG_COND_NE, t0, cpu_reserve, l1);
           tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 1 << CRF_EQ);
           gen_qemu_st64(ctx, cpu_gpr[rS(ctx->opcode)], t0);
           gen_set_label(l1);
           tcg_gen_movi_tl(cpu_reserve, -1);
       }
   #endif
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
 #endif /* defined(TARGET_PPC64) */  #endif /* defined(TARGET_PPC64) */
Line 3164  GEN_LDUF(name, ldop, op | 0x21, type);   Line 3206  GEN_LDUF(name, ldop, op | 0x21, type);  
 GEN_LDUXF(name, ldop, op | 0x01, type);                                       \  GEN_LDUXF(name, ldop, op | 0x01, type);                                       \
 GEN_LDXF(name, ldop, 0x17, op | 0x00, type)  GEN_LDXF(name, ldop, 0x17, op | 0x00, type)
   
 static always_inline void gen_qemu_ld32fs(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)  static inline void gen_qemu_ld32fs(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
     TCGv_i32 t1 = tcg_temp_new_i32();      TCGv_i32 t1 = tcg_temp_new_i32();
Line 3257  GEN_STUF(name, stop, op | 0x21, type);   Line 3299  GEN_STUF(name, stop, op | 0x21, type);  
 GEN_STUXF(name, stop, op | 0x01, type);                                       \  GEN_STUXF(name, stop, op | 0x01, type);                                       \
 GEN_STXF(name, stop, 0x17, op | 0x00, type)  GEN_STXF(name, stop, 0x17, op | 0x00, type)
   
 static always_inline void gen_qemu_st32fs(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)  static inline void gen_qemu_st32fs(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)
 {  {
     TCGv_i32 t0 = tcg_temp_new_i32();      TCGv_i32 t0 = tcg_temp_new_i32();
     TCGv t1 = tcg_temp_new();      TCGv t1 = tcg_temp_new();
Line 3274  GEN_STFS(stfd, st64, 0x16, PPC_FLOAT); Line 3316  GEN_STFS(stfd, st64, 0x16, PPC_FLOAT);
 GEN_STFS(stfs, st32fs, 0x14, PPC_FLOAT);  GEN_STFS(stfs, st32fs, 0x14, PPC_FLOAT);
   
 /* Optional: */  /* Optional: */
 static always_inline void gen_qemu_st32fiw(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)  static inline void gen_qemu_st32fiw(DisasContext *ctx, TCGv_i64 arg1, TCGv arg2)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
     tcg_gen_trunc_i64_tl(t0, arg1),      tcg_gen_trunc_i64_tl(t0, arg1),
Line 3285  static always_inline void gen_qemu_st32f Line 3327  static always_inline void gen_qemu_st32f
 GEN_STXF(stfiw, st32fiw, 0x17, 0x1E, PPC_FLOAT_STFIWX);  GEN_STXF(stfiw, st32fiw, 0x17, 0x1E, PPC_FLOAT_STFIWX);
   
 /***                                Branch                                 ***/  /***                                Branch                                 ***/
 static always_inline void gen_goto_tb (DisasContext *ctx, int n,  static inline void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
                                        target_ulong dest)  
 {  {
     TranslationBlock *tb;      TranslationBlock *tb;
     tb = ctx->tb;      tb = ctx->tb;
Line 3318  static always_inline void gen_goto_tb (D Line 3359  static always_inline void gen_goto_tb (D
     }      }
 }  }
   
 static always_inline void gen_setlr (DisasContext *ctx, target_ulong nip)  static inline void gen_setlr(DisasContext *ctx, target_ulong nip)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     if (ctx->sf_mode == 0)      if (ctx->sf_mode == 0)
Line 3354  static void gen_b(DisasContext *ctx) Line 3395  static void gen_b(DisasContext *ctx)
 #define BCOND_LR  1  #define BCOND_LR  1
 #define BCOND_CTR 2  #define BCOND_CTR 2
   
 static always_inline void gen_bcond (DisasContext *ctx, int type)  static inline void gen_bcond(DisasContext *ctx, int type)
 {  {
     uint32_t bo = BO(ctx->opcode);      uint32_t bo = BO(ctx->opcode);
     int l1 = gen_new_label();      int l1 = gen_new_label();
Line 3690  static void spr_noaccess (void *opaque,  Line 3731  static void spr_noaccess (void *opaque, 
 #endif  #endif
   
 /* mfspr */  /* mfspr */
 static always_inline void gen_op_mfspr (DisasContext *ctx)  static inline void gen_op_mfspr(DisasContext *ctx)
 {  {
     void (*read_cb)(void *opaque, int gprn, int sprn);      void (*read_cb)(void *opaque, int gprn, int sprn);
     uint32_t sprn = SPR(ctx->opcode);      uint32_t sprn = SPR(ctx->opcode);
Line 3714  static always_inline void gen_op_mfspr ( Line 3755  static always_inline void gen_op_mfspr (
              */               */
             if (sprn != SPR_PVR) {              if (sprn != SPR_PVR) {
                 qemu_log("Trying to read privileged spr %d %03x at "                  qemu_log("Trying to read privileged spr %d %03x at "
                             ADDRX "\n", sprn, sprn, ctx->nip);                           TARGET_FMT_lx "\n", sprn, sprn, ctx->nip);
                 printf("Trying to read privileged spr %d %03x at " ADDRX "\n",                  printf("Trying to read privileged spr %d %03x at "
                        sprn, sprn, ctx->nip);                         TARGET_FMT_lx "\n", sprn, sprn, ctx->nip);
             }              }
             gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);              gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
         }          }
     } else {      } else {
         /* Not defined */          /* Not defined */
         qemu_log("Trying to read invalid spr %d %03x at "          qemu_log("Trying to read invalid spr %d %03x at "
                     ADDRX "\n", sprn, sprn, ctx->nip);                      TARGET_FMT_lx "\n", sprn, sprn, ctx->nip);
         printf("Trying to read invalid spr %d %03x at " ADDRX "\n",          printf("Trying to read invalid spr %d %03x at " TARGET_FMT_lx "\n",
                sprn, sprn, ctx->nip);                 sprn, sprn, ctx->nip);
         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_SPR);          gen_inval_exception(ctx, POWERPC_EXCP_INVAL_SPR);
     }      }
Line 3864  static void gen_mtspr(DisasContext *ctx) Line 3905  static void gen_mtspr(DisasContext *ctx)
         } else {          } else {
             /* Privilege exception */              /* Privilege exception */
             qemu_log("Trying to write privileged spr %d %03x at "              qemu_log("Trying to write privileged spr %d %03x at "
                         ADDRX "\n", sprn, sprn, ctx->nip);                       TARGET_FMT_lx "\n", sprn, sprn, ctx->nip);
             printf("Trying to write privileged spr %d %03x at " ADDRX "\n",              printf("Trying to write privileged spr %d %03x at " TARGET_FMT_lx
                    sprn, sprn, ctx->nip);                     "\n", sprn, sprn, ctx->nip);
             gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);              gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
         }          }
     } else {      } else {
         /* Not defined */          /* Not defined */
         qemu_log("Trying to write invalid spr %d %03x at "          qemu_log("Trying to write invalid spr %d %03x at "
                     ADDRX "\n", sprn, sprn, ctx->nip);                   TARGET_FMT_lx "\n", sprn, sprn, ctx->nip);
         printf("Trying to write invalid spr %d %03x at " ADDRX "\n",          printf("Trying to write invalid spr %d %03x at " TARGET_FMT_lx "\n",
                sprn, sprn, ctx->nip);                 sprn, sprn, ctx->nip);
         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_SPR);          gen_inval_exception(ctx, POWERPC_EXCP_INVAL_SPR);
     }      }
Line 5297  static void gen_tlbiva(DisasContext *ctx Line 5338  static void gen_tlbiva(DisasContext *ctx
 }  }
   
 /* All 405 MAC instructions are translated here */  /* All 405 MAC instructions are translated here */
 static always_inline void gen_405_mulladd_insn (DisasContext *ctx,  static inline void gen_405_mulladd_insn(DisasContext *ctx, int opc2, int opc3,
                                                 int opc2, int opc3,                                          int ra, int rb, int rt, int Rc)
                                                 int ra, int rb, int rt, int Rc)  
 {  {
     TCGv t0, t1;      TCGv t0, t1;
   
Line 5979  static void gen_icbt_440(DisasContext *c Line 6019  static void gen_icbt_440(DisasContext *c
 /***                      Altivec vector extension                         ***/  /***                      Altivec vector extension                         ***/
 /* Altivec registers moves */  /* Altivec registers moves */
   
 static always_inline TCGv_ptr gen_avr_ptr(int reg)  static inline TCGv_ptr gen_avr_ptr(int reg)
 {  {
     TCGv_ptr r = tcg_temp_new_ptr();      TCGv_ptr r = tcg_temp_new_ptr();
     tcg_gen_addi_ptr(r, cpu_env, offsetof(CPUPPCState, avr[reg]));      tcg_gen_addi_ptr(r, cpu_env, offsetof(CPUPPCState, avr[reg]));
Line 6463  GEN_VAFORM_PAIRED(vmaddfp, vnmsubfp, 23) Line 6503  GEN_VAFORM_PAIRED(vmaddfp, vnmsubfp, 23)
 /***                           SPE extension                               ***/  /***                           SPE extension                               ***/
 /* Register moves */  /* Register moves */
   
 static always_inline void gen_load_gpr64(TCGv_i64 t, int reg) {  static inline void gen_load_gpr64(TCGv_i64 t, int reg)
   {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     tcg_gen_mov_i64(t, cpu_gpr[reg]);      tcg_gen_mov_i64(t, cpu_gpr[reg]);
 #else  #else
Line 6471  static always_inline void gen_load_gpr64 Line 6512  static always_inline void gen_load_gpr64
 #endif  #endif
 }  }
   
 static always_inline void gen_store_gpr64(int reg, TCGv_i64 t) {  static inline void gen_store_gpr64(int reg, TCGv_i64 t)
   {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     tcg_gen_mov_i64(cpu_gpr[reg], t);      tcg_gen_mov_i64(cpu_gpr[reg], t);
 #else  #else
Line 6493  static void glue(gen_, name0##_##name1)( Line 6535  static void glue(gen_, name0##_##name1)(
 }  }
   
 /* Handler for undefined SPE opcodes */  /* Handler for undefined SPE opcodes */
 static always_inline void gen_speundef (DisasContext *ctx)  static inline void gen_speundef(DisasContext *ctx)
 {  {
     gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);      gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
 }  }
Line 6501  static always_inline void gen_speundef ( Line 6543  static always_inline void gen_speundef (
 /* SPE logic */  /* SPE logic */
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 #define GEN_SPEOP_LOGIC2(name, tcg_op)                                        \  #define GEN_SPEOP_LOGIC2(name, tcg_op)                                        \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6512  static always_inline void gen_##name (Di Line 6554  static always_inline void gen_##name (Di
 }  }
 #else  #else
 #define GEN_SPEOP_LOGIC2(name, tcg_op)                                        \  #define GEN_SPEOP_LOGIC2(name, tcg_op)                                        \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6537  GEN_SPEOP_LOGIC2(evnand, tcg_gen_nand_tl Line 6579  GEN_SPEOP_LOGIC2(evnand, tcg_gen_nand_tl
 /* SPE logic immediate */  /* SPE logic immediate */
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 #define GEN_SPEOP_TCG_LOGIC_IMM2(name, tcg_opi)                               \  #define GEN_SPEOP_TCG_LOGIC_IMM2(name, tcg_opi)                               \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6558  static always_inline void gen_##name (Di Line 6600  static always_inline void gen_##name (Di
 }  }
 #else  #else
 #define GEN_SPEOP_TCG_LOGIC_IMM2(name, tcg_opi)                               \  #define GEN_SPEOP_TCG_LOGIC_IMM2(name, tcg_opi)                               \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6578  GEN_SPEOP_TCG_LOGIC_IMM2(evrlwi, tcg_gen Line 6620  GEN_SPEOP_TCG_LOGIC_IMM2(evrlwi, tcg_gen
 /* SPE arithmetic */  /* SPE arithmetic */
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 #define GEN_SPEOP_ARITH1(name, tcg_op)                                        \  #define GEN_SPEOP_ARITH1(name, tcg_op)                                        \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6599  static always_inline void gen_##name (Di Line 6641  static always_inline void gen_##name (Di
 }  }
 #else  #else
 #define GEN_SPEOP_ARITH1(name, tcg_op)                                        \  #define GEN_SPEOP_ARITH1(name, tcg_op)                                        \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6610  static always_inline void gen_##name (Di Line 6652  static always_inline void gen_##name (Di
 }  }
 #endif  #endif
   
 static always_inline void gen_op_evabs (TCGv_i32 ret, TCGv_i32 arg1)  static inline void gen_op_evabs(TCGv_i32 ret, TCGv_i32 arg1)
 {  {
     int l1 = gen_new_label();      int l1 = gen_new_label();
     int l2 = gen_new_label();      int l2 = gen_new_label();
Line 6626  GEN_SPEOP_ARITH1(evabs, gen_op_evabs); Line 6668  GEN_SPEOP_ARITH1(evabs, gen_op_evabs);
 GEN_SPEOP_ARITH1(evneg, tcg_gen_neg_i32);  GEN_SPEOP_ARITH1(evneg, tcg_gen_neg_i32);
 GEN_SPEOP_ARITH1(evextsb, tcg_gen_ext8s_i32);  GEN_SPEOP_ARITH1(evextsb, tcg_gen_ext8s_i32);
 GEN_SPEOP_ARITH1(evextsh, tcg_gen_ext16s_i32);  GEN_SPEOP_ARITH1(evextsh, tcg_gen_ext16s_i32);
 static always_inline void gen_op_evrndw (TCGv_i32 ret, TCGv_i32 arg1)  static inline void gen_op_evrndw(TCGv_i32 ret, TCGv_i32 arg1)
 {  {
     tcg_gen_addi_i32(ret, arg1, 0x8000);      tcg_gen_addi_i32(ret, arg1, 0x8000);
     tcg_gen_ext16u_i32(ret, ret);      tcg_gen_ext16u_i32(ret, ret);
Line 6637  GEN_SPEOP_ARITH1(evcntlzw, gen_helper_cn Line 6679  GEN_SPEOP_ARITH1(evcntlzw, gen_helper_cn
   
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 #define GEN_SPEOP_ARITH2(name, tcg_op)                                        \  #define GEN_SPEOP_ARITH2(name, tcg_op)                                        \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6663  static always_inline void gen_##name (Di Line 6705  static always_inline void gen_##name (Di
 }  }
 #else  #else
 #define GEN_SPEOP_ARITH2(name, tcg_op)                                        \  #define GEN_SPEOP_ARITH2(name, tcg_op)                                        \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6676  static always_inline void gen_##name (Di Line 6718  static always_inline void gen_##name (Di
 }  }
 #endif  #endif
   
 static always_inline void gen_op_evsrwu (TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)  static inline void gen_op_evsrwu(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 {  {
     TCGv_i32 t0;      TCGv_i32 t0;
     int l1, l2;      int l1, l2;
Line 6695  static always_inline void gen_op_evsrwu  Line 6737  static always_inline void gen_op_evsrwu 
     tcg_temp_free_i32(t0);      tcg_temp_free_i32(t0);
 }  }
 GEN_SPEOP_ARITH2(evsrwu, gen_op_evsrwu);  GEN_SPEOP_ARITH2(evsrwu, gen_op_evsrwu);
 static always_inline void gen_op_evsrws (TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)  static inline void gen_op_evsrws(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 {  {
     TCGv_i32 t0;      TCGv_i32 t0;
     int l1, l2;      int l1, l2;
Line 6714  static always_inline void gen_op_evsrws  Line 6756  static always_inline void gen_op_evsrws 
     tcg_temp_free_i32(t0);      tcg_temp_free_i32(t0);
 }  }
 GEN_SPEOP_ARITH2(evsrws, gen_op_evsrws);  GEN_SPEOP_ARITH2(evsrws, gen_op_evsrws);
 static always_inline void gen_op_evslw (TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)  static inline void gen_op_evslw(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 {  {
     TCGv_i32 t0;      TCGv_i32 t0;
     int l1, l2;      int l1, l2;
Line 6733  static always_inline void gen_op_evslw ( Line 6775  static always_inline void gen_op_evslw (
     tcg_temp_free_i32(t0);      tcg_temp_free_i32(t0);
 }  }
 GEN_SPEOP_ARITH2(evslw, gen_op_evslw);  GEN_SPEOP_ARITH2(evslw, gen_op_evslw);
 static always_inline void gen_op_evrlw (TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)  static inline void gen_op_evrlw(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 {  {
     TCGv_i32 t0 = tcg_temp_new_i32();      TCGv_i32 t0 = tcg_temp_new_i32();
     tcg_gen_andi_i32(t0, arg2, 0x1F);      tcg_gen_andi_i32(t0, arg2, 0x1F);
Line 6741  static always_inline void gen_op_evrlw ( Line 6783  static always_inline void gen_op_evrlw (
     tcg_temp_free_i32(t0);      tcg_temp_free_i32(t0);
 }  }
 GEN_SPEOP_ARITH2(evrlw, gen_op_evrlw);  GEN_SPEOP_ARITH2(evrlw, gen_op_evrlw);
 static always_inline void gen_evmergehi (DisasContext *ctx)  static inline void gen_evmergehi(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 6761  static always_inline void gen_evmergehi  Line 6803  static always_inline void gen_evmergehi 
 #endif  #endif
 }  }
 GEN_SPEOP_ARITH2(evaddw, tcg_gen_add_i32);  GEN_SPEOP_ARITH2(evaddw, tcg_gen_add_i32);
 static always_inline void gen_op_evsubf (TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)  static inline void gen_op_evsubf(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 {  {
     tcg_gen_sub_i32(ret, arg2, arg1);      tcg_gen_sub_i32(ret, arg2, arg1);
 }  }
Line 6770  GEN_SPEOP_ARITH2(evsubfw, gen_op_evsubf) Line 6812  GEN_SPEOP_ARITH2(evsubfw, gen_op_evsubf)
 /* SPE arithmetic immediate */  /* SPE arithmetic immediate */
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 #define GEN_SPEOP_ARITH_IMM2(name, tcg_op)                                    \  #define GEN_SPEOP_ARITH_IMM2(name, tcg_op)                                    \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6791  static always_inline void gen_##name (Di Line 6833  static always_inline void gen_##name (Di
 }  }
 #else  #else
 #define GEN_SPEOP_ARITH_IMM2(name, tcg_op)                                    \  #define GEN_SPEOP_ARITH_IMM2(name, tcg_op)                                    \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6809  GEN_SPEOP_ARITH_IMM2(evsubifw, tcg_gen_s Line 6851  GEN_SPEOP_ARITH_IMM2(evsubifw, tcg_gen_s
 /* SPE comparison */  /* SPE comparison */
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 #define GEN_SPEOP_COMP(name, tcg_cond)                                        \  #define GEN_SPEOP_COMP(name, tcg_cond)                                        \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6849  static always_inline void gen_##name (Di Line 6891  static always_inline void gen_##name (Di
 }  }
 #else  #else
 #define GEN_SPEOP_COMP(name, tcg_cond)                                        \  #define GEN_SPEOP_COMP(name, tcg_cond)                                        \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 6886  GEN_SPEOP_COMP(evcmplts, TCG_COND_LT); Line 6928  GEN_SPEOP_COMP(evcmplts, TCG_COND_LT);
 GEN_SPEOP_COMP(evcmpeq, TCG_COND_EQ);  GEN_SPEOP_COMP(evcmpeq, TCG_COND_EQ);
   
 /* SPE misc */  /* SPE misc */
 static always_inline void gen_brinc (DisasContext *ctx)  static inline void gen_brinc(DisasContext *ctx)
 {  {
     /* Note: brinc is usable even if SPE is disabled */      /* Note: brinc is usable even if SPE is disabled */
     gen_helper_brinc(cpu_gpr[rD(ctx->opcode)],      gen_helper_brinc(cpu_gpr[rD(ctx->opcode)],
                      cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);                       cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
 }  }
 static always_inline void gen_evmergelo (DisasContext *ctx)  static inline void gen_evmergelo(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 6911  static always_inline void gen_evmergelo  Line 6953  static always_inline void gen_evmergelo 
     tcg_gen_mov_i32(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);      tcg_gen_mov_i32(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
 #endif  #endif
 }  }
 static always_inline void gen_evmergehilo (DisasContext *ctx)  static inline void gen_evmergehilo(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 6930  static always_inline void gen_evmergehil Line 6972  static always_inline void gen_evmergehil
     tcg_gen_mov_i32(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rA(ctx->opcode)]);      tcg_gen_mov_i32(cpu_gprh[rD(ctx->opcode)], cpu_gprh[rA(ctx->opcode)]);
 #endif  #endif
 }  }
 static always_inline void gen_evmergelohi (DisasContext *ctx)  static inline void gen_evmergelohi(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 6957  static always_inline void gen_evmergeloh Line 6999  static always_inline void gen_evmergeloh
     }      }
 #endif  #endif
 }  }
 static always_inline void gen_evsplati (DisasContext *ctx)  static inline void gen_evsplati(DisasContext *ctx)
 {  {
     uint64_t imm = ((int32_t)(rA(ctx->opcode) << 11)) >> 27;      uint64_t imm = ((int32_t)(rA(ctx->opcode) << 11)) >> 27;
   
Line 6968  static always_inline void gen_evsplati ( Line 7010  static always_inline void gen_evsplati (
     tcg_gen_movi_i32(cpu_gprh[rD(ctx->opcode)], imm);      tcg_gen_movi_i32(cpu_gprh[rD(ctx->opcode)], imm);
 #endif  #endif
 }  }
 static always_inline void gen_evsplatfi (DisasContext *ctx)  static inline void gen_evsplatfi(DisasContext *ctx)
 {  {
     uint64_t imm = rA(ctx->opcode) << 11;      uint64_t imm = rA(ctx->opcode) << 11;
   
Line 6980  static always_inline void gen_evsplatfi  Line 7022  static always_inline void gen_evsplatfi 
 #endif  #endif
 }  }
   
 static always_inline void gen_evsel (DisasContext *ctx)  static inline void gen_evsel(DisasContext *ctx)
 {  {
     int l1 = gen_new_label();      int l1 = gen_new_label();
     int l2 = gen_new_label();      int l2 = gen_new_label();
Line 7076  GEN_SPE(evcmpltu,       evcmplts,      0 Line 7118  GEN_SPE(evcmpltu,       evcmplts,      0
 GEN_SPE(evcmpeq,        speundef,      0x1A, 0x08, 0x00600000, PPC_SPE); ////  GEN_SPE(evcmpeq,        speundef,      0x1A, 0x08, 0x00600000, PPC_SPE); ////
   
 /* SPE load and stores */  /* SPE load and stores */
 static always_inline void gen_addr_spe_imm_index (DisasContext *ctx, TCGv EA, int sh)  static inline void gen_addr_spe_imm_index(DisasContext *ctx, TCGv EA, int sh)
 {  {
     target_ulong uimm = rB(ctx->opcode);      target_ulong uimm = rB(ctx->opcode);
   
Line 7092  static always_inline void gen_addr_spe_i Line 7134  static always_inline void gen_addr_spe_i
     }      }
 }  }
   
 static always_inline void gen_op_evldd(DisasContext *ctx, TCGv addr)  static inline void gen_op_evldd(DisasContext *ctx, TCGv addr)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     gen_qemu_ld64(ctx, cpu_gpr[rD(ctx->opcode)], addr);      gen_qemu_ld64(ctx, cpu_gpr[rD(ctx->opcode)], addr);
Line 7106  static always_inline void gen_op_evldd(D Line 7148  static always_inline void gen_op_evldd(D
 #endif  #endif
 }  }
   
 static always_inline void gen_op_evldw(DisasContext *ctx, TCGv addr)  static inline void gen_op_evldw(DisasContext *ctx, TCGv addr)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
Line 7123  static always_inline void gen_op_evldw(D Line 7165  static always_inline void gen_op_evldw(D
 #endif  #endif
 }  }
   
 static always_inline void gen_op_evldh(DisasContext *ctx, TCGv addr)  static inline void gen_op_evldh(DisasContext *ctx, TCGv addr)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
Line 7156  static always_inline void gen_op_evldh(D Line 7198  static always_inline void gen_op_evldh(D
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static always_inline void gen_op_evlhhesplat(DisasContext *ctx, TCGv addr)  static inline void gen_op_evlhhesplat(DisasContext *ctx, TCGv addr)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
     gen_qemu_ld16u(ctx, t0, addr);      gen_qemu_ld16u(ctx, t0, addr);
Line 7172  static always_inline void gen_op_evlhhes Line 7214  static always_inline void gen_op_evlhhes
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static always_inline void gen_op_evlhhousplat(DisasContext *ctx, TCGv addr)  static inline void gen_op_evlhhousplat(DisasContext *ctx, TCGv addr)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
     gen_qemu_ld16u(ctx, t0, addr);      gen_qemu_ld16u(ctx, t0, addr);
Line 7186  static always_inline void gen_op_evlhhou Line 7228  static always_inline void gen_op_evlhhou
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static always_inline void gen_op_evlhhossplat(DisasContext *ctx, TCGv addr)  static inline void gen_op_evlhhossplat(DisasContext *ctx, TCGv addr)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
     gen_qemu_ld16s(ctx, t0, addr);      gen_qemu_ld16s(ctx, t0, addr);
Line 7201  static always_inline void gen_op_evlhhos Line 7243  static always_inline void gen_op_evlhhos
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static always_inline void gen_op_evlwhe(DisasContext *ctx, TCGv addr)  static inline void gen_op_evlwhe(DisasContext *ctx, TCGv addr)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
Line 7221  static always_inline void gen_op_evlwhe( Line 7263  static always_inline void gen_op_evlwhe(
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static always_inline void gen_op_evlwhou(DisasContext *ctx, TCGv addr)  static inline void gen_op_evlwhou(DisasContext *ctx, TCGv addr)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
Line 7238  static always_inline void gen_op_evlwhou Line 7280  static always_inline void gen_op_evlwhou
 #endif  #endif
 }  }
   
 static always_inline void gen_op_evlwhos(DisasContext *ctx, TCGv addr)  static inline void gen_op_evlwhos(DisasContext *ctx, TCGv addr)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
Line 7256  static always_inline void gen_op_evlwhos Line 7298  static always_inline void gen_op_evlwhos
 #endif  #endif
 }  }
   
 static always_inline void gen_op_evlwwsplat(DisasContext *ctx, TCGv addr)  static inline void gen_op_evlwwsplat(DisasContext *ctx, TCGv addr)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
     gen_qemu_ld32u(ctx, t0, addr);      gen_qemu_ld32u(ctx, t0, addr);
Line 7270  static always_inline void gen_op_evlwwsp Line 7312  static always_inline void gen_op_evlwwsp
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static always_inline void gen_op_evlwhsplat(DisasContext *ctx, TCGv addr)  static inline void gen_op_evlwhsplat(DisasContext *ctx, TCGv addr)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
Line 7295  static always_inline void gen_op_evlwhsp Line 7337  static always_inline void gen_op_evlwhsp
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static always_inline void gen_op_evstdd(DisasContext *ctx, TCGv addr)  static inline void gen_op_evstdd(DisasContext *ctx, TCGv addr)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     gen_qemu_st64(ctx, cpu_gpr[rS(ctx->opcode)], addr);      gen_qemu_st64(ctx, cpu_gpr[rS(ctx->opcode)], addr);
Line 7307  static always_inline void gen_op_evstdd( Line 7349  static always_inline void gen_op_evstdd(
 #endif  #endif
 }  }
   
 static always_inline void gen_op_evstdw(DisasContext *ctx, TCGv addr)  static inline void gen_op_evstdw(DisasContext *ctx, TCGv addr)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
Line 7321  static always_inline void gen_op_evstdw( Line 7363  static always_inline void gen_op_evstdw(
     gen_qemu_st32(ctx, cpu_gpr[rS(ctx->opcode)], addr);      gen_qemu_st32(ctx, cpu_gpr[rS(ctx->opcode)], addr);
 }  }
   
 static always_inline void gen_op_evstdh(DisasContext *ctx, TCGv addr)  static inline void gen_op_evstdh(DisasContext *ctx, TCGv addr)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
Line 7345  static always_inline void gen_op_evstdh( Line 7387  static always_inline void gen_op_evstdh(
     gen_qemu_st16(ctx, cpu_gpr[rS(ctx->opcode)], addr);      gen_qemu_st16(ctx, cpu_gpr[rS(ctx->opcode)], addr);
 }  }
   
 static always_inline void gen_op_evstwhe(DisasContext *ctx, TCGv addr)  static inline void gen_op_evstwhe(DisasContext *ctx, TCGv addr)
 {  {
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
Line 7360  static always_inline void gen_op_evstwhe Line 7402  static always_inline void gen_op_evstwhe
     tcg_temp_free(t0);      tcg_temp_free(t0);
 }  }
   
 static always_inline void gen_op_evstwho(DisasContext *ctx, TCGv addr)  static inline void gen_op_evstwho(DisasContext *ctx, TCGv addr)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
Line 7374  static always_inline void gen_op_evstwho Line 7416  static always_inline void gen_op_evstwho
     gen_qemu_st16(ctx, cpu_gpr[rS(ctx->opcode)], addr);      gen_qemu_st16(ctx, cpu_gpr[rS(ctx->opcode)], addr);
 }  }
   
 static always_inline void gen_op_evstwwe(DisasContext *ctx, TCGv addr)  static inline void gen_op_evstwwe(DisasContext *ctx, TCGv addr)
 {  {
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
     TCGv t0 = tcg_temp_new();      TCGv t0 = tcg_temp_new();
Line 7386  static always_inline void gen_op_evstwwe Line 7428  static always_inline void gen_op_evstwwe
 #endif  #endif
 }  }
   
 static always_inline void gen_op_evstwwo(DisasContext *ctx, TCGv addr)  static inline void gen_op_evstwwo(DisasContext *ctx, TCGv addr)
 {  {
     gen_qemu_st32(ctx, cpu_gpr[rS(ctx->opcode)], addr);      gen_qemu_st32(ctx, cpu_gpr[rS(ctx->opcode)], addr);
 }  }
Line 7509  GEN_SPE(speundef,       evmwsmfan,     0 Line 7551  GEN_SPE(speundef,       evmwsmfan,     0
 /***                      SPE floating-point extension                     ***/  /***                      SPE floating-point extension                     ***/
 #if defined(TARGET_PPC64)  #if defined(TARGET_PPC64)
 #define GEN_SPEFPUOP_CONV_32_32(name)                                         \  #define GEN_SPEFPUOP_CONV_32_32(name)                                         \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     TCGv_i32 t0;                                                              \      TCGv_i32 t0;                                                              \
     TCGv t1;                                                                  \      TCGv t1;                                                                  \
Line 7525  static always_inline void gen_##name (Di Line 7567  static always_inline void gen_##name (Di
     tcg_temp_free(t1);                                                        \      tcg_temp_free(t1);                                                        \
 }  }
 #define GEN_SPEFPUOP_CONV_32_64(name)                                         \  #define GEN_SPEFPUOP_CONV_32_64(name)                                         \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     TCGv_i32 t0;                                                              \      TCGv_i32 t0;                                                              \
     TCGv t1;                                                                  \      TCGv t1;                                                                  \
Line 7540  static always_inline void gen_##name (Di Line 7582  static always_inline void gen_##name (Di
     tcg_temp_free(t1);                                                        \      tcg_temp_free(t1);                                                        \
 }  }
 #define GEN_SPEFPUOP_CONV_64_32(name)                                         \  #define GEN_SPEFPUOP_CONV_64_32(name)                                         \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     TCGv_i32 t0 = tcg_temp_new_i32();                                         \      TCGv_i32 t0 = tcg_temp_new_i32();                                         \
     tcg_gen_trunc_tl_i32(t0, cpu_gpr[rB(ctx->opcode)]);                       \      tcg_gen_trunc_tl_i32(t0, cpu_gpr[rB(ctx->opcode)]);                       \
Line 7548  static always_inline void gen_##name (Di Line 7590  static always_inline void gen_##name (Di
     tcg_temp_free_i32(t0);                                                    \      tcg_temp_free_i32(t0);                                                    \
 }  }
 #define GEN_SPEFPUOP_CONV_64_64(name)                                         \  #define GEN_SPEFPUOP_CONV_64_64(name)                                         \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     gen_helper_##name(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);    \      gen_helper_##name(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);    \
 }  }
 #define GEN_SPEFPUOP_ARITH2_32_32(name)                                       \  #define GEN_SPEFPUOP_ARITH2_32_32(name)                                       \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     TCGv_i32 t0, t1;                                                          \      TCGv_i32 t0, t1;                                                          \
     TCGv_i64 t2;                                                              \      TCGv_i64 t2;                                                              \
Line 7576  static always_inline void gen_##name (Di Line 7618  static always_inline void gen_##name (Di
     tcg_temp_free(t2);                                                        \      tcg_temp_free(t2);                                                        \
 }  }
 #define GEN_SPEFPUOP_ARITH2_64_64(name)                                       \  #define GEN_SPEFPUOP_ARITH2_64_64(name)                                       \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 7586  static always_inline void gen_##name (Di Line 7628  static always_inline void gen_##name (Di
                       cpu_gpr[rB(ctx->opcode)]);                              \                        cpu_gpr[rB(ctx->opcode)]);                              \
 }  }
 #define GEN_SPEFPUOP_COMP_32(name)                                            \  #define GEN_SPEFPUOP_COMP_32(name)                                            \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     TCGv_i32 t0, t1;                                                          \      TCGv_i32 t0, t1;                                                          \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
Line 7602  static always_inline void gen_##name (Di Line 7644  static always_inline void gen_##name (Di
     tcg_temp_free_i32(t1);                                                    \      tcg_temp_free_i32(t1);                                                    \
 }  }
 #define GEN_SPEFPUOP_COMP_64(name)                                            \  #define GEN_SPEFPUOP_COMP_64(name)                                            \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 7613  static always_inline void gen_##name (Di Line 7655  static always_inline void gen_##name (Di
 }  }
 #else  #else
 #define GEN_SPEFPUOP_CONV_32_32(name)                                         \  #define GEN_SPEFPUOP_CONV_32_32(name)                                         \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     gen_helper_##name(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);    \      gen_helper_##name(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);    \
 }  }
 #define GEN_SPEFPUOP_CONV_32_64(name)                                         \  #define GEN_SPEFPUOP_CONV_32_64(name)                                         \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     TCGv_i64 t0 = tcg_temp_new_i64();                                         \      TCGv_i64 t0 = tcg_temp_new_i64();                                         \
     gen_load_gpr64(t0, rB(ctx->opcode));                                      \      gen_load_gpr64(t0, rB(ctx->opcode));                                      \
Line 7626  static always_inline void gen_##name (Di Line 7668  static always_inline void gen_##name (Di
     tcg_temp_free_i64(t0);                                                    \      tcg_temp_free_i64(t0);                                                    \
 }  }
 #define GEN_SPEFPUOP_CONV_64_32(name)                                         \  #define GEN_SPEFPUOP_CONV_64_32(name)                                         \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     TCGv_i64 t0 = tcg_temp_new_i64();                                         \      TCGv_i64 t0 = tcg_temp_new_i64();                                         \
     gen_helper_##name(t0, cpu_gpr[rB(ctx->opcode)]);                          \      gen_helper_##name(t0, cpu_gpr[rB(ctx->opcode)]);                          \
Line 7634  static always_inline void gen_##name (Di Line 7676  static always_inline void gen_##name (Di
     tcg_temp_free_i64(t0);                                                    \      tcg_temp_free_i64(t0);                                                    \
 }  }
 #define GEN_SPEFPUOP_CONV_64_64(name)                                         \  #define GEN_SPEFPUOP_CONV_64_64(name)                                         \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     TCGv_i64 t0 = tcg_temp_new_i64();                                         \      TCGv_i64 t0 = tcg_temp_new_i64();                                         \
     gen_load_gpr64(t0, rB(ctx->opcode));                                      \      gen_load_gpr64(t0, rB(ctx->opcode));                                      \
Line 7643  static always_inline void gen_##name (Di Line 7685  static always_inline void gen_##name (Di
     tcg_temp_free_i64(t0);                                                    \      tcg_temp_free_i64(t0);                                                    \
 }  }
 #define GEN_SPEFPUOP_ARITH2_32_32(name)                                       \  #define GEN_SPEFPUOP_ARITH2_32_32(name)                                       \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 7653  static always_inline void gen_##name (Di Line 7695  static always_inline void gen_##name (Di
                       cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);    \                        cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);    \
 }  }
 #define GEN_SPEFPUOP_ARITH2_64_64(name)                                       \  #define GEN_SPEFPUOP_ARITH2_64_64(name)                                       \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     TCGv_i64 t0, t1;                                                          \      TCGv_i64 t0, t1;                                                          \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
Line 7670  static always_inline void gen_##name (Di Line 7712  static always_inline void gen_##name (Di
     tcg_temp_free_i64(t1);                                                    \      tcg_temp_free_i64(t1);                                                    \
 }  }
 #define GEN_SPEFPUOP_COMP_32(name)                                            \  #define GEN_SPEFPUOP_COMP_32(name)                                            \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
         gen_exception(ctx, POWERPC_EXCP_APU);                                 \          gen_exception(ctx, POWERPC_EXCP_APU);                                 \
Line 7680  static always_inline void gen_##name (Di Line 7722  static always_inline void gen_##name (Di
                       cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);    \                        cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);    \
 }  }
 #define GEN_SPEFPUOP_COMP_64(name)                                            \  #define GEN_SPEFPUOP_COMP_64(name)                                            \
 static always_inline void gen_##name (DisasContext *ctx)                      \  static inline void gen_##name(DisasContext *ctx)                              \
 {                                                                             \  {                                                                             \
     TCGv_i64 t0, t1;                                                          \      TCGv_i64 t0, t1;                                                          \
     if (unlikely(!ctx->spe_enabled)) {                                        \      if (unlikely(!ctx->spe_enabled)) {                                        \
Line 7703  GEN_SPEFPUOP_ARITH2_64_64(evfsadd); Line 7745  GEN_SPEFPUOP_ARITH2_64_64(evfsadd);
 GEN_SPEFPUOP_ARITH2_64_64(evfssub);  GEN_SPEFPUOP_ARITH2_64_64(evfssub);
 GEN_SPEFPUOP_ARITH2_64_64(evfsmul);  GEN_SPEFPUOP_ARITH2_64_64(evfsmul);
 GEN_SPEFPUOP_ARITH2_64_64(evfsdiv);  GEN_SPEFPUOP_ARITH2_64_64(evfsdiv);
 static always_inline void gen_evfsabs (DisasContext *ctx)  static inline void gen_evfsabs(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 7716  static always_inline void gen_evfsabs (D Line 7758  static always_inline void gen_evfsabs (D
     tcg_gen_andi_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], ~0x80000000);      tcg_gen_andi_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], ~0x80000000);
 #endif  #endif
 }  }
 static always_inline void gen_evfsnabs (DisasContext *ctx)  static inline void gen_evfsnabs(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 7729  static always_inline void gen_evfsnabs ( Line 7771  static always_inline void gen_evfsnabs (
     tcg_gen_ori_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], 0x80000000);      tcg_gen_ori_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], 0x80000000);
 #endif  #endif
 }  }
 static always_inline void gen_evfsneg (DisasContext *ctx)  static inline void gen_evfsneg(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 7785  GEN_SPEFPUOP_ARITH2_32_32(efsadd); Line 7827  GEN_SPEFPUOP_ARITH2_32_32(efsadd);
 GEN_SPEFPUOP_ARITH2_32_32(efssub);  GEN_SPEFPUOP_ARITH2_32_32(efssub);
 GEN_SPEFPUOP_ARITH2_32_32(efsmul);  GEN_SPEFPUOP_ARITH2_32_32(efsmul);
 GEN_SPEFPUOP_ARITH2_32_32(efsdiv);  GEN_SPEFPUOP_ARITH2_32_32(efsdiv);
 static always_inline void gen_efsabs (DisasContext *ctx)  static inline void gen_efsabs(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 7793  static always_inline void gen_efsabs (Di Line 7835  static always_inline void gen_efsabs (Di
     }      }
     tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], (target_long)~0x80000000LL);      tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], (target_long)~0x80000000LL);
 }  }
 static always_inline void gen_efsnabs (DisasContext *ctx)  static inline void gen_efsnabs(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 7801  static always_inline void gen_efsnabs (D Line 7843  static always_inline void gen_efsnabs (D
     }      }
     tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x80000000);      tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x80000000);
 }  }
 static always_inline void gen_efsneg (DisasContext *ctx)  static inline void gen_efsneg(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 7853  GEN_SPEFPUOP_ARITH2_64_64(efdadd); Line 7895  GEN_SPEFPUOP_ARITH2_64_64(efdadd);
 GEN_SPEFPUOP_ARITH2_64_64(efdsub);  GEN_SPEFPUOP_ARITH2_64_64(efdsub);
 GEN_SPEFPUOP_ARITH2_64_64(efdmul);  GEN_SPEFPUOP_ARITH2_64_64(efdmul);
 GEN_SPEFPUOP_ARITH2_64_64(efddiv);  GEN_SPEFPUOP_ARITH2_64_64(efddiv);
 static always_inline void gen_efdabs (DisasContext *ctx)  static inline void gen_efdabs(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 7865  static always_inline void gen_efdabs (Di Line 7907  static always_inline void gen_efdabs (Di
     tcg_gen_andi_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], ~0x80000000);      tcg_gen_andi_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], ~0x80000000);
 #endif  #endif
 }  }
 static always_inline void gen_efdnabs (DisasContext *ctx)  static inline void gen_efdnabs(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 7877  static always_inline void gen_efdnabs (D Line 7919  static always_inline void gen_efdnabs (D
     tcg_gen_ori_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], 0x80000000);      tcg_gen_ori_tl(cpu_gprh[rA(ctx->opcode)], cpu_gprh[rA(ctx->opcode)], 0x80000000);
 #endif  #endif
 }  }
 static always_inline void gen_efdneg (DisasContext *ctx)  static inline void gen_efdneg(DisasContext *ctx)
 {  {
     if (unlikely(!ctx->spe_enabled)) {      if (unlikely(!ctx->spe_enabled)) {
         gen_exception(ctx, POWERPC_EXCP_APU);          gen_exception(ctx, POWERPC_EXCP_APU);
Line 8797  void cpu_dump_state (CPUState *env, FILE Line 8839  void cpu_dump_state (CPUState *env, FILE
   
     int i;      int i;
   
     cpu_fprintf(f, "NIP " ADDRX "   LR " ADDRX " CTR " ADDRX " XER %08x\n",      cpu_fprintf(f, "NIP " TARGET_FMT_lx "   LR " TARGET_FMT_lx " CTR "
                 env->nip, env->lr, env->ctr, env->xer);                  TARGET_FMT_lx " XER %08x\n", env->nip, env->lr, env->ctr,
     cpu_fprintf(f, "MSR " ADDRX " HID0 " ADDRX "  HF " ADDRX " idx %d\n",                  env->xer);
                 env->msr, env->spr[SPR_HID0], env->hflags, env->mmu_idx);      cpu_fprintf(f, "MSR " TARGET_FMT_lx " HID0 " TARGET_FMT_lx "  HF "
                   TARGET_FMT_lx " idx %d\n", env->msr, env->spr[SPR_HID0],
                   env->hflags, env->mmu_idx);
 #if !defined(NO_TIMER_DUMP)  #if !defined(NO_TIMER_DUMP)
     cpu_fprintf(f, "TB %08x %08x "      cpu_fprintf(f, "TB %08x %08x "
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
Line 8816  void cpu_dump_state (CPUState *env, FILE Line 8860  void cpu_dump_state (CPUState *env, FILE
     for (i = 0; i < 32; i++) {      for (i = 0; i < 32; i++) {
         if ((i & (RGPL - 1)) == 0)          if ((i & (RGPL - 1)) == 0)
             cpu_fprintf(f, "GPR%02d", i);              cpu_fprintf(f, "GPR%02d", i);
         cpu_fprintf(f, " " REGX, ppc_dump_gpr(env, i));          cpu_fprintf(f, " %016" PRIx64, ppc_dump_gpr(env, i));
         if ((i & (RGPL - 1)) == (RGPL - 1))          if ((i & (RGPL - 1)) == (RGPL - 1))
             cpu_fprintf(f, "\n");              cpu_fprintf(f, "\n");
     }      }
Line 8834  void cpu_dump_state (CPUState *env, FILE Line 8878  void cpu_dump_state (CPUState *env, FILE
             a = 'E';              a = 'E';
         cpu_fprintf(f, " %c%c", a, env->crf[i] & 0x01 ? 'O' : ' ');          cpu_fprintf(f, " %c%c", a, env->crf[i] & 0x01 ? 'O' : ' ');
     }      }
     cpu_fprintf(f, " ]             RES " ADDRX "\n", env->reserve);      cpu_fprintf(f, " ]             RES " TARGET_FMT_lx "\n",
                   env->reserve_addr);
     for (i = 0; i < 32; i++) {      for (i = 0; i < 32; i++) {
         if ((i & (RFPL - 1)) == 0)          if ((i & (RFPL - 1)) == 0)
             cpu_fprintf(f, "FPR%02d", i);              cpu_fprintf(f, "FPR%02d", i);
Line 8844  void cpu_dump_state (CPUState *env, FILE Line 8889  void cpu_dump_state (CPUState *env, FILE
     }      }
     cpu_fprintf(f, "FPSCR %08x\n", env->fpscr);      cpu_fprintf(f, "FPSCR %08x\n", env->fpscr);
 #if !defined(CONFIG_USER_ONLY)  #if !defined(CONFIG_USER_ONLY)
     cpu_fprintf(f, "SRR0 " ADDRX " SRR1 " ADDRX " SDR1 " ADDRX "\n",      cpu_fprintf(f, "SRR0 " TARGET_FMT_lx " SRR1 " TARGET_FMT_lx " SDR1 "
                 env->spr[SPR_SRR0], env->spr[SPR_SRR1], env->sdr1);                  TARGET_FMT_lx "\n", env->spr[SPR_SRR0], env->spr[SPR_SRR1],
                   env->sdr1);
 #endif  #endif
   
 #undef RGPL  #undef RGPL
Line 8900  void cpu_dump_statistics (CPUState *env, Line 8946  void cpu_dump_statistics (CPUState *env,
 }  }
   
 /*****************************************************************************/  /*****************************************************************************/
 static always_inline void gen_intermediate_code_internal (CPUState *env,  static inline void gen_intermediate_code_internal(CPUState *env,
                                                           TranslationBlock *tb,                                                    TranslationBlock *tb,
                                                           int search_pc)                                                    int search_pc)
 {  {
     DisasContext ctx, *ctxp = &ctx;      DisasContext ctx, *ctxp = &ctx;
     opc_handler_t **table, *handler;      opc_handler_t **table, *handler;
Line 8954  static always_inline void gen_intermedia Line 9000  static always_inline void gen_intermedia
     gen_icount_start();      gen_icount_start();
     /* Set env in case of segfault during code fetch */      /* Set env in case of segfault during code fetch */
     while (ctx.exception == POWERPC_EXCP_NONE && gen_opc_ptr < gen_opc_end) {      while (ctx.exception == POWERPC_EXCP_NONE && gen_opc_ptr < gen_opc_end) {
         if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) {          if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
             TAILQ_FOREACH(bp, &env->breakpoints, entry) {              QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
                 if (bp->pc == ctx.nip) {                  if (bp->pc == ctx.nip) {
                     gen_debug_exception(ctxp);                      gen_debug_exception(ctxp);
                     break;                      break;
Line 8974  static always_inline void gen_intermedia Line 9020  static always_inline void gen_intermedia
             gen_opc_icount[lj] = num_insns;              gen_opc_icount[lj] = num_insns;
         }          }
         LOG_DISAS("----------------\n");          LOG_DISAS("----------------\n");
         LOG_DISAS("nip=" ADDRX " super=%d ir=%d\n",          LOG_DISAS("nip=" TARGET_FMT_lx " super=%d ir=%d\n",
                   ctx.nip, ctx.mem_idx, (int)msr_ir);                    ctx.nip, ctx.mem_idx, (int)msr_ir);
         if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))          if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
             gen_io_start();              gen_io_start();
Line 8986  static always_inline void gen_intermedia Line 9032  static always_inline void gen_intermedia
         LOG_DISAS("translate opcode %08x (%02x %02x %02x) (%s)\n",          LOG_DISAS("translate opcode %08x (%02x %02x %02x) (%s)\n",
                     ctx.opcode, opc1(ctx.opcode), opc2(ctx.opcode),                      ctx.opcode, opc1(ctx.opcode), opc2(ctx.opcode),
                     opc3(ctx.opcode), little_endian ? "little" : "big");                      opc3(ctx.opcode), little_endian ? "little" : "big");
           if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP)))
               tcg_gen_debug_insn_start(ctx.nip);
         ctx.nip += 4;          ctx.nip += 4;
         table = env->opcodes;          table = env->opcodes;
         num_insns++;          num_insns++;
Line 9002  static always_inline void gen_intermedia Line 9050  static always_inline void gen_intermedia
         if (unlikely(handler->handler == &gen_invalid)) {          if (unlikely(handler->handler == &gen_invalid)) {
             if (qemu_log_enabled()) {              if (qemu_log_enabled()) {
                 qemu_log("invalid/unsupported opcode: "                  qemu_log("invalid/unsupported opcode: "
                           "%02x - %02x - %02x (%08x) " ADDRX " %d\n",                           "%02x - %02x - %02x (%08x) " TARGET_FMT_lx " %d\n",
                           opc1(ctx.opcode), opc2(ctx.opcode),                           opc1(ctx.opcode), opc2(ctx.opcode),
                           opc3(ctx.opcode), ctx.opcode, ctx.nip - 4, (int)msr_ir);                           opc3(ctx.opcode), ctx.opcode, ctx.nip - 4, (int)msr_ir);
             } else {              } else {
                 printf("invalid/unsupported opcode: "                  printf("invalid/unsupported opcode: "
                        "%02x - %02x - %02x (%08x) " ADDRX " %d\n",                         "%02x - %02x - %02x (%08x) " TARGET_FMT_lx " %d\n",
                        opc1(ctx.opcode), opc2(ctx.opcode),                         opc1(ctx.opcode), opc2(ctx.opcode),
                        opc3(ctx.opcode), ctx.opcode, ctx.nip - 4, (int)msr_ir);                         opc3(ctx.opcode), ctx.opcode, ctx.nip - 4, (int)msr_ir);
             }              }
Line 9015  static always_inline void gen_intermedia Line 9063  static always_inline void gen_intermedia
             if (unlikely((ctx.opcode & handler->inval) != 0)) {              if (unlikely((ctx.opcode & handler->inval) != 0)) {
                 if (qemu_log_enabled()) {                  if (qemu_log_enabled()) {
                     qemu_log("invalid bits: %08x for opcode: "                      qemu_log("invalid bits: %08x for opcode: "
                               "%02x - %02x - %02x (%08x) " ADDRX "\n",                               "%02x - %02x - %02x (%08x) " TARGET_FMT_lx "\n",
                               ctx.opcode & handler->inval, opc1(ctx.opcode),                               ctx.opcode & handler->inval, opc1(ctx.opcode),
                               opc2(ctx.opcode), opc3(ctx.opcode),                               opc2(ctx.opcode), opc3(ctx.opcode),
                               ctx.opcode, ctx.nip - 4);                               ctx.opcode, ctx.nip - 4);
                 } else {                  } else {
                     printf("invalid bits: %08x for opcode: "                      printf("invalid bits: %08x for opcode: "
                            "%02x - %02x - %02x (%08x) " ADDRX "\n",                             "%02x - %02x - %02x (%08x) " TARGET_FMT_lx "\n",
                            ctx.opcode & handler->inval, opc1(ctx.opcode),                             ctx.opcode & handler->inval, opc1(ctx.opcode),
                            opc2(ctx.opcode), opc3(ctx.opcode),                             opc2(ctx.opcode), opc3(ctx.opcode),
                            ctx.opcode, ctx.nip - 4);                             ctx.opcode, ctx.nip - 4);

Removed from v.1.1.1.7  
changed lines
  Added in v.1.1.1.8


unix.superglobalmegacorp.com