target/ppc/translate.c

   1 /*
   2  *  PowerPC emulation for qemu: main translation routines.
   3  *
   4  *  Copyright (c) 2003-2007 Jocelyn Mayer
   5  *  Copyright (C) 2011 Freescale Semiconductor, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "cpu.h"
  23 #include "internal.h"
  24 #include "disas/disas.h"
  25 #include "exec/exec-all.h"
  26 #include "tcg/tcg-op.h"
  27 #include "tcg/tcg-op-gvec.h"
  28 #include "qemu/host-utils.h"
  29 #include "qemu/main-loop.h"
  30 #include "exec/cpu_ldst.h"
  31
  32 #include "exec/helper-proto.h"
  33 #include "exec/helper-gen.h"
  34
  35 #include "exec/translator.h"
  36 #include "exec/log.h"
  37 #include "qemu/atomic128.h"
  38 #include "spr_common.h"
  39 #include "power8-pmu.h"
  40
  41 #include "qemu/qemu-print.h"
  42 #include "qapi/error.h"
  43
  44 #define HELPER_H "helper.h"
  45 #include "exec/helper-info.c.inc"
  46 #undef  HELPER_H
  47
  48 #define CPU_SINGLE_STEP 0x1
  49 #define CPU_BRANCH_STEP 0x2
  50
  51 /* Include definitions for instructions classes and implementations flags */
  52 /* #define PPC_DEBUG_DISAS */
  53
  54 #ifdef PPC_DEBUG_DISAS
  55 #  define LOG_DISAS(...) qemu_log_mask(CPU_LOG_TB_IN_ASM, ## __VA_ARGS__)
  56 #else
  57 #  define LOG_DISAS(...) do { } while (0)
  58 #endif
  59 /*****************************************************************************/
  60 /* Code translation helpers                                                  */
  61
  62 /* global register indexes */
  63 static char cpu_reg_names[10 * 3 + 22 * 4   /* GPR */
  64                           + 10 * 4 + 22 * 5 /* SPE GPRh */
  65                           + 8 * 5           /* CRF */];
  66 static TCGv cpu_gpr[32];
  67 static TCGv cpu_gprh[32];
  68 static TCGv_i32 cpu_crf[8];
  69 static TCGv cpu_nip;
  70 static TCGv cpu_msr;
  71 static TCGv cpu_ctr;
  72 static TCGv cpu_lr;
  73 #if defined(TARGET_PPC64)
  74 static TCGv cpu_cfar;
  75 #endif
  76 static TCGv cpu_xer, cpu_so, cpu_ov, cpu_ca, cpu_ov32, cpu_ca32;
  77 static TCGv cpu_reserve;
  78 static TCGv cpu_reserve_length;
  79 static TCGv cpu_reserve_val;
  80 static TCGv cpu_reserve_val2;
  81 static TCGv cpu_fpscr;
  82 static TCGv_i32 cpu_access_type;
  83
  84 void ppc_translate_init(void)
  85 {
  86     int i;
  87     char *p;
  88     size_t cpu_reg_names_size;
  89
  90     p = cpu_reg_names;
  91     cpu_reg_names_size = sizeof(cpu_reg_names);
  92
  93     for (i = 0; i < 8; i++) {
  94         snprintf(p, cpu_reg_names_size, "crf%d", i);
  95         cpu_crf[i] = tcg_global_mem_new_i32(cpu_env,
  96                                             offsetof(CPUPPCState, crf[i]), p);
  97         p += 5;
  98         cpu_reg_names_size -= 5;
  99     }
 100
 101     for (i = 0; i < 32; i++) {
 102         snprintf(p, cpu_reg_names_size, "r%d", i);
 103         cpu_gpr[i] = tcg_global_mem_new(cpu_env,
 104                                         offsetof(CPUPPCState, gpr[i]), p);
 105         p += (i < 10) ? 3 : 4;
 106         cpu_reg_names_size -= (i < 10) ? 3 : 4;
 107         snprintf(p, cpu_reg_names_size, "r%dH", i);
 108         cpu_gprh[i] = tcg_global_mem_new(cpu_env,
 109                                          offsetof(CPUPPCState, gprh[i]), p);
 110         p += (i < 10) ? 4 : 5;
 111         cpu_reg_names_size -= (i < 10) ? 4 : 5;
 112     }
 113
 114     cpu_nip = tcg_global_mem_new(cpu_env,
 115                                  offsetof(CPUPPCState, nip), "nip");
 116
 117     cpu_msr = tcg_global_mem_new(cpu_env,
 118                                  offsetof(CPUPPCState, msr), "msr");
 119
 120     cpu_ctr = tcg_global_mem_new(cpu_env,
 121                                  offsetof(CPUPPCState, ctr), "ctr");
 122
 123     cpu_lr = tcg_global_mem_new(cpu_env,
 124                                 offsetof(CPUPPCState, lr), "lr");
 125
 126 #if defined(TARGET_PPC64)
 127     cpu_cfar = tcg_global_mem_new(cpu_env,
 128                                   offsetof(CPUPPCState, cfar), "cfar");
 129 #endif
 130
 131     cpu_xer = tcg_global_mem_new(cpu_env,
 132                                  offsetof(CPUPPCState, xer), "xer");
 133     cpu_so = tcg_global_mem_new(cpu_env,
 134                                 offsetof(CPUPPCState, so), "SO");
 135     cpu_ov = tcg_global_mem_new(cpu_env,
 136                                 offsetof(CPUPPCState, ov), "OV");
 137     cpu_ca = tcg_global_mem_new(cpu_env,
 138                                 offsetof(CPUPPCState, ca), "CA");
 139     cpu_ov32 = tcg_global_mem_new(cpu_env,
 140                                   offsetof(CPUPPCState, ov32), "OV32");
 141     cpu_ca32 = tcg_global_mem_new(cpu_env,
 142                                   offsetof(CPUPPCState, ca32), "CA32");
 143
 144     cpu_reserve = tcg_global_mem_new(cpu_env,
 145                                      offsetof(CPUPPCState, reserve_addr),
 146                                      "reserve_addr");
 147     cpu_reserve_length = tcg_global_mem_new(cpu_env,
 148                                             offsetof(CPUPPCState,
 149                                                      reserve_length),
 150                                             "reserve_length");
 151     cpu_reserve_val = tcg_global_mem_new(cpu_env,
 152                                          offsetof(CPUPPCState, reserve_val),
 153                                          "reserve_val");
 154     cpu_reserve_val2 = tcg_global_mem_new(cpu_env,
 155                                           offsetof(CPUPPCState, reserve_val2),
 156                                           "reserve_val2");
 157
 158     cpu_fpscr = tcg_global_mem_new(cpu_env,
 159                                    offsetof(CPUPPCState, fpscr), "fpscr");
 160
 161     cpu_access_type = tcg_global_mem_new_i32(cpu_env,
 162                                              offsetof(CPUPPCState, access_type),
 163                                              "access_type");
 164 }
 165
 166 /* internal defines */
 167 struct DisasContext {
 168     DisasContextBase base;
 169     target_ulong cia;  /* current instruction address */
 170     uint32_t opcode;
 171     /* Routine used to access memory */
 172     bool pr, hv, dr, le_mode;
 173     bool lazy_tlb_flush;
 174     bool need_access_type;
 175     int mem_idx;
 176     int access_type;
 177     /* Translation flags */
 178     MemOp default_tcg_memop_mask;
 179 #if defined(TARGET_PPC64)
 180     bool sf_mode;
 181     bool has_cfar;
 182 #endif
 183     bool fpu_enabled;
 184     bool altivec_enabled;
 185     bool vsx_enabled;
 186     bool spe_enabled;
 187     bool tm_enabled;
 188     bool gtse;
 189     bool hr;
 190     bool mmcr0_pmcc0;
 191     bool mmcr0_pmcc1;
 192     bool mmcr0_pmcjce;
 193     bool pmc_other;
 194     bool pmu_insn_cnt;
 195     ppc_spr_t *spr_cb; /* Needed to check rights for mfspr/mtspr */
 196     int singlestep_enabled;
 197     uint32_t flags;
 198     uint64_t insns_flags;
 199     uint64_t insns_flags2;
 200 };
 201
 202 #define DISAS_EXIT         DISAS_TARGET_0  /* exit to main loop, pc updated */
 203 #define DISAS_EXIT_UPDATE  DISAS_TARGET_1  /* exit to main loop, pc stale */
 204 #define DISAS_CHAIN        DISAS_TARGET_2  /* lookup next tb, pc updated */
 205 #define DISAS_CHAIN_UPDATE DISAS_TARGET_3  /* lookup next tb, pc stale */
 206
 207 /* Return true iff byteswap is needed in a scalar memop */
 208 static inline bool need_byteswap(const DisasContext *ctx)
 209 {
 210 #if TARGET_BIG_ENDIAN
 211      return ctx->le_mode;
 212 #else
 213      return !ctx->le_mode;
 214 #endif
 215 }
 216
 217 /* True when active word size < size of target_long.  */
 218 #ifdef TARGET_PPC64
 219 # define NARROW_MODE(C)  (!(C)->sf_mode)
 220 #else
 221 # define NARROW_MODE(C)  0
 222 #endif
 223
 224 struct opc_handler_t {
 225     /* invalid bits for instruction 1 (Rc(opcode) == 0) */
 226     uint32_t inval1;
 227     /* invalid bits for instruction 2 (Rc(opcode) == 1) */
 228     uint32_t inval2;
 229     /* instruction type */
 230     uint64_t type;
 231     /* extended instruction type */
 232     uint64_t type2;
 233     /* handler */
 234     void (*handler)(DisasContext *ctx);
 235 };
 236
 237 static inline bool gen_serialize(DisasContext *ctx)
 238 {
 239     if (tb_cflags(ctx->base.tb) & CF_PARALLEL) {
 240         /* Restart with exclusive lock.  */
 241         gen_helper_exit_atomic(cpu_env);
 242         ctx->base.is_jmp = DISAS_NORETURN;
 243         return false;
 244     }
 245     return true;
 246 }
 247
 248 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
 249 static inline bool gen_serialize_core(DisasContext *ctx)
 250 {
 251     if (ctx->flags & POWERPC_FLAG_SMT) {
 252         return gen_serialize(ctx);
 253     }
 254
 255     return true;
 256 }
 257 #endif
 258
 259 /* SPR load/store helpers */
 260 static inline void gen_load_spr(TCGv t, int reg)
 261 {
 262     tcg_gen_ld_tl(t, cpu_env, offsetof(CPUPPCState, spr[reg]));
 263 }
 264
 265 static inline void gen_store_spr(int reg, TCGv t)
 266 {
 267     tcg_gen_st_tl(t, cpu_env, offsetof(CPUPPCState, spr[reg]));
 268 }
 269
 270 static inline void gen_set_access_type(DisasContext *ctx, int access_type)
 271 {
 272     if (ctx->need_access_type && ctx->access_type != access_type) {
 273         tcg_gen_movi_i32(cpu_access_type, access_type);
 274         ctx->access_type = access_type;
 275     }
 276 }
 277
 278 static inline void gen_update_nip(DisasContext *ctx, target_ulong nip)
 279 {
 280     if (NARROW_MODE(ctx)) {
 281         nip = (uint32_t)nip;
 282     }
 283     tcg_gen_movi_tl(cpu_nip, nip);
 284 }
 285
 286 static void gen_exception_err(DisasContext *ctx, uint32_t excp, uint32_t error)
 287 {
 288     TCGv_i32 t0, t1;
 289
 290     /*
 291      * These are all synchronous exceptions, we set the PC back to the
 292      * faulting instruction
 293      */
 294     gen_update_nip(ctx, ctx->cia);
 295     t0 = tcg_constant_i32(excp);
 296     t1 = tcg_constant_i32(error);
 297     gen_helper_raise_exception_err(cpu_env, t0, t1);
 298     ctx->base.is_jmp = DISAS_NORETURN;
 299 }
 300
 301 static void gen_exception(DisasContext *ctx, uint32_t excp)
 302 {
 303     TCGv_i32 t0;
 304
 305     /*
 306      * These are all synchronous exceptions, we set the PC back to the
 307      * faulting instruction
 308      */
 309     gen_update_nip(ctx, ctx->cia);
 310     t0 = tcg_constant_i32(excp);
 311     gen_helper_raise_exception(cpu_env, t0);
 312     ctx->base.is_jmp = DISAS_NORETURN;
 313 }
 314
 315 static void gen_exception_nip(DisasContext *ctx, uint32_t excp,
 316                               target_ulong nip)
 317 {
 318     TCGv_i32 t0;
 319
 320     gen_update_nip(ctx, nip);
 321     t0 = tcg_constant_i32(excp);
 322     gen_helper_raise_exception(cpu_env, t0);
 323     ctx->base.is_jmp = DISAS_NORETURN;
 324 }
 325
 326 #if !defined(CONFIG_USER_ONLY)
 327 static void gen_ppc_maybe_interrupt(DisasContext *ctx)
 328 {
 329     translator_io_start(&ctx->base);
 330     gen_helper_ppc_maybe_interrupt(cpu_env);
 331 }
 332 #endif
 333
 334 /*
 335  * Tells the caller what is the appropriate exception to generate and prepares
 336  * SPR registers for this exception.
 337  *
 338  * The exception can be either POWERPC_EXCP_TRACE (on most PowerPCs) or
 339  * POWERPC_EXCP_DEBUG (on BookE).
 340  */
 341 static uint32_t gen_prep_dbgex(DisasContext *ctx)
 342 {
 343     if (ctx->flags & POWERPC_FLAG_DE) {
 344         target_ulong dbsr = 0;
 345         if (ctx->singlestep_enabled & CPU_SINGLE_STEP) {
 346             dbsr = DBCR0_ICMP;
 347         } else {
 348             /* Must have been branch */
 349             dbsr = DBCR0_BRT;
 350         }
 351         TCGv t0 = tcg_temp_new();
 352         gen_load_spr(t0, SPR_BOOKE_DBSR);
 353         tcg_gen_ori_tl(t0, t0, dbsr);
 354         gen_store_spr(SPR_BOOKE_DBSR, t0);
 355         return POWERPC_EXCP_DEBUG;
 356     } else {
 357         return POWERPC_EXCP_TRACE;
 358     }
 359 }
 360
 361 static void gen_debug_exception(DisasContext *ctx)
 362 {
 363     gen_helper_raise_exception(cpu_env, tcg_constant_i32(gen_prep_dbgex(ctx)));
 364     ctx->base.is_jmp = DISAS_NORETURN;
 365 }
 366
 367 static inline void gen_inval_exception(DisasContext *ctx, uint32_t error)
 368 {
 369     /* Will be converted to program check if needed */
 370     gen_exception_err(ctx, POWERPC_EXCP_HV_EMU, POWERPC_EXCP_INVAL | error);
 371 }
 372
 373 static inline void gen_priv_exception(DisasContext *ctx, uint32_t error)
 374 {
 375     gen_exception_err(ctx, POWERPC_EXCP_PROGRAM, POWERPC_EXCP_PRIV | error);
 376 }
 377
 378 static inline void gen_hvpriv_exception(DisasContext *ctx, uint32_t error)
 379 {
 380     /* Will be converted to program check if needed */
 381     gen_exception_err(ctx, POWERPC_EXCP_HV_EMU, POWERPC_EXCP_PRIV | error);
 382 }
 383
 384 /*****************************************************************************/
 385 /* SPR READ/WRITE CALLBACKS */
 386
 387 void spr_noaccess(DisasContext *ctx, int gprn, int sprn)
 388 {
 389 #if 0
 390     sprn = ((sprn >> 5) & 0x1F) | ((sprn & 0x1F) << 5);
 391     printf("ERROR: try to access SPR %d !\n", sprn);
 392 #endif
 393 }
 394
 395 /* #define PPC_DUMP_SPR_ACCESSES */
 396
 397 /*
 398  * Generic callbacks:
 399  * do nothing but store/retrieve spr value
 400  */
 401 static void spr_load_dump_spr(int sprn)
 402 {
 403 #ifdef PPC_DUMP_SPR_ACCESSES
 404     TCGv_i32 t0 = tcg_constant_i32(sprn);
 405     gen_helper_load_dump_spr(cpu_env, t0);
 406 #endif
 407 }
 408
 409 void spr_read_generic(DisasContext *ctx, int gprn, int sprn)
 410 {
 411     gen_load_spr(cpu_gpr[gprn], sprn);
 412     spr_load_dump_spr(sprn);
 413 }
 414
 415 static void spr_store_dump_spr(int sprn)
 416 {
 417 #ifdef PPC_DUMP_SPR_ACCESSES
 418     TCGv_i32 t0 = tcg_constant_i32(sprn);
 419     gen_helper_store_dump_spr(cpu_env, t0);
 420 #endif
 421 }
 422
 423 void spr_write_generic(DisasContext *ctx, int sprn, int gprn)
 424 {
 425     gen_store_spr(sprn, cpu_gpr[gprn]);
 426     spr_store_dump_spr(sprn);
 427 }
 428
 429 void spr_write_generic32(DisasContext *ctx, int sprn, int gprn)
 430 {
 431 #ifdef TARGET_PPC64
 432     TCGv t0 = tcg_temp_new();
 433     tcg_gen_ext32u_tl(t0, cpu_gpr[gprn]);
 434     gen_store_spr(sprn, t0);
 435     spr_store_dump_spr(sprn);
 436 #else
 437     spr_write_generic(ctx, sprn, gprn);
 438 #endif
 439 }
 440
 441 static void spr_write_CTRL_ST(DisasContext *ctx, int sprn, int gprn)
 442 {
 443     /* This does not implement >1 thread */
 444     TCGv t0 = tcg_temp_new();
 445     TCGv t1 = tcg_temp_new();
 446     tcg_gen_extract_tl(t0, cpu_gpr[gprn], 0, 1); /* Extract RUN field */
 447     tcg_gen_shli_tl(t1, t0, 8); /* Duplicate the bit in TS */
 448     tcg_gen_or_tl(t1, t1, t0);
 449     gen_store_spr(sprn, t1);
 450 }
 451
 452 void spr_write_CTRL(DisasContext *ctx, int sprn, int gprn)
 453 {
 454     if (!(ctx->flags & POWERPC_FLAG_SMT)) {
 455         spr_write_CTRL_ST(ctx, sprn, gprn);
 456         goto out;
 457     }
 458
 459     if (!gen_serialize(ctx)) {
 460         return;
 461     }
 462
 463     gen_helper_spr_write_CTRL(cpu_env, tcg_constant_i32(sprn),
 464                               cpu_gpr[gprn]);
 465 out:
 466     spr_store_dump_spr(sprn);
 467
 468     /*
 469      * SPR_CTRL writes must force a new translation block,
 470      * allowing the PMU to calculate the run latch events with
 471      * more accuracy.
 472      */
 473     ctx->base.is_jmp = DISAS_EXIT_UPDATE;
 474 }
 475
 476 #if !defined(CONFIG_USER_ONLY)
 477 void spr_write_clear(DisasContext *ctx, int sprn, int gprn)
 478 {
 479     TCGv t0 = tcg_temp_new();
 480     TCGv t1 = tcg_temp_new();
 481     gen_load_spr(t0, sprn);
 482     tcg_gen_neg_tl(t1, cpu_gpr[gprn]);
 483     tcg_gen_and_tl(t0, t0, t1);
 484     gen_store_spr(sprn, t0);
 485 }
 486
 487 void spr_access_nop(DisasContext *ctx, int sprn, int gprn)
 488 {
 489 }
 490
 491 #endif
 492
 493 /* SPR common to all PowerPC */
 494 /* XER */
 495 void spr_read_xer(DisasContext *ctx, int gprn, int sprn)
 496 {
 497     TCGv dst = cpu_gpr[gprn];
 498     TCGv t0 = tcg_temp_new();
 499     TCGv t1 = tcg_temp_new();
 500     TCGv t2 = tcg_temp_new();
 501     tcg_gen_mov_tl(dst, cpu_xer);
 502     tcg_gen_shli_tl(t0, cpu_so, XER_SO);
 503     tcg_gen_shli_tl(t1, cpu_ov, XER_OV);
 504     tcg_gen_shli_tl(t2, cpu_ca, XER_CA);
 505     tcg_gen_or_tl(t0, t0, t1);
 506     tcg_gen_or_tl(dst, dst, t2);
 507     tcg_gen_or_tl(dst, dst, t0);
 508     if (is_isa300(ctx)) {
 509         tcg_gen_shli_tl(t0, cpu_ov32, XER_OV32);
 510         tcg_gen_or_tl(dst, dst, t0);
 511         tcg_gen_shli_tl(t0, cpu_ca32, XER_CA32);
 512         tcg_gen_or_tl(dst, dst, t0);
 513     }
 514 }
 515
 516 void spr_write_xer(DisasContext *ctx, int sprn, int gprn)
 517 {
 518     TCGv src = cpu_gpr[gprn];
 519     /* Write all flags, while reading back check for isa300 */
 520     tcg_gen_andi_tl(cpu_xer, src,
 521                     ~((1u << XER_SO) |
 522                       (1u << XER_OV) | (1u << XER_OV32) |
 523                       (1u << XER_CA) | (1u << XER_CA32)));
 524     tcg_gen_extract_tl(cpu_ov32, src, XER_OV32, 1);
 525     tcg_gen_extract_tl(cpu_ca32, src, XER_CA32, 1);
 526     tcg_gen_extract_tl(cpu_so, src, XER_SO, 1);
 527     tcg_gen_extract_tl(cpu_ov, src, XER_OV, 1);
 528     tcg_gen_extract_tl(cpu_ca, src, XER_CA, 1);
 529 }
 530
 531 /* LR */
 532 void spr_read_lr(DisasContext *ctx, int gprn, int sprn)
 533 {
 534     tcg_gen_mov_tl(cpu_gpr[gprn], cpu_lr);
 535 }
 536
 537 void spr_write_lr(DisasContext *ctx, int sprn, int gprn)
 538 {
 539     tcg_gen_mov_tl(cpu_lr, cpu_gpr[gprn]);
 540 }
 541
 542 /* CFAR */
 543 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
 544 void spr_read_cfar(DisasContext *ctx, int gprn, int sprn)
 545 {
 546     tcg_gen_mov_tl(cpu_gpr[gprn], cpu_cfar);
 547 }
 548
 549 void spr_write_cfar(DisasContext *ctx, int sprn, int gprn)
 550 {
 551     tcg_gen_mov_tl(cpu_cfar, cpu_gpr[gprn]);
 552 }
 553 #endif /* defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY) */
 554
 555 /* CTR */
 556 void spr_read_ctr(DisasContext *ctx, int gprn, int sprn)
 557 {
 558     tcg_gen_mov_tl(cpu_gpr[gprn], cpu_ctr);
 559 }
 560
 561 void spr_write_ctr(DisasContext *ctx, int sprn, int gprn)
 562 {
 563     tcg_gen_mov_tl(cpu_ctr, cpu_gpr[gprn]);
 564 }
 565
 566 /* User read access to SPR */
 567 /* USPRx */
 568 /* UMMCRx */
 569 /* UPMCx */
 570 /* USIA */
 571 /* UDECR */
 572 void spr_read_ureg(DisasContext *ctx, int gprn, int sprn)
 573 {
 574     gen_load_spr(cpu_gpr[gprn], sprn + 0x10);
 575 }
 576
 577 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
 578 void spr_write_ureg(DisasContext *ctx, int sprn, int gprn)
 579 {
 580     gen_store_spr(sprn + 0x10, cpu_gpr[gprn]);
 581 }
 582 #endif
 583
 584 /* SPR common to all non-embedded PowerPC */
 585 /* DECR */
 586 #if !defined(CONFIG_USER_ONLY)
 587 void spr_read_decr(DisasContext *ctx, int gprn, int sprn)
 588 {
 589     translator_io_start(&ctx->base);
 590     gen_helper_load_decr(cpu_gpr[gprn], cpu_env);
 591 }
 592
 593 void spr_write_decr(DisasContext *ctx, int sprn, int gprn)
 594 {
 595     translator_io_start(&ctx->base);
 596     gen_helper_store_decr(cpu_env, cpu_gpr[gprn]);
 597 }
 598 #endif
 599
 600 /* SPR common to all non-embedded PowerPC, except 601 */
 601 /* Time base */
 602 void spr_read_tbl(DisasContext *ctx, int gprn, int sprn)
 603 {
 604     translator_io_start(&ctx->base);
 605     gen_helper_load_tbl(cpu_gpr[gprn], cpu_env);
 606 }
 607
 608 void spr_read_tbu(DisasContext *ctx, int gprn, int sprn)
 609 {
 610     translator_io_start(&ctx->base);
 611     gen_helper_load_tbu(cpu_gpr[gprn], cpu_env);
 612 }
 613
 614 void spr_read_atbl(DisasContext *ctx, int gprn, int sprn)
 615 {
 616     gen_helper_load_atbl(cpu_gpr[gprn], cpu_env);
 617 }
 618
 619 void spr_read_atbu(DisasContext *ctx, int gprn, int sprn)
 620 {
 621     gen_helper_load_atbu(cpu_gpr[gprn], cpu_env);
 622 }
 623
 624 #if !defined(CONFIG_USER_ONLY)
 625 void spr_write_tbl(DisasContext *ctx, int sprn, int gprn)
 626 {
 627     translator_io_start(&ctx->base);
 628     gen_helper_store_tbl(cpu_env, cpu_gpr[gprn]);
 629 }
 630
 631 void spr_write_tbu(DisasContext *ctx, int sprn, int gprn)
 632 {
 633     translator_io_start(&ctx->base);
 634     gen_helper_store_tbu(cpu_env, cpu_gpr[gprn]);
 635 }
 636
 637 void spr_write_atbl(DisasContext *ctx, int sprn, int gprn)
 638 {
 639     gen_helper_store_atbl(cpu_env, cpu_gpr[gprn]);
 640 }
 641
 642 void spr_write_atbu(DisasContext *ctx, int sprn, int gprn)
 643 {
 644     gen_helper_store_atbu(cpu_env, cpu_gpr[gprn]);
 645 }
 646
 647 #if defined(TARGET_PPC64)
 648 void spr_read_purr(DisasContext *ctx, int gprn, int sprn)
 649 {
 650     translator_io_start(&ctx->base);
 651     gen_helper_load_purr(cpu_gpr[gprn], cpu_env);
 652 }
 653
 654 void spr_write_purr(DisasContext *ctx, int sprn, int gprn)
 655 {
 656     translator_io_start(&ctx->base);
 657     gen_helper_store_purr(cpu_env, cpu_gpr[gprn]);
 658 }
 659
 660 /* HDECR */
 661 void spr_read_hdecr(DisasContext *ctx, int gprn, int sprn)
 662 {
 663     translator_io_start(&ctx->base);
 664     gen_helper_load_hdecr(cpu_gpr[gprn], cpu_env);
 665 }
 666
 667 void spr_write_hdecr(DisasContext *ctx, int sprn, int gprn)
 668 {
 669     translator_io_start(&ctx->base);
 670     gen_helper_store_hdecr(cpu_env, cpu_gpr[gprn]);
 671 }
 672
 673 void spr_read_vtb(DisasContext *ctx, int gprn, int sprn)
 674 {
 675     translator_io_start(&ctx->base);
 676     gen_helper_load_vtb(cpu_gpr[gprn], cpu_env);
 677 }
 678
 679 void spr_write_vtb(DisasContext *ctx, int sprn, int gprn)
 680 {
 681     translator_io_start(&ctx->base);
 682     gen_helper_store_vtb(cpu_env, cpu_gpr[gprn]);
 683 }
 684
 685 void spr_write_tbu40(DisasContext *ctx, int sprn, int gprn)
 686 {
 687     translator_io_start(&ctx->base);
 688     gen_helper_store_tbu40(cpu_env, cpu_gpr[gprn]);
 689 }
 690
 691 #endif
 692 #endif
 693
 694 #if !defined(CONFIG_USER_ONLY)
 695 /* IBAT0U...IBAT0U */
 696 /* IBAT0L...IBAT7L */
 697 void spr_read_ibat(DisasContext *ctx, int gprn, int sprn)
 698 {
 699     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env,
 700                   offsetof(CPUPPCState,
 701                            IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
 702 }
 703
 704 void spr_read_ibat_h(DisasContext *ctx, int gprn, int sprn)
 705 {
 706     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env,
 707                   offsetof(CPUPPCState,
 708                            IBAT[sprn & 1][((sprn - SPR_IBAT4U) / 2) + 4]));
 709 }
 710
 711 void spr_write_ibatu(DisasContext *ctx, int sprn, int gprn)
 712 {
 713     TCGv_i32 t0 = tcg_constant_i32((sprn - SPR_IBAT0U) / 2);
 714     gen_helper_store_ibatu(cpu_env, t0, cpu_gpr[gprn]);
 715 }
 716
 717 void spr_write_ibatu_h(DisasContext *ctx, int sprn, int gprn)
 718 {
 719     TCGv_i32 t0 = tcg_constant_i32(((sprn - SPR_IBAT4U) / 2) + 4);
 720     gen_helper_store_ibatu(cpu_env, t0, cpu_gpr[gprn]);
 721 }
 722
 723 void spr_write_ibatl(DisasContext *ctx, int sprn, int gprn)
 724 {
 725     TCGv_i32 t0 = tcg_constant_i32((sprn - SPR_IBAT0L) / 2);
 726     gen_helper_store_ibatl(cpu_env, t0, cpu_gpr[gprn]);
 727 }
 728
 729 void spr_write_ibatl_h(DisasContext *ctx, int sprn, int gprn)
 730 {
 731     TCGv_i32 t0 = tcg_constant_i32(((sprn - SPR_IBAT4L) / 2) + 4);
 732     gen_helper_store_ibatl(cpu_env, t0, cpu_gpr[gprn]);
 733 }
 734
 735 /* DBAT0U...DBAT7U */
 736 /* DBAT0L...DBAT7L */
 737 void spr_read_dbat(DisasContext *ctx, int gprn, int sprn)
 738 {
 739     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env,
 740                   offsetof(CPUPPCState,
 741                            DBAT[sprn & 1][(sprn - SPR_DBAT0U) / 2]));
 742 }
 743
 744 void spr_read_dbat_h(DisasContext *ctx, int gprn, int sprn)
 745 {
 746     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env,
 747                   offsetof(CPUPPCState,
 748                            DBAT[sprn & 1][((sprn - SPR_DBAT4U) / 2) + 4]));
 749 }
 750
 751 void spr_write_dbatu(DisasContext *ctx, int sprn, int gprn)
 752 {
 753     TCGv_i32 t0 = tcg_constant_i32((sprn - SPR_DBAT0U) / 2);
 754     gen_helper_store_dbatu(cpu_env, t0, cpu_gpr[gprn]);
 755 }
 756
 757 void spr_write_dbatu_h(DisasContext *ctx, int sprn, int gprn)
 758 {
 759     TCGv_i32 t0 = tcg_constant_i32(((sprn - SPR_DBAT4U) / 2) + 4);
 760     gen_helper_store_dbatu(cpu_env, t0, cpu_gpr[gprn]);
 761 }
 762
 763 void spr_write_dbatl(DisasContext *ctx, int sprn, int gprn)
 764 {
 765     TCGv_i32 t0 = tcg_constant_i32((sprn - SPR_DBAT0L) / 2);
 766     gen_helper_store_dbatl(cpu_env, t0, cpu_gpr[gprn]);
 767 }
 768
 769 void spr_write_dbatl_h(DisasContext *ctx, int sprn, int gprn)
 770 {
 771     TCGv_i32 t0 = tcg_constant_i32(((sprn - SPR_DBAT4L) / 2) + 4);
 772     gen_helper_store_dbatl(cpu_env, t0, cpu_gpr[gprn]);
 773 }
 774
 775 /* SDR1 */
 776 void spr_write_sdr1(DisasContext *ctx, int sprn, int gprn)
 777 {
 778     gen_helper_store_sdr1(cpu_env, cpu_gpr[gprn]);
 779 }
 780
 781 #if defined(TARGET_PPC64)
 782 /* 64 bits PowerPC specific SPRs */
 783 /* PIDR */
 784 void spr_write_pidr(DisasContext *ctx, int sprn, int gprn)
 785 {
 786     gen_helper_store_pidr(cpu_env, cpu_gpr[gprn]);
 787 }
 788
 789 void spr_write_lpidr(DisasContext *ctx, int sprn, int gprn)
 790 {
 791     gen_helper_store_lpidr(cpu_env, cpu_gpr[gprn]);
 792 }
 793
 794 void spr_read_hior(DisasContext *ctx, int gprn, int sprn)
 795 {
 796     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, excp_prefix));
 797 }
 798
 799 void spr_write_hior(DisasContext *ctx, int sprn, int gprn)
 800 {
 801     TCGv t0 = tcg_temp_new();
 802     tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0x3FFFFF00000ULL);
 803     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_prefix));
 804 }
 805 void spr_write_ptcr(DisasContext *ctx, int sprn, int gprn)
 806 {
 807     gen_helper_store_ptcr(cpu_env, cpu_gpr[gprn]);
 808 }
 809
 810 void spr_write_pcr(DisasContext *ctx, int sprn, int gprn)
 811 {
 812     gen_helper_store_pcr(cpu_env, cpu_gpr[gprn]);
 813 }
 814
 815 /* DPDES */
 816 void spr_read_dpdes(DisasContext *ctx, int gprn, int sprn)
 817 {
 818     if (!gen_serialize_core(ctx)) {
 819         return;
 820     }
 821
 822     gen_helper_load_dpdes(cpu_gpr[gprn], cpu_env);
 823 }
 824
 825 void spr_write_dpdes(DisasContext *ctx, int sprn, int gprn)
 826 {
 827     if (!gen_serialize_core(ctx)) {
 828         return;
 829     }
 830
 831     gen_helper_store_dpdes(cpu_env, cpu_gpr[gprn]);
 832 }
 833 #endif
 834 #endif
 835
 836 /* PowerPC 40x specific registers */
 837 #if !defined(CONFIG_USER_ONLY)
 838 void spr_read_40x_pit(DisasContext *ctx, int gprn, int sprn)
 839 {
 840     translator_io_start(&ctx->base);
 841     gen_helper_load_40x_pit(cpu_gpr[gprn], cpu_env);
 842 }
 843
 844 void spr_write_40x_pit(DisasContext *ctx, int sprn, int gprn)
 845 {
 846     translator_io_start(&ctx->base);
 847     gen_helper_store_40x_pit(cpu_env, cpu_gpr[gprn]);
 848 }
 849
 850 void spr_write_40x_dbcr0(DisasContext *ctx, int sprn, int gprn)
 851 {
 852     translator_io_start(&ctx->base);
 853     gen_store_spr(sprn, cpu_gpr[gprn]);
 854     gen_helper_store_40x_dbcr0(cpu_env, cpu_gpr[gprn]);
 855     /* We must stop translation as we may have rebooted */
 856     ctx->base.is_jmp = DISAS_EXIT_UPDATE;
 857 }
 858
 859 void spr_write_40x_sler(DisasContext *ctx, int sprn, int gprn)
 860 {
 861     translator_io_start(&ctx->base);
 862     gen_helper_store_40x_sler(cpu_env, cpu_gpr[gprn]);
 863 }
 864
 865 void spr_write_40x_tcr(DisasContext *ctx, int sprn, int gprn)
 866 {
 867     translator_io_start(&ctx->base);
 868     gen_helper_store_40x_tcr(cpu_env, cpu_gpr[gprn]);
 869 }
 870
 871 void spr_write_40x_tsr(DisasContext *ctx, int sprn, int gprn)
 872 {
 873     translator_io_start(&ctx->base);
 874     gen_helper_store_40x_tsr(cpu_env, cpu_gpr[gprn]);
 875 }
 876
 877 void spr_write_40x_pid(DisasContext *ctx, int sprn, int gprn)
 878 {
 879     TCGv t0 = tcg_temp_new();
 880     tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0xFF);
 881     gen_helper_store_40x_pid(cpu_env, t0);
 882 }
 883
 884 void spr_write_booke_tcr(DisasContext *ctx, int sprn, int gprn)
 885 {
 886     translator_io_start(&ctx->base);
 887     gen_helper_store_booke_tcr(cpu_env, cpu_gpr[gprn]);
 888 }
 889
 890 void spr_write_booke_tsr(DisasContext *ctx, int sprn, int gprn)
 891 {
 892     translator_io_start(&ctx->base);
 893     gen_helper_store_booke_tsr(cpu_env, cpu_gpr[gprn]);
 894 }
 895 #endif
 896
 897 /* PIR */
 898 #if !defined(CONFIG_USER_ONLY)
 899 void spr_write_pir(DisasContext *ctx, int sprn, int gprn)
 900 {
 901     TCGv t0 = tcg_temp_new();
 902     tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0xF);
 903     gen_store_spr(SPR_PIR, t0);
 904 }
 905 #endif
 906
 907 /* SPE specific registers */
 908 void spr_read_spefscr(DisasContext *ctx, int gprn, int sprn)
 909 {
 910     TCGv_i32 t0 = tcg_temp_new_i32();
 911     tcg_gen_ld_i32(t0, cpu_env, offsetof(CPUPPCState, spe_fscr));
 912     tcg_gen_extu_i32_tl(cpu_gpr[gprn], t0);
 913 }
 914
 915 void spr_write_spefscr(DisasContext *ctx, int sprn, int gprn)
 916 {
 917     TCGv_i32 t0 = tcg_temp_new_i32();
 918     tcg_gen_trunc_tl_i32(t0, cpu_gpr[gprn]);
 919     tcg_gen_st_i32(t0, cpu_env, offsetof(CPUPPCState, spe_fscr));
 920 }
 921
 922 #if !defined(CONFIG_USER_ONLY)
 923 /* Callback used to write the exception vector base */
 924 void spr_write_excp_prefix(DisasContext *ctx, int sprn, int gprn)
 925 {
 926     TCGv t0 = tcg_temp_new();
 927     tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUPPCState, ivpr_mask));
 928     tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
 929     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_prefix));
 930     gen_store_spr(sprn, t0);
 931 }
 932
 933 void spr_write_excp_vector(DisasContext *ctx, int sprn, int gprn)
 934 {
 935     int sprn_offs;
 936
 937     if (sprn >= SPR_BOOKE_IVOR0 && sprn <= SPR_BOOKE_IVOR15) {
 938         sprn_offs = sprn - SPR_BOOKE_IVOR0;
 939     } else if (sprn >= SPR_BOOKE_IVOR32 && sprn <= SPR_BOOKE_IVOR37) {
 940         sprn_offs = sprn - SPR_BOOKE_IVOR32 + 32;
 941     } else if (sprn >= SPR_BOOKE_IVOR38 && sprn <= SPR_BOOKE_IVOR42) {
 942         sprn_offs = sprn - SPR_BOOKE_IVOR38 + 38;
 943     } else {
 944         qemu_log_mask(LOG_GUEST_ERROR, "Trying to write an unknown exception"
 945                       " vector 0x%03x\n", sprn);
 946         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
 947         return;
 948     }
 949
 950     TCGv t0 = tcg_temp_new();
 951     tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUPPCState, ivor_mask));
 952     tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
 953     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_vectors[sprn_offs]));
 954     gen_store_spr(sprn, t0);
 955 }
 956 #endif
 957
 958 #ifdef TARGET_PPC64
 959 #ifndef CONFIG_USER_ONLY
 960 void spr_write_amr(DisasContext *ctx, int sprn, int gprn)
 961 {
 962     TCGv t0 = tcg_temp_new();
 963     TCGv t1 = tcg_temp_new();
 964     TCGv t2 = tcg_temp_new();
 965
 966     /*
 967      * Note, the HV=1 PR=0 case is handled earlier by simply using
 968      * spr_write_generic for HV mode in the SPR table
 969      */
 970
 971     /* Build insertion mask into t1 based on context */
 972     if (ctx->pr) {
 973         gen_load_spr(t1, SPR_UAMOR);
 974     } else {
 975         gen_load_spr(t1, SPR_AMOR);
 976     }
 977
 978     /* Mask new bits into t2 */
 979     tcg_gen_and_tl(t2, t1, cpu_gpr[gprn]);
 980
 981     /* Load AMR and clear new bits in t0 */
 982     gen_load_spr(t0, SPR_AMR);
 983     tcg_gen_andc_tl(t0, t0, t1);
 984
 985     /* Or'in new bits and write it out */
 986     tcg_gen_or_tl(t0, t0, t2);
 987     gen_store_spr(SPR_AMR, t0);
 988     spr_store_dump_spr(SPR_AMR);
 989 }
 990
 991 void spr_write_uamor(DisasContext *ctx, int sprn, int gprn)
 992 {
 993     TCGv t0 = tcg_temp_new();
 994     TCGv t1 = tcg_temp_new();
 995     TCGv t2 = tcg_temp_new();
 996
 997     /*
 998      * Note, the HV=1 case is handled earlier by simply using
 999      * spr_write_generic for HV mode in the SPR table
1000      */
1001
1002     /* Build insertion mask into t1 based on context */
1003     gen_load_spr(t1, SPR_AMOR);
1004
1005     /* Mask new bits into t2 */
1006     tcg_gen_and_tl(t2, t1, cpu_gpr[gprn]);
1007
1008     /* Load AMR and clear new bits in t0 */
1009     gen_load_spr(t0, SPR_UAMOR);
1010     tcg_gen_andc_tl(t0, t0, t1);
1011
1012     /* Or'in new bits and write it out */
1013     tcg_gen_or_tl(t0, t0, t2);
1014     gen_store_spr(SPR_UAMOR, t0);
1015     spr_store_dump_spr(SPR_UAMOR);
1016 }
1017
1018 void spr_write_iamr(DisasContext *ctx, int sprn, int gprn)
1019 {
1020     TCGv t0 = tcg_temp_new();
1021     TCGv t1 = tcg_temp_new();
1022     TCGv t2 = tcg_temp_new();
1023
1024     /*
1025      * Note, the HV=1 case is handled earlier by simply using
1026      * spr_write_generic for HV mode in the SPR table
1027      */
1028
1029     /* Build insertion mask into t1 based on context */
1030     gen_load_spr(t1, SPR_AMOR);
1031
1032     /* Mask new bits into t2 */
1033     tcg_gen_and_tl(t2, t1, cpu_gpr[gprn]);
1034
1035     /* Load AMR and clear new bits in t0 */
1036     gen_load_spr(t0, SPR_IAMR);
1037     tcg_gen_andc_tl(t0, t0, t1);
1038
1039     /* Or'in new bits and write it out */
1040     tcg_gen_or_tl(t0, t0, t2);
1041     gen_store_spr(SPR_IAMR, t0);
1042     spr_store_dump_spr(SPR_IAMR);
1043 }
1044 #endif
1045 #endif
1046
1047 #ifndef CONFIG_USER_ONLY
1048 void spr_read_thrm(DisasContext *ctx, int gprn, int sprn)
1049 {
1050     gen_helper_fixup_thrm(cpu_env);
1051     gen_load_spr(cpu_gpr[gprn], sprn);
1052     spr_load_dump_spr(sprn);
1053 }
1054 #endif /* !CONFIG_USER_ONLY */
1055
1056 #if !defined(CONFIG_USER_ONLY)
1057 void spr_write_e500_l1csr0(DisasContext *ctx, int sprn, int gprn)
1058 {
1059     TCGv t0 = tcg_temp_new();
1060
1061     tcg_gen_andi_tl(t0, cpu_gpr[gprn], L1CSR0_DCE | L1CSR0_CPE);
1062     gen_store_spr(sprn, t0);
1063 }
1064
1065 void spr_write_e500_l1csr1(DisasContext *ctx, int sprn, int gprn)
1066 {
1067     TCGv t0 = tcg_temp_new();
1068
1069     tcg_gen_andi_tl(t0, cpu_gpr[gprn], L1CSR1_ICE | L1CSR1_CPE);
1070     gen_store_spr(sprn, t0);
1071 }
1072
1073 void spr_write_e500_l2csr0(DisasContext *ctx, int sprn, int gprn)
1074 {
1075     TCGv t0 = tcg_temp_new();
1076
1077     tcg_gen_andi_tl(t0, cpu_gpr[gprn],
1078                     ~(E500_L2CSR0_L2FI | E500_L2CSR0_L2FL | E500_L2CSR0_L2LFC));
1079     gen_store_spr(sprn, t0);
1080 }
1081
1082 void spr_write_booke206_mmucsr0(DisasContext *ctx, int sprn, int gprn)
1083 {
1084     gen_helper_booke206_tlbflush(cpu_env, cpu_gpr[gprn]);
1085 }
1086
1087 void spr_write_booke_pid(DisasContext *ctx, int sprn, int gprn)
1088 {
1089     TCGv_i32 t0 = tcg_constant_i32(sprn);
1090     gen_helper_booke_setpid(cpu_env, t0, cpu_gpr[gprn]);
1091 }
1092
1093 void spr_write_eplc(DisasContext *ctx, int sprn, int gprn)
1094 {
1095     gen_helper_booke_set_eplc(cpu_env, cpu_gpr[gprn]);
1096 }
1097
1098 void spr_write_epsc(DisasContext *ctx, int sprn, int gprn)
1099 {
1100     gen_helper_booke_set_epsc(cpu_env, cpu_gpr[gprn]);
1101 }
1102
1103 #endif
1104
1105 #if !defined(CONFIG_USER_ONLY)
1106 void spr_write_mas73(DisasContext *ctx, int sprn, int gprn)
1107 {
1108     TCGv val = tcg_temp_new();
1109     tcg_gen_ext32u_tl(val, cpu_gpr[gprn]);
1110     gen_store_spr(SPR_BOOKE_MAS3, val);
1111     tcg_gen_shri_tl(val, cpu_gpr[gprn], 32);
1112     gen_store_spr(SPR_BOOKE_MAS7, val);
1113 }
1114
1115 void spr_read_mas73(DisasContext *ctx, int gprn, int sprn)
1116 {
1117     TCGv mas7 = tcg_temp_new();
1118     TCGv mas3 = tcg_temp_new();
1119     gen_load_spr(mas7, SPR_BOOKE_MAS7);
1120     tcg_gen_shli_tl(mas7, mas7, 32);
1121     gen_load_spr(mas3, SPR_BOOKE_MAS3);
1122     tcg_gen_or_tl(cpu_gpr[gprn], mas3, mas7);
1123 }
1124
1125 #endif
1126
1127 #ifdef TARGET_PPC64
1128 static void gen_fscr_facility_check(DisasContext *ctx, int facility_sprn,
1129                                     int bit, int sprn, int cause)
1130 {
1131     TCGv_i32 t1 = tcg_constant_i32(bit);
1132     TCGv_i32 t2 = tcg_constant_i32(sprn);
1133     TCGv_i32 t3 = tcg_constant_i32(cause);
1134
1135     gen_helper_fscr_facility_check(cpu_env, t1, t2, t3);
1136 }
1137
1138 static void gen_msr_facility_check(DisasContext *ctx, int facility_sprn,
1139                                    int bit, int sprn, int cause)
1140 {
1141     TCGv_i32 t1 = tcg_constant_i32(bit);
1142     TCGv_i32 t2 = tcg_constant_i32(sprn);
1143     TCGv_i32 t3 = tcg_constant_i32(cause);
1144
1145     gen_helper_msr_facility_check(cpu_env, t1, t2, t3);
1146 }
1147
1148 void spr_read_prev_upper32(DisasContext *ctx, int gprn, int sprn)
1149 {
1150     TCGv spr_up = tcg_temp_new();
1151     TCGv spr = tcg_temp_new();
1152
1153     gen_load_spr(spr, sprn - 1);
1154     tcg_gen_shri_tl(spr_up, spr, 32);
1155     tcg_gen_ext32u_tl(cpu_gpr[gprn], spr_up);
1156 }
1157
1158 void spr_write_prev_upper32(DisasContext *ctx, int sprn, int gprn)
1159 {
1160     TCGv spr = tcg_temp_new();
1161
1162     gen_load_spr(spr, sprn - 1);
1163     tcg_gen_deposit_tl(spr, spr, cpu_gpr[gprn], 32, 32);
1164     gen_store_spr(sprn - 1, spr);
1165 }
1166
1167 #if !defined(CONFIG_USER_ONLY)
1168 void spr_write_hmer(DisasContext *ctx, int sprn, int gprn)
1169 {
1170     TCGv hmer = tcg_temp_new();
1171
1172     gen_load_spr(hmer, sprn);
1173     tcg_gen_and_tl(hmer, cpu_gpr[gprn], hmer);
1174     gen_store_spr(sprn, hmer);
1175     spr_store_dump_spr(sprn);
1176 }
1177
1178 void spr_read_tfmr(DisasContext *ctx, int gprn, int sprn)
1179 {
1180     gen_helper_load_tfmr(cpu_gpr[gprn], cpu_env);
1181 }
1182
1183 void spr_write_tfmr(DisasContext *ctx, int sprn, int gprn)
1184 {
1185     gen_helper_store_tfmr(cpu_env, cpu_gpr[gprn]);
1186 }
1187
1188 void spr_write_lpcr(DisasContext *ctx, int sprn, int gprn)
1189 {
1190     translator_io_start(&ctx->base);
1191     gen_helper_store_lpcr(cpu_env, cpu_gpr[gprn]);
1192 }
1193 #endif /* !defined(CONFIG_USER_ONLY) */
1194
1195 void spr_read_tar(DisasContext *ctx, int gprn, int sprn)
1196 {
1197     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_TAR, sprn, FSCR_IC_TAR);
1198     spr_read_generic(ctx, gprn, sprn);
1199 }
1200
1201 void spr_write_tar(DisasContext *ctx, int sprn, int gprn)
1202 {
1203     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_TAR, sprn, FSCR_IC_TAR);
1204     spr_write_generic(ctx, sprn, gprn);
1205 }
1206
1207 void spr_read_tm(DisasContext *ctx, int gprn, int sprn)
1208 {
1209     gen_msr_facility_check(ctx, SPR_FSCR, MSR_TM, sprn, FSCR_IC_TM);
1210     spr_read_generic(ctx, gprn, sprn);
1211 }
1212
1213 void spr_write_tm(DisasContext *ctx, int sprn, int gprn)
1214 {
1215     gen_msr_facility_check(ctx, SPR_FSCR, MSR_TM, sprn, FSCR_IC_TM);
1216     spr_write_generic(ctx, sprn, gprn);
1217 }
1218
1219 void spr_read_tm_upper32(DisasContext *ctx, int gprn, int sprn)
1220 {
1221     gen_msr_facility_check(ctx, SPR_FSCR, MSR_TM, sprn, FSCR_IC_TM);
1222     spr_read_prev_upper32(ctx, gprn, sprn);
1223 }
1224
1225 void spr_write_tm_upper32(DisasContext *ctx, int sprn, int gprn)
1226 {
1227     gen_msr_facility_check(ctx, SPR_FSCR, MSR_TM, sprn, FSCR_IC_TM);
1228     spr_write_prev_upper32(ctx, sprn, gprn);
1229 }
1230
1231 void spr_read_ebb(DisasContext *ctx, int gprn, int sprn)
1232 {
1233     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_EBB, sprn, FSCR_IC_EBB);
1234     spr_read_generic(ctx, gprn, sprn);
1235 }
1236
1237 void spr_write_ebb(DisasContext *ctx, int sprn, int gprn)
1238 {
1239     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_EBB, sprn, FSCR_IC_EBB);
1240     spr_write_generic(ctx, sprn, gprn);
1241 }
1242
1243 void spr_read_ebb_upper32(DisasContext *ctx, int gprn, int sprn)
1244 {
1245     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_EBB, sprn, FSCR_IC_EBB);
1246     spr_read_prev_upper32(ctx, gprn, sprn);
1247 }
1248
1249 void spr_write_ebb_upper32(DisasContext *ctx, int sprn, int gprn)
1250 {
1251     gen_fscr_facility_check(ctx, SPR_FSCR, FSCR_EBB, sprn, FSCR_IC_EBB);
1252     spr_write_prev_upper32(ctx, sprn, gprn);
1253 }
1254
1255 void spr_read_dexcr_ureg(DisasContext *ctx, int gprn, int sprn)
1256 {
1257     TCGv t0 = tcg_temp_new();
1258
1259     /*
1260      * Access to the (H)DEXCR in problem state is done using separated
1261      * SPR indexes which are 16 below the SPR indexes which have full
1262      * access to the (H)DEXCR in privileged state. Problem state can
1263      * only read bits 32:63, bits 0:31 return 0.
1264      *
1265      * See section 9.3.1-9.3.2 of PowerISA v3.1B
1266      */
1267
1268     gen_load_spr(t0, sprn + 16);
1269     tcg_gen_ext32u_tl(cpu_gpr[gprn], t0);
1270 }
1271 #endif
1272
1273 #define GEN_HANDLER(name, opc1, opc2, opc3, inval, type)                      \
1274 GEN_OPCODE(name, opc1, opc2, opc3, inval, type, PPC_NONE)
1275
1276 #define GEN_HANDLER_E(name, opc1, opc2, opc3, inval, type, type2)             \
1277 GEN_OPCODE(name, opc1, opc2, opc3, inval, type, type2)
1278
1279 #define GEN_HANDLER2(name, onam, opc1, opc2, opc3, inval, type)               \
1280 GEN_OPCODE2(name, onam, opc1, opc2, opc3, inval, type, PPC_NONE)
1281
1282 #define GEN_HANDLER2_E(name, onam, opc1, opc2, opc3, inval, type, type2)      \
1283 GEN_OPCODE2(name, onam, opc1, opc2, opc3, inval, type, type2)
1284
1285 #define GEN_HANDLER_E_2(name, opc1, opc2, opc3, opc4, inval, type, type2)     \
1286 GEN_OPCODE3(name, opc1, opc2, opc3, opc4, inval, type, type2)
1287
1288 #define GEN_HANDLER2_E_2(name, onam, opc1, opc2, opc3, opc4, inval, typ, typ2) \
1289 GEN_OPCODE4(name, onam, opc1, opc2, opc3, opc4, inval, typ, typ2)
1290
1291 typedef struct opcode_t {
1292     unsigned char opc1, opc2, opc3, opc4;
1293 #if HOST_LONG_BITS == 64 /* Explicitly align to 64 bits */
1294     unsigned char pad[4];
1295 #endif
1296     opc_handler_t handler;
1297     const char *oname;
1298 } opcode_t;
1299
1300 static void gen_priv_opc(DisasContext *ctx)
1301 {
1302     gen_priv_exception(ctx, POWERPC_EXCP_PRIV_OPC);
1303 }
1304
1305 /* Helpers for priv. check */
1306 #define GEN_PRIV(CTX)              \
1307     do {                           \
1308         gen_priv_opc(CTX); return; \
1309     } while (0)
1310
1311 #if defined(CONFIG_USER_ONLY)
1312 #define CHK_HV(CTX) GEN_PRIV(CTX)
1313 #define CHK_SV(CTX) GEN_PRIV(CTX)
1314 #define CHK_HVRM(CTX) GEN_PRIV(CTX)
1315 #else
1316 #define CHK_HV(CTX)                         \
1317     do {                                    \
1318         if (unlikely(ctx->pr || !ctx->hv)) {\
1319             GEN_PRIV(CTX);                  \
1320         }                                   \
1321     } while (0)
1322 #define CHK_SV(CTX)              \
1323     do {                         \
1324         if (unlikely(ctx->pr)) { \
1325             GEN_PRIV(CTX);       \
1326         }                        \
1327     } while (0)
1328 #define CHK_HVRM(CTX)                                   \
1329     do {                                                \
1330         if (unlikely(ctx->pr || !ctx->hv || ctx->dr)) { \
1331             GEN_PRIV(CTX);                              \
1332         }                                               \
1333     } while (0)
1334 #endif
1335
1336 #define CHK_NONE(CTX)
1337
1338 /*****************************************************************************/
1339 /* PowerPC instructions table                                                */
1340
1341 #define GEN_OPCODE(name, op1, op2, op3, invl, _typ, _typ2)                    \
1342 {                                                                             \
1343     .opc1 = op1,                                                              \
1344     .opc2 = op2,                                                              \
1345     .opc3 = op3,                                                              \
1346     .opc4 = 0xff,                                                             \
1347     .handler = {                                                              \
1348         .inval1  = invl,                                                      \
1349         .type = _typ,                                                         \
1350         .type2 = _typ2,                                                       \
1351         .handler = &gen_##name,                                               \
1352     },                                                                        \
1353     .oname = stringify(name),                                                 \
1354 }
1355 #define GEN_OPCODE_DUAL(name, op1, op2, op3, invl1, invl2, _typ, _typ2)       \
1356 {                                                                             \
1357     .opc1 = op1,                                                              \
1358     .opc2 = op2,                                                              \
1359     .opc3 = op3,                                                              \
1360     .opc4 = 0xff,                                                             \
1361     .handler = {                                                              \
1362         .inval1  = invl1,                                                     \
1363         .inval2  = invl2,                                                     \
1364         .type = _typ,                                                         \
1365         .type2 = _typ2,                                                       \
1366         .handler = &gen_##name,                                               \
1367     },                                                                        \
1368     .oname = stringify(name),                                                 \
1369 }
1370 #define GEN_OPCODE2(name, onam, op1, op2, op3, invl, _typ, _typ2)             \
1371 {                                                                             \
1372     .opc1 = op1,                                                              \
1373     .opc2 = op2,                                                              \
1374     .opc3 = op3,                                                              \
1375     .opc4 = 0xff,                                                             \
1376     .handler = {                                                              \
1377         .inval1  = invl,                                                      \
1378         .type = _typ,                                                         \
1379         .type2 = _typ2,                                                       \
1380         .handler = &gen_##name,                                               \
1381     },                                                                        \
1382     .oname = onam,                                                            \
1383 }
1384 #define GEN_OPCODE3(name, op1, op2, op3, op4, invl, _typ, _typ2)              \
1385 {                                                                             \
1386     .opc1 = op1,                                                              \
1387     .opc2 = op2,                                                              \
1388     .opc3 = op3,                                                              \
1389     .opc4 = op4,                                                              \
1390     .handler = {                                                              \
1391         .inval1  = invl,                                                      \
1392         .type = _typ,                                                         \
1393         .type2 = _typ2,                                                       \
1394         .handler = &gen_##name,                                               \
1395     },                                                                        \
1396     .oname = stringify(name),                                                 \
1397 }
1398 #define GEN_OPCODE4(name, onam, op1, op2, op3, op4, invl, _typ, _typ2)        \
1399 {                                                                             \
1400     .opc1 = op1,                                                              \
1401     .opc2 = op2,                                                              \
1402     .opc3 = op3,                                                              \
1403     .opc4 = op4,                                                              \
1404     .handler = {                                                              \
1405         .inval1  = invl,                                                      \
1406         .type = _typ,                                                         \
1407         .type2 = _typ2,                                                       \
1408         .handler = &gen_##name,                                               \
1409     },                                                                        \
1410     .oname = onam,                                                            \
1411 }
1412
1413 /* Invalid instruction */
1414 static void gen_invalid(DisasContext *ctx)
1415 {
1416     gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
1417 }
1418
1419 static opc_handler_t invalid_handler = {
1420     .inval1  = 0xFFFFFFFF,
1421     .inval2  = 0xFFFFFFFF,
1422     .type    = PPC_NONE,
1423     .type2   = PPC_NONE,
1424     .handler = gen_invalid,
1425 };
1426
1427 /***                           Integer comparison                          ***/
1428
1429 static inline void gen_op_cmp(TCGv arg0, TCGv arg1, int s, int crf)
1430 {
1431     TCGv t0 = tcg_temp_new();
1432     TCGv t1 = tcg_temp_new();
1433     TCGv_i32 t = tcg_temp_new_i32();
1434
1435     tcg_gen_movi_tl(t0, CRF_EQ);
1436     tcg_gen_movi_tl(t1, CRF_LT);
1437     tcg_gen_movcond_tl((s ? TCG_COND_LT : TCG_COND_LTU),
1438                        t0, arg0, arg1, t1, t0);
1439     tcg_gen_movi_tl(t1, CRF_GT);
1440     tcg_gen_movcond_tl((s ? TCG_COND_GT : TCG_COND_GTU),
1441                        t0, arg0, arg1, t1, t0);
1442
1443     tcg_gen_trunc_tl_i32(t, t0);
1444     tcg_gen_trunc_tl_i32(cpu_crf[crf], cpu_so);
1445     tcg_gen_or_i32(cpu_crf[crf], cpu_crf[crf], t);
1446 }
1447
1448 static inline void gen_op_cmpi(TCGv arg0, target_ulong arg1, int s, int crf)
1449 {
1450     TCGv t0 = tcg_constant_tl(arg1);
1451     gen_op_cmp(arg0, t0, s, crf);
1452 }
1453
1454 static inline void gen_op_cmp32(TCGv arg0, TCGv arg1, int s, int crf)
1455 {
1456     TCGv t0, t1;
1457     t0 = tcg_temp_new();
1458     t1 = tcg_temp_new();
1459     if (s) {
1460         tcg_gen_ext32s_tl(t0, arg0);
1461         tcg_gen_ext32s_tl(t1, arg1);
1462     } else {
1463         tcg_gen_ext32u_tl(t0, arg0);
1464         tcg_gen_ext32u_tl(t1, arg1);
1465     }
1466     gen_op_cmp(t0, t1, s, crf);
1467 }
1468
1469 static inline void gen_op_cmpi32(TCGv arg0, target_ulong arg1, int s, int crf)
1470 {
1471     TCGv t0 = tcg_constant_tl(arg1);
1472     gen_op_cmp32(arg0, t0, s, crf);
1473 }
1474
1475 static inline void gen_set_Rc0(DisasContext *ctx, TCGv reg)
1476 {
1477     if (NARROW_MODE(ctx)) {
1478         gen_op_cmpi32(reg, 0, 1, 0);
1479     } else {
1480         gen_op_cmpi(reg, 0, 1, 0);
1481     }
1482 }
1483
1484 /* cmprb - range comparison: isupper, isaplha, islower*/
1485 static void gen_cmprb(DisasContext *ctx)
1486 {
1487     TCGv_i32 src1 = tcg_temp_new_i32();
1488     TCGv_i32 src2 = tcg_temp_new_i32();
1489     TCGv_i32 src2lo = tcg_temp_new_i32();
1490     TCGv_i32 src2hi = tcg_temp_new_i32();
1491     TCGv_i32 crf = cpu_crf[crfD(ctx->opcode)];
1492
1493     tcg_gen_trunc_tl_i32(src1, cpu_gpr[rA(ctx->opcode)]);
1494     tcg_gen_trunc_tl_i32(src2, cpu_gpr[rB(ctx->opcode)]);
1495
1496     tcg_gen_andi_i32(src1, src1, 0xFF);
1497     tcg_gen_ext8u_i32(src2lo, src2);
1498     tcg_gen_shri_i32(src2, src2, 8);
1499     tcg_gen_ext8u_i32(src2hi, src2);
1500
1501     tcg_gen_setcond_i32(TCG_COND_LEU, src2lo, src2lo, src1);
1502     tcg_gen_setcond_i32(TCG_COND_LEU, src2hi, src1, src2hi);
1503     tcg_gen_and_i32(crf, src2lo, src2hi);
1504
1505     if (ctx->opcode & 0x00200000) {
1506         tcg_gen_shri_i32(src2, src2, 8);
1507         tcg_gen_ext8u_i32(src2lo, src2);
1508         tcg_gen_shri_i32(src2, src2, 8);
1509         tcg_gen_ext8u_i32(src2hi, src2);
1510         tcg_gen_setcond_i32(TCG_COND_LEU, src2lo, src2lo, src1);
1511         tcg_gen_setcond_i32(TCG_COND_LEU, src2hi, src1, src2hi);
1512         tcg_gen_and_i32(src2lo, src2lo, src2hi);
1513         tcg_gen_or_i32(crf, crf, src2lo);
1514     }
1515     tcg_gen_shli_i32(crf, crf, CRF_GT_BIT);
1516 }
1517
1518 #if defined(TARGET_PPC64)
1519 /* cmpeqb */
1520 static void gen_cmpeqb(DisasContext *ctx)
1521 {
1522     gen_helper_cmpeqb(cpu_crf[crfD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)],
1523                       cpu_gpr[rB(ctx->opcode)]);
1524 }
1525 #endif
1526
1527 /* isel (PowerPC 2.03 specification) */
1528 static void gen_isel(DisasContext *ctx)
1529 {
1530     uint32_t bi = rC(ctx->opcode);
1531     uint32_t mask = 0x08 >> (bi & 0x03);
1532     TCGv t0 = tcg_temp_new();
1533     TCGv zr;
1534
1535     tcg_gen_extu_i32_tl(t0, cpu_crf[bi >> 2]);
1536     tcg_gen_andi_tl(t0, t0, mask);
1537
1538     zr = tcg_constant_tl(0);
1539     tcg_gen_movcond_tl(TCG_COND_NE, cpu_gpr[rD(ctx->opcode)], t0, zr,
1540                        rA(ctx->opcode) ? cpu_gpr[rA(ctx->opcode)] : zr,
1541                        cpu_gpr[rB(ctx->opcode)]);
1542 }
1543
1544 /* cmpb: PowerPC 2.05 specification */
1545 static void gen_cmpb(DisasContext *ctx)
1546 {
1547     gen_helper_cmpb(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)],
1548                     cpu_gpr[rB(ctx->opcode)]);
1549 }
1550
1551 /***                           Integer arithmetic                          ***/
1552
1553 static inline void gen_op_arith_compute_ov(DisasContext *ctx, TCGv arg0,
1554                                            TCGv arg1, TCGv arg2, int sub)
1555 {
1556     TCGv t0 = tcg_temp_new();
1557
1558     tcg_gen_xor_tl(cpu_ov, arg0, arg2);
1559     tcg_gen_xor_tl(t0, arg1, arg2);
1560     if (sub) {
1561         tcg_gen_and_tl(cpu_ov, cpu_ov, t0);
1562     } else {
1563         tcg_gen_andc_tl(cpu_ov, cpu_ov, t0);
1564     }
1565     if (NARROW_MODE(ctx)) {
1566         tcg_gen_extract_tl(cpu_ov, cpu_ov, 31, 1);
1567         if (is_isa300(ctx)) {
1568             tcg_gen_mov_tl(cpu_ov32, cpu_ov);
1569         }
1570     } else {
1571         if (is_isa300(ctx)) {
1572             tcg_gen_extract_tl(cpu_ov32, cpu_ov, 31, 1);
1573         }
1574         tcg_gen_extract_tl(cpu_ov, cpu_ov, TARGET_LONG_BITS - 1, 1);
1575     }
1576     tcg_gen_or_tl(cpu_so, cpu_so, cpu_ov);
1577 }
1578
1579 static inline void gen_op_arith_compute_ca32(DisasContext *ctx,
1580                                              TCGv res, TCGv arg0, TCGv arg1,
1581                                              TCGv ca32, int sub)
1582 {
1583     TCGv t0;
1584
1585     if (!is_isa300(ctx)) {
1586         return;
1587     }
1588
1589     t0 = tcg_temp_new();
1590     if (sub) {
1591         tcg_gen_eqv_tl(t0, arg0, arg1);
1592     } else {
1593         tcg_gen_xor_tl(t0, arg0, arg1);
1594     }
1595     tcg_gen_xor_tl(t0, t0, res);
1596     tcg_gen_extract_tl(ca32, t0, 32, 1);
1597 }
1598
1599 /* Common add function */
1600 static inline void gen_op_arith_add(DisasContext *ctx, TCGv ret, TCGv arg1,
1601                                     TCGv arg2, TCGv ca, TCGv ca32,
1602                                     bool add_ca, bool compute_ca,
1603                                     bool compute_ov, bool compute_rc0)
1604 {
1605     TCGv t0 = ret;
1606
1607     if (compute_ca || compute_ov) {
1608         t0 = tcg_temp_new();
1609     }
1610
1611     if (compute_ca) {
1612         if (NARROW_MODE(ctx)) {
1613             /*
1614              * Caution: a non-obvious corner case of the spec is that
1615              * we must produce the *entire* 64-bit addition, but
1616              * produce the carry into bit 32.
1617              */
1618             TCGv t1 = tcg_temp_new();
1619             tcg_gen_xor_tl(t1, arg1, arg2);        /* add without carry */
1620             tcg_gen_add_tl(t0, arg1, arg2);
1621             if (add_ca) {
1622                 tcg_gen_add_tl(t0, t0, ca);
1623             }
1624             tcg_gen_xor_tl(ca, t0, t1);        /* bits changed w/ carry */
1625             tcg_gen_extract_tl(ca, ca, 32, 1);
1626             if (is_isa300(ctx)) {
1627                 tcg_gen_mov_tl(ca32, ca);
1628             }
1629         } else {
1630             TCGv zero = tcg_constant_tl(0);
1631             if (add_ca) {
1632                 tcg_gen_add2_tl(t0, ca, arg1, zero, ca, zero);
1633                 tcg_gen_add2_tl(t0, ca, t0, ca, arg2, zero);
1634             } else {
1635                 tcg_gen_add2_tl(t0, ca, arg1, zero, arg2, zero);
1636             }
1637             gen_op_arith_compute_ca32(ctx, t0, arg1, arg2, ca32, 0);
1638         }
1639     } else {
1640         tcg_gen_add_tl(t0, arg1, arg2);
1641         if (add_ca) {
1642             tcg_gen_add_tl(t0, t0, ca);
1643         }
1644     }
1645
1646     if (compute_ov) {
1647         gen_op_arith_compute_ov(ctx, t0, arg1, arg2, 0);
1648     }
1649     if (unlikely(compute_rc0)) {
1650         gen_set_Rc0(ctx, t0);
1651     }
1652
1653     if (t0 != ret) {
1654         tcg_gen_mov_tl(ret, t0);
1655     }
1656 }
1657 /* Add functions with two operands */
1658 #define GEN_INT_ARITH_ADD(name, opc3, ca, add_ca, compute_ca, compute_ov)     \
1659 static void glue(gen_, name)(DisasContext *ctx)                               \
1660 {                                                                             \
1661     gen_op_arith_add(ctx, cpu_gpr[rD(ctx->opcode)],                           \
1662                      cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],      \
1663                      ca, glue(ca, 32),                                        \
1664                      add_ca, compute_ca, compute_ov, Rc(ctx->opcode));        \
1665 }
1666 /* Add functions with one operand and one immediate */
1667 #define GEN_INT_ARITH_ADD_CONST(name, opc3, const_val, ca,                    \
1668                                 add_ca, compute_ca, compute_ov)               \
1669 static void glue(gen_, name)(DisasContext *ctx)                               \
1670 {                                                                             \
1671     TCGv t0 = tcg_constant_tl(const_val);                                     \
1672     gen_op_arith_add(ctx, cpu_gpr[rD(ctx->opcode)],                           \
1673                      cpu_gpr[rA(ctx->opcode)], t0,                            \
1674                      ca, glue(ca, 32),                                        \
1675                      add_ca, compute_ca, compute_ov, Rc(ctx->opcode));        \
1676 }
1677
1678 /* add  add.  addo  addo. */
1679 GEN_INT_ARITH_ADD(add, 0x08, cpu_ca, 0, 0, 0)
1680 GEN_INT_ARITH_ADD(addo, 0x18, cpu_ca, 0, 0, 1)
1681 /* addc  addc.  addco  addco. */
1682 GEN_INT_ARITH_ADD(addc, 0x00, cpu_ca, 0, 1, 0)
1683 GEN_INT_ARITH_ADD(addco, 0x10, cpu_ca, 0, 1, 1)
1684 /* adde  adde.  addeo  addeo. */
1685 GEN_INT_ARITH_ADD(adde, 0x04, cpu_ca, 1, 1, 0)
1686 GEN_INT_ARITH_ADD(addeo, 0x14, cpu_ca, 1, 1, 1)
1687 /* addme  addme.  addmeo  addmeo.  */
1688 GEN_INT_ARITH_ADD_CONST(addme, 0x07, -1LL, cpu_ca, 1, 1, 0)
1689 GEN_INT_ARITH_ADD_CONST(addmeo, 0x17, -1LL, cpu_ca, 1, 1, 1)
1690 /* addex */
1691 GEN_INT_ARITH_ADD(addex, 0x05, cpu_ov, 1, 1, 0);
1692 /* addze  addze.  addzeo  addzeo.*/
1693 GEN_INT_ARITH_ADD_CONST(addze, 0x06, 0, cpu_ca, 1, 1, 0)
1694 GEN_INT_ARITH_ADD_CONST(addzeo, 0x16, 0, cpu_ca, 1, 1, 1)
1695 /* addic  addic.*/
1696 static inline void gen_op_addic(DisasContext *ctx, bool compute_rc0)
1697 {
1698     TCGv c = tcg_constant_tl(SIMM(ctx->opcode));
1699     gen_op_arith_add(ctx, cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)],
1700                      c, cpu_ca, cpu_ca32, 0, 1, 0, compute_rc0);
1701 }
1702
1703 static void gen_addic(DisasContext *ctx)
1704 {
1705     gen_op_addic(ctx, 0);
1706 }
1707
1708 static void gen_addic_(DisasContext *ctx)
1709 {
1710     gen_op_addic(ctx, 1);
1711 }
1712
1713 static inline void gen_op_arith_divw(DisasContext *ctx, TCGv ret, TCGv arg1,
1714                                      TCGv arg2, int sign, int compute_ov)
1715 {
1716     TCGv_i32 t0 = tcg_temp_new_i32();
1717     TCGv_i32 t1 = tcg_temp_new_i32();
1718     TCGv_i32 t2 = tcg_temp_new_i32();
1719     TCGv_i32 t3 = tcg_temp_new_i32();
1720
1721     tcg_gen_trunc_tl_i32(t0, arg1);
1722     tcg_gen_trunc_tl_i32(t1, arg2);
1723     if (sign) {
1724         tcg_gen_setcondi_i32(TCG_COND_EQ, t2, t0, INT_MIN);
1725         tcg_gen_setcondi_i32(TCG_COND_EQ, t3, t1, -1);
1726         tcg_gen_and_i32(t2, t2, t3);
1727         tcg_gen_setcondi_i32(TCG_COND_EQ, t3, t1, 0);
1728         tcg_gen_or_i32(t2, t2, t3);
1729         tcg_gen_movi_i32(t3, 0);
1730         tcg_gen_movcond_i32(TCG_COND_NE, t1, t2, t3, t2, t1);
1731         tcg_gen_div_i32(t3, t0, t1);
1732         tcg_gen_extu_i32_tl(ret, t3);
1733     } else {
1734         tcg_gen_setcondi_i32(TCG_COND_EQ, t2, t1, 0);
1735         tcg_gen_movi_i32(t3, 0);
1736         tcg_gen_movcond_i32(TCG_COND_NE, t1, t2, t3, t2, t1);
1737         tcg_gen_divu_i32(t3, t0, t1);
1738         tcg_gen_extu_i32_tl(ret, t3);
1739     }
1740     if (compute_ov) {
1741         tcg_gen_extu_i32_tl(cpu_ov, t2);
1742         if (is_isa300(ctx)) {
1743             tcg_gen_extu_i32_tl(cpu_ov32, t2);
1744         }
1745         tcg_gen_or_tl(cpu_so, cpu_so, cpu_ov);
1746     }
1747
1748     if (unlikely(Rc(ctx->opcode) != 0)) {
1749         gen_set_Rc0(ctx, ret);
1750     }
1751 }
1752 /* Div functions */
1753 #define GEN_INT_ARITH_DIVW(name, opc3, sign, compute_ov)                      \
1754 static void glue(gen_, name)(DisasContext *ctx)                               \
1755 {                                                                             \
1756     gen_op_arith_divw(ctx, cpu_gpr[rD(ctx->opcode)],                          \
1757                      cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],      \
1758                      sign, compute_ov);                                       \
1759 }
1760 /* divwu  divwu.  divwuo  divwuo.   */
1761 GEN_INT_ARITH_DIVW(divwu, 0x0E, 0, 0);
1762 GEN_INT_ARITH_DIVW(divwuo, 0x1E, 0, 1);
1763 /* divw  divw.  divwo  divwo.   */
1764 GEN_INT_ARITH_DIVW(divw, 0x0F, 1, 0);
1765 GEN_INT_ARITH_DIVW(divwo, 0x1F, 1, 1);
1766
1767 /* div[wd]eu[o][.] */
1768 #define GEN_DIVE(name, hlpr, compute_ov)                                      \
1769 static void gen_##name(DisasContext *ctx)                                     \
1770 {                                                                             \
1771     TCGv_i32 t0 = tcg_constant_i32(compute_ov);                               \
1772     gen_helper_##hlpr(cpu_gpr[rD(ctx->opcode)], cpu_env,                      \
1773                      cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], t0); \
1774     if (unlikely(Rc(ctx->opcode) != 0)) {                                     \
1775         gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);                           \
1776     }                                                                         \
1777 }
1778
1779 GEN_DIVE(divweu, divweu, 0);
1780 GEN_DIVE(divweuo, divweu, 1);
1781 GEN_DIVE(divwe, divwe, 0);
1782 GEN_DIVE(divweo, divwe, 1);
1783
1784 #if defined(TARGET_PPC64)
1785 static inline void gen_op_arith_divd(DisasContext *ctx, TCGv ret, TCGv arg1,
1786                                      TCGv arg2, int sign, int compute_ov)
1787 {
1788     TCGv_i64 t0 = tcg_temp_new_i64();
1789     TCGv_i64 t1 = tcg_temp_new_i64();
1790     TCGv_i64 t2 = tcg_temp_new_i64();
1791     TCGv_i64 t3 = tcg_temp_new_i64();
1792
1793     tcg_gen_mov_i64(t0, arg1);
1794     tcg_gen_mov_i64(t1, arg2);
1795     if (sign) {
1796         tcg_gen_setcondi_i64(TCG_COND_EQ, t2, t0, INT64_MIN);
1797         tcg_gen_setcondi_i64(TCG_COND_EQ, t3, t1, -1);
1798         tcg_gen_and_i64(t2, t2, t3);
1799         tcg_gen_setcondi_i64(TCG_COND_EQ, t3, t1, 0);
1800         tcg_gen_or_i64(t2, t2, t3);
1801         tcg_gen_movi_i64(t3, 0);
1802         tcg_gen_movcond_i64(TCG_COND_NE, t1, t2, t3, t2, t1);
1803         tcg_gen_div_i64(ret, t0, t1);
1804     } else {
1805         tcg_gen_setcondi_i64(TCG_COND_EQ, t2, t1, 0);
1806         tcg_gen_movi_i64(t3, 0);
1807         tcg_gen_movcond_i64(TCG_COND_NE, t1, t2, t3, t2, t1);
1808         tcg_gen_divu_i64(ret, t0, t1);
1809     }
1810     if (compute_ov) {
1811         tcg_gen_mov_tl(cpu_ov, t2);
1812         if (is_isa300(ctx)) {
1813             tcg_gen_mov_tl(cpu_ov32, t2);
1814         }
1815         tcg_gen_or_tl(cpu_so, cpu_so, cpu_ov);
1816     }
1817
1818     if (unlikely(Rc(ctx->opcode) != 0)) {
1819         gen_set_Rc0(ctx, ret);
1820     }
1821 }
1822
1823 #define GEN_INT_ARITH_DIVD(name, opc3, sign, compute_ov)                      \
1824 static void glue(gen_, name)(DisasContext *ctx)                               \
1825 {                                                                             \
1826     gen_op_arith_divd(ctx, cpu_gpr[rD(ctx->opcode)],                          \
1827                       cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],     \
1828                       sign, compute_ov);                                      \
1829 }
1830 /* divdu  divdu.  divduo  divduo.   */
1831 GEN_INT_ARITH_DIVD(divdu, 0x0E, 0, 0);
1832 GEN_INT_ARITH_DIVD(divduo, 0x1E, 0, 1);
1833 /* divd  divd.  divdo  divdo.   */
1834 GEN_INT_ARITH_DIVD(divd, 0x0F, 1, 0);
1835 GEN_INT_ARITH_DIVD(divdo, 0x1F, 1, 1);
1836
1837 GEN_DIVE(divdeu, divdeu, 0);
1838 GEN_DIVE(divdeuo, divdeu, 1);
1839 GEN_DIVE(divde, divde, 0);
1840 GEN_DIVE(divdeo, divde, 1);
1841 #endif
1842
1843 static inline void gen_op_arith_modw(DisasContext *ctx, TCGv ret, TCGv arg1,
1844                                      TCGv arg2, int sign)
1845 {
1846     TCGv_i32 t0 = tcg_temp_new_i32();
1847     TCGv_i32 t1 = tcg_temp_new_i32();
1848
1849     tcg_gen_trunc_tl_i32(t0, arg1);
1850     tcg_gen_trunc_tl_i32(t1, arg2);
1851     if (sign) {
1852         TCGv_i32 t2 = tcg_temp_new_i32();
1853         TCGv_i32 t3 = tcg_temp_new_i32();
1854         tcg_gen_setcondi_i32(TCG_COND_EQ, t2, t0, INT_MIN);
1855         tcg_gen_setcondi_i32(TCG_COND_EQ, t3, t1, -1);
1856         tcg_gen_and_i32(t2, t2, t3);
1857         tcg_gen_setcondi_i32(TCG_COND_EQ, t3, t1, 0);
1858         tcg_gen_or_i32(t2, t2, t3);
1859         tcg_gen_movi_i32(t3, 0);
1860         tcg_gen_movcond_i32(TCG_COND_NE, t1, t2, t3, t2, t1);
1861         tcg_gen_rem_i32(t3, t0, t1);
1862         tcg_gen_ext_i32_tl(ret, t3);
1863     } else {
1864         TCGv_i32 t2 = tcg_constant_i32(1);
1865         TCGv_i32 t3 = tcg_constant_i32(0);
1866         tcg_gen_movcond_i32(TCG_COND_EQ, t1, t1, t3, t2, t1);
1867         tcg_gen_remu_i32(t0, t0, t1);
1868         tcg_gen_extu_i32_tl(ret, t0);
1869     }
1870 }
1871
1872 #define GEN_INT_ARITH_MODW(name, opc3, sign)                                \
1873 static void glue(gen_, name)(DisasContext *ctx)                             \
1874 {                                                                           \
1875     gen_op_arith_modw(ctx, cpu_gpr[rD(ctx->opcode)],                        \
1876                       cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],   \
1877                       sign);                                                \
1878 }
1879
1880 GEN_INT_ARITH_MODW(moduw, 0x08, 0);
1881 GEN_INT_ARITH_MODW(modsw, 0x18, 1);
1882
1883 #if defined(TARGET_PPC64)
1884 static inline void gen_op_arith_modd(DisasContext *ctx, TCGv ret, TCGv arg1,
1885                                      TCGv arg2, int sign)
1886 {
1887     TCGv_i64 t0 = tcg_temp_new_i64();
1888     TCGv_i64 t1 = tcg_temp_new_i64();
1889
1890     tcg_gen_mov_i64(t0, arg1);
1891     tcg_gen_mov_i64(t1, arg2);
1892     if (sign) {
1893         TCGv_i64 t2 = tcg_temp_new_i64();
1894         TCGv_i64 t3 = tcg_temp_new_i64();
1895         tcg_gen_setcondi_i64(TCG_COND_EQ, t2, t0, INT64_MIN);
1896         tcg_gen_setcondi_i64(TCG_COND_EQ, t3, t1, -1);
1897         tcg_gen_and_i64(t2, t2, t3);
1898         tcg_gen_setcondi_i64(TCG_COND_EQ, t3, t1, 0);
1899         tcg_gen_or_i64(t2, t2, t3);
1900         tcg_gen_movi_i64(t3, 0);
1901         tcg_gen_movcond_i64(TCG_COND_NE, t1, t2, t3, t2, t1);
1902         tcg_gen_rem_i64(ret, t0, t1);
1903     } else {
1904         TCGv_i64 t2 = tcg_constant_i64(1);
1905         TCGv_i64 t3 = tcg_constant_i64(0);
1906         tcg_gen_movcond_i64(TCG_COND_EQ, t1, t1, t3, t2, t1);
1907         tcg_gen_remu_i64(ret, t0, t1);
1908     }
1909 }
1910
1911 #define GEN_INT_ARITH_MODD(name, opc3, sign)                            \
1912 static void glue(gen_, name)(DisasContext *ctx)                           \
1913 {                                                                         \
1914   gen_op_arith_modd(ctx, cpu_gpr[rD(ctx->opcode)],                        \
1915                     cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],   \
1916                     sign);                                                \
1917 }
1918
1919 GEN_INT_ARITH_MODD(modud, 0x08, 0);
1920 GEN_INT_ARITH_MODD(modsd, 0x18, 1);
1921 #endif
1922
1923 /* mulhw  mulhw. */
1924 static void gen_mulhw(DisasContext *ctx)
1925 {
1926     TCGv_i32 t0 = tcg_temp_new_i32();
1927     TCGv_i32 t1 = tcg_temp_new_i32();
1928
1929     tcg_gen_trunc_tl_i32(t0, cpu_gpr[rA(ctx->opcode)]);
1930     tcg_gen_trunc_tl_i32(t1, cpu_gpr[rB(ctx->opcode)]);
1931     tcg_gen_muls2_i32(t0, t1, t0, t1);
1932     tcg_gen_extu_i32_tl(cpu_gpr[rD(ctx->opcode)], t1);
1933     if (unlikely(Rc(ctx->opcode) != 0)) {
1934         gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
1935     }
1936 }
1937
1938 /* mulhwu  mulhwu.  */
1939 static void gen_mulhwu(DisasContext *ctx)
1940 {
1941     TCGv_i32 t0 = tcg_temp_new_i32();
1942     TCGv_i32 t1 = tcg_temp_new_i32();
1943
1944     tcg_gen_trunc_tl_i32(t0, cpu_gpr[rA(ctx->opcode)]);
1945     tcg_gen_trunc_tl_i32(t1, cpu_gpr[rB(ctx->opcode)]);
1946     tcg_gen_mulu2_i32(t0, t1, t0, t1);
1947     tcg_gen_extu_i32_tl(cpu_gpr[rD(ctx->opcode)], t1);
1948     if (unlikely(Rc(ctx->opcode) != 0)) {
1949         gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
1950     }
1951 }
1952
1953 /* mullw  mullw. */
1954 static void gen_mullw(DisasContext *ctx)
1955 {
1956 #if defined(TARGET_PPC64)
1957     TCGv_i64 t0, t1;
1958     t0 = tcg_temp_new_i64();
1959     t1 = tcg_temp_new_i64();
1960     tcg_gen_ext32s_tl(t0, cpu_gpr[rA(ctx->opcode)]);
1961     tcg_gen_ext32s_tl(t1, cpu_gpr[rB(ctx->opcode)]);
1962     tcg_gen_mul_i64(cpu_gpr[rD(ctx->opcode)], t0, t1);
1963 #else
1964     tcg_gen_mul_i32(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)],
1965                     cpu_gpr[rB(ctx->opcode)]);
1966 #endif
1967     if (unlikely(Rc(ctx->opcode) != 0)) {
1968         gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
1969     }
1970 }
1971
1972 /* mullwo  mullwo. */
1973 static void gen_mullwo(DisasContext *ctx)
1974 {
1975     TCGv_i32 t0 = tcg_temp_new_i32();
1976     TCGv_i32 t1 = tcg_temp_new_i32();
1977
1978     tcg_gen_trunc_tl_i32(t0, cpu_gpr[rA(ctx->opcode)]);
1979     tcg_gen_trunc_tl_i32(t1, cpu_gpr[rB(ctx->opcode)]);
1980     tcg_gen_muls2_i32(t0, t1, t0, t1);
1981 #if defined(TARGET_PPC64)
1982     tcg_gen_concat_i32_i64(cpu_gpr[rD(ctx->opcode)], t0, t1);
1983 #else
1984     tcg_gen_mov_i32(cpu_gpr[rD(ctx->opcode)], t0);
1985 #endif
1986
1987     tcg_gen_sari_i32(t0, t0, 31);
1988     tcg_gen_setcond_i32(TCG_COND_NE, t0, t0, t1);
1989     tcg_gen_extu_i32_tl(cpu_ov, t0);
1990     if (is_isa300(ctx)) {
1991         tcg_gen_mov_tl(cpu_ov32, cpu_ov);
1992     }
1993     tcg_gen_or_tl(cpu_so, cpu_so, cpu_ov);
1994
1995     if (unlikely(Rc(ctx->opcode) != 0)) {
1996         gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
1997     }
1998 }
1999
2000 /* mulli */
2001 static void gen_mulli(DisasContext *ctx)
2002 {
2003     tcg_gen_muli_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)],
2004                     SIMM(ctx->opcode));
2005 }
2006
2007 #if defined(TARGET_PPC64)
2008 /* mulhd  mulhd. */
2009 static void gen_mulhd(DisasContext *ctx)
2010 {
2011     TCGv lo = tcg_temp_new();
2012     tcg_gen_muls2_tl(lo, cpu_gpr[rD(ctx->opcode)],
2013                      cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
2014     if (unlikely(Rc(ctx->opcode) != 0)) {
2015         gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
2016     }
2017 }
2018
2019 /* mulhdu  mulhdu. */
2020 static void gen_mulhdu(DisasContext *ctx)
2021 {
2022     TCGv lo = tcg_temp_new();
2023     tcg_gen_mulu2_tl(lo, cpu_gpr[rD(ctx->opcode)],
2024                      cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
2025     if (unlikely(Rc(ctx->opcode) != 0)) {
2026         gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
2027     }
2028 }
2029
2030 /* mulld  mulld. */
2031 static void gen_mulld(DisasContext *ctx)
2032 {
2033     tcg_gen_mul_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)],
2034                    cpu_gpr[rB(ctx->opcode)]);
2035     if (unlikely(Rc(ctx->opcode) != 0)) {
2036         gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
2037     }
2038 }
2039
2040 /* mulldo  mulldo. */
2041 static void gen_mulldo(DisasContext *ctx)
2042 {
2043     TCGv_i64 t0 = tcg_temp_new_i64();
2044     TCGv_i64 t1 = tcg_temp_new_i64();
2045
2046     tcg_gen_muls2_i64(t0, t1, cpu_gpr[rA(ctx->opcode)],
2047                       cpu_gpr[rB(ctx->opcode)]);
2048     tcg_gen_mov_i64(cpu_gpr[rD(ctx->opcode)], t0);
2049
2050     tcg_gen_sari_i64(t0, t0, 63);
2051     tcg_gen_setcond_i64(TCG_COND_NE, cpu_ov, t0, t1);
2052     if (is_isa300(ctx)) {
2053         tcg_gen_mov_tl(cpu_ov32, cpu_ov);
2054     }
2055     tcg_gen_or_tl(cpu_so, cpu_so, cpu_ov);
2056
2057     if (unlikely(Rc(ctx->opcode) != 0)) {
2058         gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
2059     }
2060 }
2061 #endif
2062
2063 /* Common subf function */
2064 static inline void gen_op_arith_subf(DisasContext *ctx, TCGv ret, TCGv arg1,
2065                                      TCGv arg2, bool add_ca, bool compute_ca,
2066                                      bool compute_ov, bool compute_rc0)
2067 {
2068     TCGv t0 = ret;
2069
2070     if (compute_ca || compute_ov) {
2071         t0 = tcg_temp_new();
2072     }
2073
2074     if (compute_ca) {
2075         /* dest = ~arg1 + arg2 [+ ca].  */
2076         if (NARROW_MODE(ctx)) {
2077             /*
2078              * Caution: a non-obvious corner case of the spec is that
2079              * we must produce the *entire* 64-bit addition, but
2080              * produce the carry into bit 32.
2081              */
2082             TCGv inv1 = tcg_temp_new();
2083             TCGv t1 = tcg_temp_new();
2084             tcg_gen_not_tl(inv1, arg1);
2085             if (add_ca) {
2086                 tcg_gen_add_tl(t0, arg2, cpu_ca);
2087             } else {
2088                 tcg_gen_addi_tl(t0, arg2, 1);
2089             }
2090             tcg_gen_xor_tl(t1, arg2, inv1);         /* add without carry */
2091             tcg_gen_add_tl(t0, t0, inv1);
2092             tcg_gen_xor_tl(cpu_ca, t0, t1);         /* bits changes w/ carry */
2093             tcg_gen_extract_tl(cpu_ca, cpu_ca, 32, 1);
2094             if (is_isa300(ctx)) {
2095                 tcg_gen_mov_tl(cpu_ca32, cpu_ca);
2096             }
2097         } else if (add_ca) {
2098             TCGv zero, inv1 = tcg_temp_new();
2099             tcg_gen_not_tl(inv1, arg1);
2100             zero = tcg_constant_tl(0);
2101             tcg_gen_add2_tl(t0, cpu_ca, arg2, zero, cpu_ca, zero);
2102             tcg_gen_add2_tl(t0, cpu_ca, t0, cpu_ca, inv1, zero);
2103             gen_op_arith_compute_ca32(ctx, t0, inv1, arg2, cpu_ca32, 0);
2104         } else {
2105             tcg_gen_setcond_tl(TCG_COND_GEU, cpu_ca, arg2, arg1);
2106             tcg_gen_sub_tl(t0, arg2, arg1);
2107             gen_op_arith_compute_ca32(ctx, t0, arg1, arg2, cpu_ca32, 1);
2108         }
2109     } else if (add_ca) {
2110         /*
2111          * Since we're ignoring carry-out, we can simplify the
2112          * standard ~arg1 + arg2 + ca to arg2 - arg1 + ca - 1.
2113          */
2114         tcg_gen_sub_tl(t0, arg2, arg1);
2115         tcg_gen_add_tl(t0, t0, cpu_ca);
2116         tcg_gen_subi_tl(t0, t0, 1);
2117     } else {
2118         tcg_gen_sub_tl(t0, arg2, arg1);
2119     }
2120
2121     if (compute_ov) {
2122         gen_op_arith_compute_ov(ctx, t0, arg1, arg2, 1);
2123     }
2124     if (unlikely(compute_rc0)) {
2125         gen_set_Rc0(ctx, t0);
2126     }
2127
2128     if (t0 != ret) {
2129         tcg_gen_mov_tl(ret, t0);
2130     }
2131 }
2132 /* Sub functions with Two operands functions */
2133 #define GEN_INT_ARITH_SUBF(name, opc3, add_ca, compute_ca, compute_ov)        \
2134 static void glue(gen_, name)(DisasContext *ctx)                               \
2135 {                                                                             \
2136     gen_op_arith_subf(ctx, cpu_gpr[rD(ctx->opcode)],                          \
2137                       cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],     \
2138                       add_ca, compute_ca, compute_ov, Rc(ctx->opcode));       \
2139 }
2140 /* Sub functions with one operand and one immediate */
2141 #define GEN_INT_ARITH_SUBF_CONST(name, opc3, const_val,                       \
2142                                 add_ca, compute_ca, compute_ov)               \
2143 static void glue(gen_, name)(DisasContext *ctx)                               \
2144 {                                                                             \
2145     TCGv t0 = tcg_constant_tl(const_val);                                     \
2146     gen_op_arith_subf(ctx, cpu_gpr[rD(ctx->opcode)],                          \
2147                       cpu_gpr[rA(ctx->opcode)], t0,                           \
2148                       add_ca, compute_ca, compute_ov, Rc(ctx->opcode));       \
2149 }
2150 /* subf  subf.  subfo  subfo. */
2151 GEN_INT_ARITH_SUBF(subf, 0x01, 0, 0, 0)
2152 GEN_INT_ARITH_SUBF(subfo, 0x11, 0, 0, 1)
2153 /* subfc  subfc.  subfco  subfco. */
2154 GEN_INT_ARITH_SUBF(subfc, 0x00, 0, 1, 0)
2155 GEN_INT_ARITH_SUBF(subfco, 0x10, 0, 1, 1)
2156 /* subfe  subfe.  subfeo  subfo. */
2157 GEN_INT_ARITH_SUBF(subfe, 0x04, 1, 1, 0)
2158 GEN_INT_ARITH_SUBF(subfeo, 0x14, 1, 1, 1)
2159 /* subfme  subfme.  subfmeo  subfmeo.  */
2160 GEN_INT_ARITH_SUBF_CONST(subfme, 0x07, -1LL, 1, 1, 0)
2161 GEN_INT_ARITH_SUBF_CONST(subfmeo, 0x17, -1LL, 1, 1, 1)
2162 /* subfze  subfze.  subfzeo  subfzeo.*/
2163 GEN_INT_ARITH_SUBF_CONST(subfze, 0x06, 0, 1, 1, 0)
2164 GEN_INT_ARITH_SUBF_CONST(subfzeo, 0x16, 0, 1, 1, 1)
2165
2166 /* subfic */
2167 static void gen_subfic(DisasContext *ctx)
2168 {
2169     TCGv c = tcg_constant_tl(SIMM(ctx->opcode));
2170     gen_op_arith_subf(ctx, cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)],
2171                       c, 0, 1, 0, 0);
2172 }
2173
2174 /* neg neg. nego nego. */
2175 static inline void gen_op_arith_neg(DisasContext *ctx, bool compute_ov)
2176 {
2177     TCGv zero = tcg_constant_tl(0);
2178     gen_op_arith_subf(ctx, cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)],
2179                       zero, 0, 0, compute_ov, Rc(ctx->opcode));
2180 }
2181
2182 static void gen_neg(DisasContext *ctx)
2183 {
2184     tcg_gen_neg_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
2185     if (unlikely(Rc(ctx->opcode))) {
2186         gen_set_Rc0(ctx, cpu_gpr[rD(ctx->opcode)]);
2187     }
2188 }
2189
2190 static void gen_nego(DisasContext *ctx)
2191 {
2192     gen_op_arith_neg(ctx, 1);
2193 }
2194
2195 /***                            Integer logical                            ***/
2196 #define GEN_LOGICAL2(name, tcg_op, opc, type)                                 \
2197 static void glue(gen_, name)(DisasContext *ctx)                               \
2198 {                                                                             \
2199     tcg_op(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)],                \
2200        cpu_gpr[rB(ctx->opcode)]);                                             \
2201     if (unlikely(Rc(ctx->opcode) != 0))                                       \
2202         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);                           \
2203 }
2204
2205 #define GEN_LOGICAL1(name, tcg_op, opc, type)                                 \
2206 static void glue(gen_, name)(DisasContext *ctx)                               \
2207 {                                                                             \
2208     tcg_op(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);               \
2209     if (unlikely(Rc(ctx->opcode) != 0))                                       \
2210         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);                           \
2211 }
2212
2213 /* and & and. */
2214 GEN_LOGICAL2(and, tcg_gen_and_tl, 0x00, PPC_INTEGER);
2215 /* andc & andc. */
2216 GEN_LOGICAL2(andc, tcg_gen_andc_tl, 0x01, PPC_INTEGER);
2217
2218 /* andi. */
2219 static void gen_andi_(DisasContext *ctx)
2220 {
2221     tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)],
2222                     UIMM(ctx->opcode));
2223     gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2224 }
2225
2226 /* andis. */
2227 static void gen_andis_(DisasContext *ctx)
2228 {
2229     tcg_gen_andi_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)],
2230                     UIMM(ctx->opcode) << 16);
2231     gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2232 }
2233
2234 /* cntlzw */
2235 static void gen_cntlzw(DisasContext *ctx)
2236 {
2237     TCGv_i32 t = tcg_temp_new_i32();
2238
2239     tcg_gen_trunc_tl_i32(t, cpu_gpr[rS(ctx->opcode)]);
2240     tcg_gen_clzi_i32(t, t, 32);
2241     tcg_gen_extu_i32_tl(cpu_gpr[rA(ctx->opcode)], t);
2242
2243     if (unlikely(Rc(ctx->opcode) != 0)) {
2244         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2245     }
2246 }
2247
2248 /* cnttzw */
2249 static void gen_cnttzw(DisasContext *ctx)
2250 {
2251     TCGv_i32 t = tcg_temp_new_i32();
2252
2253     tcg_gen_trunc_tl_i32(t, cpu_gpr[rS(ctx->opcode)]);
2254     tcg_gen_ctzi_i32(t, t, 32);
2255     tcg_gen_extu_i32_tl(cpu_gpr[rA(ctx->opcode)], t);
2256
2257     if (unlikely(Rc(ctx->opcode) != 0)) {
2258         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2259     }
2260 }
2261
2262 /* eqv & eqv. */
2263 GEN_LOGICAL2(eqv, tcg_gen_eqv_tl, 0x08, PPC_INTEGER);
2264 /* extsb & extsb. */
2265 GEN_LOGICAL1(extsb, tcg_gen_ext8s_tl, 0x1D, PPC_INTEGER);
2266 /* extsh & extsh. */
2267 GEN_LOGICAL1(extsh, tcg_gen_ext16s_tl, 0x1C, PPC_INTEGER);
2268 /* nand & nand. */
2269 GEN_LOGICAL2(nand, tcg_gen_nand_tl, 0x0E, PPC_INTEGER);
2270 /* nor & nor. */
2271 GEN_LOGICAL2(nor, tcg_gen_nor_tl, 0x03, PPC_INTEGER);
2272
2273 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
2274 static void gen_pause(DisasContext *ctx)
2275 {
2276     TCGv_i32 t0 = tcg_constant_i32(0);
2277     tcg_gen_st_i32(t0, cpu_env,
2278                    -offsetof(PowerPCCPU, env) + offsetof(CPUState, halted));
2279
2280     /* Stop translation, this gives other CPUs a chance to run */
2281     gen_exception_nip(ctx, EXCP_HLT, ctx->base.pc_next);
2282 }
2283 #endif /* defined(TARGET_PPC64) */
2284
2285 /* or & or. */
2286 static void gen_or(DisasContext *ctx)
2287 {
2288     int rs, ra, rb;
2289
2290     rs = rS(ctx->opcode);
2291     ra = rA(ctx->opcode);
2292     rb = rB(ctx->opcode);
2293     /* Optimisation for mr. ri case */
2294     if (rs != ra || rs != rb) {
2295         if (rs != rb) {
2296             tcg_gen_or_tl(cpu_gpr[ra], cpu_gpr[rs], cpu_gpr[rb]);
2297         } else {
2298             tcg_gen_mov_tl(cpu_gpr[ra], cpu_gpr[rs]);
2299         }
2300         if (unlikely(Rc(ctx->opcode) != 0)) {
2301             gen_set_Rc0(ctx, cpu_gpr[ra]);
2302         }
2303     } else if (unlikely(Rc(ctx->opcode) != 0)) {
2304         gen_set_Rc0(ctx, cpu_gpr[rs]);
2305 #if defined(TARGET_PPC64)
2306     } else if (rs != 0) { /* 0 is nop */
2307         int prio = 0;
2308
2309         switch (rs) {
2310         case 1:
2311             /* Set process priority to low */
2312             prio = 2;
2313             break;
2314         case 6:
2315             /* Set process priority to medium-low */
2316             prio = 3;
2317             break;
2318         case 2:
2319             /* Set process priority to normal */
2320             prio = 4;
2321             break;
2322 #if !defined(CONFIG_USER_ONLY)
2323         case 31:
2324             if (!ctx->pr) {
2325                 /* Set process priority to very low */
2326                 prio = 1;
2327             }
2328             break;
2329         case 5:
2330             if (!ctx->pr) {
2331                 /* Set process priority to medium-hight */
2332                 prio = 5;
2333             }
2334             break;
2335         case 3:
2336             if (!ctx->pr) {
2337                 /* Set process priority to high */
2338                 prio = 6;
2339             }
2340             break;
2341         case 7:
2342             if (ctx->hv && !ctx->pr) {
2343                 /* Set process priority to very high */
2344                 prio = 7;
2345             }
2346             break;
2347 #endif
2348         default:
2349             break;
2350         }
2351         if (prio) {
2352             TCGv t0 = tcg_temp_new();
2353             gen_load_spr(t0, SPR_PPR);
2354             tcg_gen_andi_tl(t0, t0, ~0x001C000000000000ULL);
2355             tcg_gen_ori_tl(t0, t0, ((uint64_t)prio) << 50);
2356             gen_store_spr(SPR_PPR, t0);
2357         }
2358 #if !defined(CONFIG_USER_ONLY)
2359         /*
2360          * Pause out of TCG otherwise spin loops with smt_low eat too
2361          * much CPU and the kernel hangs.  This applies to all
2362          * encodings other than no-op, e.g., miso(rs=26), yield(27),
2363          * mdoio(29), mdoom(30), and all currently undefined.
2364          */
2365         gen_pause(ctx);
2366 #endif
2367 #endif
2368     }
2369 }
2370 /* orc & orc. */
2371 GEN_LOGICAL2(orc, tcg_gen_orc_tl, 0x0C, PPC_INTEGER);
2372
2373 /* xor & xor. */
2374 static void gen_xor(DisasContext *ctx)
2375 {
2376     /* Optimisation for "set to zero" case */
2377     if (rS(ctx->opcode) != rB(ctx->opcode)) {
2378         tcg_gen_xor_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)],
2379                        cpu_gpr[rB(ctx->opcode)]);
2380     } else {
2381         tcg_gen_movi_tl(cpu_gpr[rA(ctx->opcode)], 0);
2382     }
2383     if (unlikely(Rc(ctx->opcode) != 0)) {
2384         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2385     }
2386 }
2387
2388 /* ori */
2389 static void gen_ori(DisasContext *ctx)
2390 {
2391     target_ulong uimm = UIMM(ctx->opcode);
2392
2393     if (rS(ctx->opcode) == rA(ctx->opcode) && uimm == 0) {
2394         return;
2395     }
2396     tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], uimm);
2397 }
2398
2399 /* oris */
2400 static void gen_oris(DisasContext *ctx)
2401 {
2402     target_ulong uimm = UIMM(ctx->opcode);
2403
2404     if (rS(ctx->opcode) == rA(ctx->opcode) && uimm == 0) {
2405         /* NOP */
2406         return;
2407     }
2408     tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)],
2409                    uimm << 16);
2410 }
2411
2412 /* xori */
2413 static void gen_xori(DisasContext *ctx)
2414 {
2415     target_ulong uimm = UIMM(ctx->opcode);
2416
2417     if (rS(ctx->opcode) == rA(ctx->opcode) && uimm == 0) {
2418         /* NOP */
2419         return;
2420     }
2421     tcg_gen_xori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], uimm);
2422 }
2423
2424 /* xoris */
2425 static void gen_xoris(DisasContext *ctx)
2426 {
2427     target_ulong uimm = UIMM(ctx->opcode);
2428
2429     if (rS(ctx->opcode) == rA(ctx->opcode) && uimm == 0) {
2430         /* NOP */
2431         return;
2432     }
2433     tcg_gen_xori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)],
2434                     uimm << 16);
2435 }
2436
2437 /* popcntb : PowerPC 2.03 specification */
2438 static void gen_popcntb(DisasContext *ctx)
2439 {
2440     gen_helper_popcntb(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
2441 }
2442
2443 static void gen_popcntw(DisasContext *ctx)
2444 {
2445 #if defined(TARGET_PPC64)
2446     gen_helper_popcntw(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
2447 #else
2448     tcg_gen_ctpop_i32(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
2449 #endif
2450 }
2451
2452 #if defined(TARGET_PPC64)
2453 /* popcntd: PowerPC 2.06 specification */
2454 static void gen_popcntd(DisasContext *ctx)
2455 {
2456     tcg_gen_ctpop_i64(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
2457 }
2458 #endif
2459
2460 /* prtyw: PowerPC 2.05 specification */
2461 static void gen_prtyw(DisasContext *ctx)
2462 {
2463     TCGv ra = cpu_gpr[rA(ctx->opcode)];
2464     TCGv rs = cpu_gpr[rS(ctx->opcode)];
2465     TCGv t0 = tcg_temp_new();
2466     tcg_gen_shri_tl(t0, rs, 16);
2467     tcg_gen_xor_tl(ra, rs, t0);
2468     tcg_gen_shri_tl(t0, ra, 8);
2469     tcg_gen_xor_tl(ra, ra, t0);
2470     tcg_gen_andi_tl(ra, ra, (target_ulong)0x100000001ULL);
2471 }
2472
2473 #if defined(TARGET_PPC64)
2474 /* prtyd: PowerPC 2.05 specification */
2475 static void gen_prtyd(DisasContext *ctx)
2476 {
2477     TCGv ra = cpu_gpr[rA(ctx->opcode)];
2478     TCGv rs = cpu_gpr[rS(ctx->opcode)];
2479     TCGv t0 = tcg_temp_new();
2480     tcg_gen_shri_tl(t0, rs, 32);
2481     tcg_gen_xor_tl(ra, rs, t0);
2482     tcg_gen_shri_tl(t0, ra, 16);
2483     tcg_gen_xor_tl(ra, ra, t0);
2484     tcg_gen_shri_tl(t0, ra, 8);
2485     tcg_gen_xor_tl(ra, ra, t0);
2486     tcg_gen_andi_tl(ra, ra, 1);
2487 }
2488 #endif
2489
2490 #if defined(TARGET_PPC64)
2491 /* bpermd */
2492 static void gen_bpermd(DisasContext *ctx)
2493 {
2494     gen_helper_bpermd(cpu_gpr[rA(ctx->opcode)],
2495                       cpu_gpr[rS(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
2496 }
2497 #endif
2498
2499 #if defined(TARGET_PPC64)
2500 /* extsw & extsw. */
2501 GEN_LOGICAL1(extsw, tcg_gen_ext32s_tl, 0x1E, PPC_64B);
2502
2503 /* cntlzd */
2504 static void gen_cntlzd(DisasContext *ctx)
2505 {
2506     tcg_gen_clzi_i64(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], 64);
2507     if (unlikely(Rc(ctx->opcode) != 0)) {
2508         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2509     }
2510 }
2511
2512 /* cnttzd */
2513 static void gen_cnttzd(DisasContext *ctx)
2514 {
2515     tcg_gen_ctzi_i64(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)], 64);
2516     if (unlikely(Rc(ctx->opcode) != 0)) {
2517         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2518     }
2519 }
2520
2521 /* darn */
2522 static void gen_darn(DisasContext *ctx)
2523 {
2524     int l = L(ctx->opcode);
2525
2526     if (l > 2) {
2527         tcg_gen_movi_i64(cpu_gpr[rD(ctx->opcode)], -1);
2528     } else {
2529         translator_io_start(&ctx->base);
2530         if (l == 0) {
2531             gen_helper_darn32(cpu_gpr[rD(ctx->opcode)]);
2532         } else {
2533             /* Return 64-bit random for both CRN and RRN */
2534             gen_helper_darn64(cpu_gpr[rD(ctx->opcode)]);
2535         }
2536     }
2537 }
2538 #endif
2539
2540 /***                             Integer rotate                            ***/
2541
2542 /* rlwimi & rlwimi. */
2543 static void gen_rlwimi(DisasContext *ctx)
2544 {
2545     TCGv t_ra = cpu_gpr[rA(ctx->opcode)];
2546     TCGv t_rs = cpu_gpr[rS(ctx->opcode)];
2547     uint32_t sh = SH(ctx->opcode);
2548     uint32_t mb = MB(ctx->opcode);
2549     uint32_t me = ME(ctx->opcode);
2550
2551     if (sh == (31 - me) && mb <= me) {
2552         tcg_gen_deposit_tl(t_ra, t_ra, t_rs, sh, me - mb + 1);
2553     } else {
2554         target_ulong mask;
2555         bool mask_in_32b = true;
2556         TCGv t1;
2557
2558 #if defined(TARGET_PPC64)
2559         mb += 32;
2560         me += 32;
2561 #endif
2562         mask = MASK(mb, me);
2563
2564 #if defined(TARGET_PPC64)
2565         if (mask > 0xffffffffu) {
2566             mask_in_32b = false;
2567         }
2568 #endif
2569         t1 = tcg_temp_new();
2570         if (mask_in_32b) {
2571             TCGv_i32 t0 = tcg_temp_new_i32();
2572             tcg_gen_trunc_tl_i32(t0, t_rs);
2573             tcg_gen_rotli_i32(t0, t0, sh);
2574             tcg_gen_extu_i32_tl(t1, t0);
2575         } else {
2576 #if defined(TARGET_PPC64)
2577             tcg_gen_deposit_i64(t1, t_rs, t_rs, 32, 32);
2578             tcg_gen_rotli_i64(t1, t1, sh);
2579 #else
2580             g_assert_not_reached();
2581 #endif
2582         }
2583
2584         tcg_gen_andi_tl(t1, t1, mask);
2585         tcg_gen_andi_tl(t_ra, t_ra, ~mask);
2586         tcg_gen_or_tl(t_ra, t_ra, t1);
2587     }
2588     if (unlikely(Rc(ctx->opcode) != 0)) {
2589         gen_set_Rc0(ctx, t_ra);
2590     }
2591 }
2592
2593 /* rlwinm & rlwinm. */
2594 static void gen_rlwinm(DisasContext *ctx)
2595 {
2596     TCGv t_ra = cpu_gpr[rA(ctx->opcode)];
2597     TCGv t_rs = cpu_gpr[rS(ctx->opcode)];
2598     int sh = SH(ctx->opcode);
2599     int mb = MB(ctx->opcode);
2600     int me = ME(ctx->opcode);
2601     int len = me - mb + 1;
2602     int rsh = (32 - sh) & 31;
2603
2604     if (sh != 0 && len > 0 && me == (31 - sh)) {
2605         tcg_gen_deposit_z_tl(t_ra, t_rs, sh, len);
2606     } else if (me == 31 && rsh + len <= 32) {
2607         tcg_gen_extract_tl(t_ra, t_rs, rsh, len);
2608     } else {
2609         target_ulong mask;
2610         bool mask_in_32b = true;
2611 #if defined(TARGET_PPC64)
2612         mb += 32;
2613         me += 32;
2614 #endif
2615         mask = MASK(mb, me);
2616 #if defined(TARGET_PPC64)
2617         if (mask > 0xffffffffu) {
2618             mask_in_32b = false;
2619         }
2620 #endif
2621         if (mask_in_32b) {
2622             if (sh == 0) {
2623                 tcg_gen_andi_tl(t_ra, t_rs, mask);
2624             } else {
2625                 TCGv_i32 t0 = tcg_temp_new_i32();
2626                 tcg_gen_trunc_tl_i32(t0, t_rs);
2627                 tcg_gen_rotli_i32(t0, t0, sh);
2628                 tcg_gen_andi_i32(t0, t0, mask);
2629                 tcg_gen_extu_i32_tl(t_ra, t0);
2630             }
2631         } else {
2632 #if defined(TARGET_PPC64)
2633             tcg_gen_deposit_i64(t_ra, t_rs, t_rs, 32, 32);
2634             tcg_gen_rotli_i64(t_ra, t_ra, sh);
2635             tcg_gen_andi_i64(t_ra, t_ra, mask);
2636 #else
2637             g_assert_not_reached();
2638 #endif
2639         }
2640     }
2641     if (unlikely(Rc(ctx->opcode) != 0)) {
2642         gen_set_Rc0(ctx, t_ra);
2643     }
2644 }
2645
2646 /* rlwnm & rlwnm. */
2647 static void gen_rlwnm(DisasContext *ctx)
2648 {
2649     TCGv t_ra = cpu_gpr[rA(ctx->opcode)];
2650     TCGv t_rs = cpu_gpr[rS(ctx->opcode)];
2651     TCGv t_rb = cpu_gpr[rB(ctx->opcode)];
2652     uint32_t mb = MB(ctx->opcode);
2653     uint32_t me = ME(ctx->opcode);
2654     target_ulong mask;
2655     bool mask_in_32b = true;
2656
2657 #if defined(TARGET_PPC64)
2658     mb += 32;
2659     me += 32;
2660 #endif
2661     mask = MASK(mb, me);
2662
2663 #if defined(TARGET_PPC64)
2664     if (mask > 0xffffffffu) {
2665         mask_in_32b = false;
2666     }
2667 #endif
2668     if (mask_in_32b) {
2669         TCGv_i32 t0 = tcg_temp_new_i32();
2670         TCGv_i32 t1 = tcg_temp_new_i32();
2671         tcg_gen_trunc_tl_i32(t0, t_rb);
2672         tcg_gen_trunc_tl_i32(t1, t_rs);
2673         tcg_gen_andi_i32(t0, t0, 0x1f);
2674         tcg_gen_rotl_i32(t1, t1, t0);
2675         tcg_gen_extu_i32_tl(t_ra, t1);
2676     } else {
2677 #if defined(TARGET_PPC64)
2678         TCGv_i64 t0 = tcg_temp_new_i64();
2679         tcg_gen_andi_i64(t0, t_rb, 0x1f);
2680         tcg_gen_deposit_i64(t_ra, t_rs, t_rs, 32, 32);
2681         tcg_gen_rotl_i64(t_ra, t_ra, t0);
2682 #else
2683         g_assert_not_reached();
2684 #endif
2685     }
2686
2687     tcg_gen_andi_tl(t_ra, t_ra, mask);
2688
2689     if (unlikely(Rc(ctx->opcode) != 0)) {
2690         gen_set_Rc0(ctx, t_ra);
2691     }
2692 }
2693
2694 #if defined(TARGET_PPC64)
2695 #define GEN_PPC64_R2(name, opc1, opc2)                                        \
2696 static void glue(gen_, name##0)(DisasContext *ctx)                            \
2697 {                                                                             \
2698     gen_##name(ctx, 0);                                                       \
2699 }                                                                             \
2700                                                                               \
2701 static void glue(gen_, name##1)(DisasContext *ctx)                            \
2702 {                                                                             \
2703     gen_##name(ctx, 1);                                                       \
2704 }
2705 #define GEN_PPC64_R4(name, opc1, opc2)                                        \
2706 static void glue(gen_, name##0)(DisasContext *ctx)                            \
2707 {                                                                             \
2708     gen_##name(ctx, 0, 0);                                                    \
2709 }                                                                             \
2710                                                                               \
2711 static void glue(gen_, name##1)(DisasContext *ctx)                            \
2712 {                                                                             \
2713     gen_##name(ctx, 0, 1);                                                    \
2714 }                                                                             \
2715                                                                               \
2716 static void glue(gen_, name##2)(DisasContext *ctx)                            \
2717 {                                                                             \
2718     gen_##name(ctx, 1, 0);                                                    \
2719 }                                                                             \
2720                                                                               \
2721 static void glue(gen_, name##3)(DisasContext *ctx)                            \
2722 {                                                                             \
2723     gen_##name(ctx, 1, 1);                                                    \
2724 }
2725
2726 static void gen_rldinm(DisasContext *ctx, int mb, int me, int sh)
2727 {
2728     TCGv t_ra = cpu_gpr[rA(ctx->opcode)];
2729     TCGv t_rs = cpu_gpr[rS(ctx->opcode)];
2730     int len = me - mb + 1;
2731     int rsh = (64 - sh) & 63;
2732
2733     if (sh != 0 && len > 0 && me == (63 - sh)) {
2734         tcg_gen_deposit_z_tl(t_ra, t_rs, sh, len);
2735     } else if (me == 63 && rsh + len <= 64) {
2736         tcg_gen_extract_tl(t_ra, t_rs, rsh, len);
2737     } else {
2738         tcg_gen_rotli_tl(t_ra, t_rs, sh);
2739         tcg_gen_andi_tl(t_ra, t_ra, MASK(mb, me));
2740     }
2741     if (unlikely(Rc(ctx->opcode) != 0)) {
2742         gen_set_Rc0(ctx, t_ra);
2743     }
2744 }
2745
2746 /* rldicl - rldicl. */
2747 static inline void gen_rldicl(DisasContext *ctx, int mbn, int shn)
2748 {
2749     uint32_t sh, mb;
2750
2751     sh = SH(ctx->opcode) | (shn << 5);
2752     mb = MB(ctx->opcode) | (mbn << 5);
2753     gen_rldinm(ctx, mb, 63, sh);
2754 }
2755 GEN_PPC64_R4(rldicl, 0x1E, 0x00);
2756
2757 /* rldicr - rldicr. */
2758 static inline void gen_rldicr(DisasContext *ctx, int men, int shn)
2759 {
2760     uint32_t sh, me;
2761
2762     sh = SH(ctx->opcode) | (shn << 5);
2763     me = MB(ctx->opcode) | (men << 5);
2764     gen_rldinm(ctx, 0, me, sh);
2765 }
2766 GEN_PPC64_R4(rldicr, 0x1E, 0x02);
2767
2768 /* rldic - rldic. */
2769 static inline void gen_rldic(DisasContext *ctx, int mbn, int shn)
2770 {
2771     uint32_t sh, mb;
2772
2773     sh = SH(ctx->opcode) | (shn << 5);
2774     mb = MB(ctx->opcode) | (mbn << 5);
2775     gen_rldinm(ctx, mb, 63 - sh, sh);
2776 }
2777 GEN_PPC64_R4(rldic, 0x1E, 0x04);
2778
2779 static void gen_rldnm(DisasContext *ctx, int mb, int me)
2780 {
2781     TCGv t_ra = cpu_gpr[rA(ctx->opcode)];
2782     TCGv t_rs = cpu_gpr[rS(ctx->opcode)];
2783     TCGv t_rb = cpu_gpr[rB(ctx->opcode)];
2784     TCGv t0;
2785
2786     t0 = tcg_temp_new();
2787     tcg_gen_andi_tl(t0, t_rb, 0x3f);
2788     tcg_gen_rotl_tl(t_ra, t_rs, t0);
2789
2790     tcg_gen_andi_tl(t_ra, t_ra, MASK(mb, me));
2791     if (unlikely(Rc(ctx->opcode) != 0)) {
2792         gen_set_Rc0(ctx, t_ra);
2793     }
2794 }
2795
2796 /* rldcl - rldcl. */
2797 static inline void gen_rldcl(DisasContext *ctx, int mbn)
2798 {
2799     uint32_t mb;
2800
2801     mb = MB(ctx->opcode) | (mbn << 5);
2802     gen_rldnm(ctx, mb, 63);
2803 }
2804 GEN_PPC64_R2(rldcl, 0x1E, 0x08);
2805
2806 /* rldcr - rldcr. */
2807 static inline void gen_rldcr(DisasContext *ctx, int men)
2808 {
2809     uint32_t me;
2810
2811     me = MB(ctx->opcode) | (men << 5);
2812     gen_rldnm(ctx, 0, me);
2813 }
2814 GEN_PPC64_R2(rldcr, 0x1E, 0x09);
2815
2816 /* rldimi - rldimi. */
2817 static void gen_rldimi(DisasContext *ctx, int mbn, int shn)
2818 {
2819     TCGv t_ra = cpu_gpr[rA(ctx->opcode)];
2820     TCGv t_rs = cpu_gpr[rS(ctx->opcode)];
2821     uint32_t sh = SH(ctx->opcode) | (shn << 5);
2822     uint32_t mb = MB(ctx->opcode) | (mbn << 5);
2823     uint32_t me = 63 - sh;
2824
2825     if (mb <= me) {
2826         tcg_gen_deposit_tl(t_ra, t_ra, t_rs, sh, me - mb + 1);
2827     } else {
2828         target_ulong mask = MASK(mb, me);
2829         TCGv t1 = tcg_temp_new();
2830
2831         tcg_gen_rotli_tl(t1, t_rs, sh);
2832         tcg_gen_andi_tl(t1, t1, mask);
2833         tcg_gen_andi_tl(t_ra, t_ra, ~mask);
2834         tcg_gen_or_tl(t_ra, t_ra, t1);
2835     }
2836     if (unlikely(Rc(ctx->opcode) != 0)) {
2837         gen_set_Rc0(ctx, t_ra);
2838     }
2839 }
2840 GEN_PPC64_R4(rldimi, 0x1E, 0x06);
2841 #endif
2842
2843 /***                             Integer shift                             ***/
2844
2845 /* slw & slw. */
2846 static void gen_slw(DisasContext *ctx)
2847 {
2848     TCGv t0, t1;
2849
2850     t0 = tcg_temp_new();
2851     /* AND rS with a mask that is 0 when rB >= 0x20 */
2852 #if defined(TARGET_PPC64)
2853     tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x3a);
2854     tcg_gen_sari_tl(t0, t0, 0x3f);
2855 #else
2856     tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1a);
2857     tcg_gen_sari_tl(t0, t0, 0x1f);
2858 #endif
2859     tcg_gen_andc_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
2860     t1 = tcg_temp_new();
2861     tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x1f);
2862     tcg_gen_shl_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
2863     tcg_gen_ext32u_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
2864     if (unlikely(Rc(ctx->opcode) != 0)) {
2865         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2866     }
2867 }
2868
2869 /* sraw & sraw. */
2870 static void gen_sraw(DisasContext *ctx)
2871 {
2872     gen_helper_sraw(cpu_gpr[rA(ctx->opcode)], cpu_env,
2873                     cpu_gpr[rS(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
2874     if (unlikely(Rc(ctx->opcode) != 0)) {
2875         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2876     }
2877 }
2878
2879 /* srawi & srawi. */
2880 static void gen_srawi(DisasContext *ctx)
2881 {
2882     int sh = SH(ctx->opcode);
2883     TCGv dst = cpu_gpr[rA(ctx->opcode)];
2884     TCGv src = cpu_gpr[rS(ctx->opcode)];
2885     if (sh == 0) {
2886         tcg_gen_ext32s_tl(dst, src);
2887         tcg_gen_movi_tl(cpu_ca, 0);
2888         if (is_isa300(ctx)) {
2889             tcg_gen_movi_tl(cpu_ca32, 0);
2890         }
2891     } else {
2892         TCGv t0;
2893         tcg_gen_ext32s_tl(dst, src);
2894         tcg_gen_andi_tl(cpu_ca, dst, (1ULL << sh) - 1);
2895         t0 = tcg_temp_new();
2896         tcg_gen_sari_tl(t0, dst, TARGET_LONG_BITS - 1);
2897         tcg_gen_and_tl(cpu_ca, cpu_ca, t0);
2898         tcg_gen_setcondi_tl(TCG_COND_NE, cpu_ca, cpu_ca, 0);
2899         if (is_isa300(ctx)) {
2900             tcg_gen_mov_tl(cpu_ca32, cpu_ca);
2901         }
2902         tcg_gen_sari_tl(dst, dst, sh);
2903     }
2904     if (unlikely(Rc(ctx->opcode) != 0)) {
2905         gen_set_Rc0(ctx, dst);
2906     }
2907 }
2908
2909 /* srw & srw. */
2910 static void gen_srw(DisasContext *ctx)
2911 {
2912     TCGv t0, t1;
2913
2914     t0 = tcg_temp_new();
2915     /* AND rS with a mask that is 0 when rB >= 0x20 */
2916 #if defined(TARGET_PPC64)
2917     tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x3a);
2918     tcg_gen_sari_tl(t0, t0, 0x3f);
2919 #else
2920     tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1a);
2921     tcg_gen_sari_tl(t0, t0, 0x1f);
2922 #endif
2923     tcg_gen_andc_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
2924     tcg_gen_ext32u_tl(t0, t0);
2925     t1 = tcg_temp_new();
2926     tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x1f);
2927     tcg_gen_shr_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
2928     if (unlikely(Rc(ctx->opcode) != 0)) {
2929         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2930     }
2931 }
2932
2933 #if defined(TARGET_PPC64)
2934 /* sld & sld. */
2935 static void gen_sld(DisasContext *ctx)
2936 {
2937     TCGv t0, t1;
2938
2939     t0 = tcg_temp_new();
2940     /* AND rS with a mask that is 0 when rB >= 0x40 */
2941     tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x39);
2942     tcg_gen_sari_tl(t0, t0, 0x3f);
2943     tcg_gen_andc_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
2944     t1 = tcg_temp_new();
2945     tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x3f);
2946     tcg_gen_shl_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
2947     if (unlikely(Rc(ctx->opcode) != 0)) {
2948         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2949     }
2950 }
2951
2952 /* srad & srad. */
2953 static void gen_srad(DisasContext *ctx)
2954 {
2955     gen_helper_srad(cpu_gpr[rA(ctx->opcode)], cpu_env,
2956                     cpu_gpr[rS(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
2957     if (unlikely(Rc(ctx->opcode) != 0)) {
2958         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
2959     }
2960 }
2961 /* sradi & sradi. */
2962 static inline void gen_sradi(DisasContext *ctx, int n)
2963 {
2964     int sh = SH(ctx->opcode) + (n << 5);
2965     TCGv dst = cpu_gpr[rA(ctx->opcode)];
2966     TCGv src = cpu_gpr[rS(ctx->opcode)];
2967     if (sh == 0) {
2968         tcg_gen_mov_tl(dst, src);
2969         tcg_gen_movi_tl(cpu_ca, 0);
2970         if (is_isa300(ctx)) {
2971             tcg_gen_movi_tl(cpu_ca32, 0);
2972         }
2973     } else {
2974         TCGv t0;
2975         tcg_gen_andi_tl(cpu_ca, src, (1ULL << sh) - 1);
2976         t0 = tcg_temp_new();
2977         tcg_gen_sari_tl(t0, src, TARGET_LONG_BITS - 1);
2978         tcg_gen_and_tl(cpu_ca, cpu_ca, t0);
2979         tcg_gen_setcondi_tl(TCG_COND_NE, cpu_ca, cpu_ca, 0);
2980         if (is_isa300(ctx)) {
2981             tcg_gen_mov_tl(cpu_ca32, cpu_ca);
2982         }
2983         tcg_gen_sari_tl(dst, src, sh);
2984     }
2985     if (unlikely(Rc(ctx->opcode) != 0)) {
2986         gen_set_Rc0(ctx, dst);
2987     }
2988 }
2989
2990 static void gen_sradi0(DisasContext *ctx)
2991 {
2992     gen_sradi(ctx, 0);
2993 }
2994
2995 static void gen_sradi1(DisasContext *ctx)
2996 {
2997     gen_sradi(ctx, 1);
2998 }
2999
3000 /* extswsli & extswsli. */
3001 static inline void gen_extswsli(DisasContext *ctx, int n)
3002 {
3003     int sh = SH(ctx->opcode) + (n << 5);
3004     TCGv dst = cpu_gpr[rA(ctx->opcode)];
3005     TCGv src = cpu_gpr[rS(ctx->opcode)];
3006
3007     tcg_gen_ext32s_tl(dst, src);
3008     tcg_gen_shli_tl(dst, dst, sh);
3009     if (unlikely(Rc(ctx->opcode) != 0)) {
3010         gen_set_Rc0(ctx, dst);
3011     }
3012 }
3013
3014 static void gen_extswsli0(DisasContext *ctx)
3015 {
3016     gen_extswsli(ctx, 0);
3017 }
3018
3019 static void gen_extswsli1(DisasContext *ctx)
3020 {
3021     gen_extswsli(ctx, 1);
3022 }
3023
3024 /* srd & srd. */
3025 static void gen_srd(DisasContext *ctx)
3026 {
3027     TCGv t0, t1;
3028
3029     t0 = tcg_temp_new();
3030     /* AND rS with a mask that is 0 when rB >= 0x40 */
3031     tcg_gen_shli_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x39);
3032     tcg_gen_sari_tl(t0, t0, 0x3f);
3033     tcg_gen_andc_tl(t0, cpu_gpr[rS(ctx->opcode)], t0);
3034     t1 = tcg_temp_new();
3035     tcg_gen_andi_tl(t1, cpu_gpr[rB(ctx->opcode)], 0x3f);
3036     tcg_gen_shr_tl(cpu_gpr[rA(ctx->opcode)], t0, t1);
3037     if (unlikely(Rc(ctx->opcode) != 0)) {
3038         gen_set_Rc0(ctx, cpu_gpr[rA(ctx->opcode)]);
3039     }
3040 }
3041 #endif
3042
3043 /***                           Addressing modes                            ***/
3044 /* Register indirect with immediate index : EA = (rA|0) + SIMM */
3045 static inline void gen_addr_imm_index(DisasContext *ctx, TCGv EA,
3046                                       target_long maskl)
3047 {
3048     target_long simm = SIMM(ctx->opcode);
3049
3050     simm &= ~maskl;
3051     if (rA(ctx->opcode) == 0) {
3052         if (NARROW_MODE(ctx)) {
3053             simm = (uint32_t)simm;
3054         }
3055         tcg_gen_movi_tl(EA, simm);
3056     } else if (likely(simm != 0)) {
3057         tcg_gen_addi_tl(EA, cpu_gpr[rA(ctx->opcode)], simm);
3058         if (NARROW_MODE(ctx)) {
3059             tcg_gen_ext32u_tl(EA, EA);
3060         }
3061     } else {
3062         if (NARROW_MODE(ctx)) {
3063             tcg_gen_ext32u_tl(EA, cpu_gpr[rA(ctx->opcode)]);
3064         } else {
3065             tcg_gen_mov_tl(EA, cpu_gpr[rA(ctx->opcode)]);
3066         }
3067     }
3068 }
3069
3070 static inline void gen_addr_reg_index(DisasContext *ctx, TCGv EA)
3071 {
3072     if (rA(ctx->opcode) == 0) {
3073         if (NARROW_MODE(ctx)) {
3074             tcg_gen_ext32u_tl(EA, cpu_gpr[rB(ctx->opcode)]);
3075         } else {
3076             tcg_gen_mov_tl(EA, cpu_gpr[rB(ctx->opcode)]);
3077         }
3078     } else {
3079         tcg_gen_add_tl(EA, cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
3080         if (NARROW_MODE(ctx)) {
3081             tcg_gen_ext32u_tl(EA, EA);
3082         }
3083     }
3084 }
3085
3086 static inline void gen_addr_register(DisasContext *ctx, TCGv EA)
3087 {
3088     if (rA(ctx->opcode) == 0) {
3089         tcg_gen_movi_tl(EA, 0);
3090     } else if (NARROW_MODE(ctx)) {
3091         tcg_gen_ext32u_tl(EA, cpu_gpr[rA(ctx->opcode)]);
3092     } else {
3093         tcg_gen_mov_tl(EA, cpu_gpr[rA(ctx->opcode)]);
3094     }
3095 }
3096
3097 static inline void gen_addr_add(DisasContext *ctx, TCGv ret, TCGv arg1,
3098                                 target_long val)
3099 {
3100     tcg_gen_addi_tl(ret, arg1, val);
3101     if (NARROW_MODE(ctx)) {
3102         tcg_gen_ext32u_tl(ret, ret);
3103     }
3104 }
3105
3106 static inline void gen_align_no_le(DisasContext *ctx)
3107 {
3108     gen_exception_err(ctx, POWERPC_EXCP_ALIGN,
3109                       (ctx->opcode & 0x03FF0000) | POWERPC_EXCP_ALIGN_LE);
3110 }
3111
3112 static TCGv do_ea_calc(DisasContext *ctx, int ra, TCGv displ)
3113 {
3114     TCGv ea = tcg_temp_new();
3115     if (ra) {
3116         tcg_gen_add_tl(ea, cpu_gpr[ra], displ);
3117     } else {
3118         tcg_gen_mov_tl(ea, displ);
3119     }
3120     if (NARROW_MODE(ctx)) {
3121         tcg_gen_ext32u_tl(ea, ea);
3122     }
3123     return ea;
3124 }
3125
3126 /***                             Integer load                              ***/
3127 #define DEF_MEMOP(op) ((op) | ctx->default_tcg_memop_mask)
3128 #define BSWAP_MEMOP(op) ((op) | (ctx->default_tcg_memop_mask ^ MO_BSWAP))
3129
3130 #define GEN_QEMU_LOAD_TL(ldop, op)                                      \
3131 static void glue(gen_qemu_, ldop)(DisasContext *ctx,                    \
3132                                   TCGv val,                             \
3133                                   TCGv addr)                            \
3134 {                                                                       \
3135     tcg_gen_qemu_ld_tl(val, addr, ctx->mem_idx, op);                    \
3136 }
3137
3138 GEN_QEMU_LOAD_TL(ld8u,  DEF_MEMOP(MO_UB))
3139 GEN_QEMU_LOAD_TL(ld16u, DEF_MEMOP(MO_UW))
3140 GEN_QEMU_LOAD_TL(ld16s, DEF_MEMOP(MO_SW))
3141 GEN_QEMU_LOAD_TL(ld32u, DEF_MEMOP(MO_UL))
3142 GEN_QEMU_LOAD_TL(ld32s, DEF_MEMOP(MO_SL))
3143
3144 GEN_QEMU_LOAD_TL(ld16ur, BSWAP_MEMOP(MO_UW))
3145 GEN_QEMU_LOAD_TL(ld32ur, BSWAP_MEMOP(MO_UL))
3146
3147 #define GEN_QEMU_LOAD_64(ldop, op)                                  \
3148 static void glue(gen_qemu_, glue(ldop, _i64))(DisasContext *ctx,    \
3149                                              TCGv_i64 val,          \
3150                                              TCGv addr)             \
3151 {                                                                   \
3152     tcg_gen_qemu_ld_i64(val, addr, ctx->mem_idx, op);               \
3153 }
3154
3155 GEN_QEMU_LOAD_64(ld8u,  DEF_MEMOP(MO_UB))
3156 GEN_QEMU_LOAD_64(ld16u, DEF_MEMOP(MO_UW))
3157 GEN_QEMU_LOAD_64(ld32u, DEF_MEMOP(MO_UL))
3158 GEN_QEMU_LOAD_64(ld32s, DEF_MEMOP(MO_SL))
3159 GEN_QEMU_LOAD_64(ld64,  DEF_MEMOP(MO_UQ))
3160
3161 #if defined(TARGET_PPC64)
3162 GEN_QEMU_LOAD_64(ld64ur, BSWAP_MEMOP(MO_UQ))
3163 #endif
3164
3165 #define GEN_QEMU_STORE_TL(stop, op)                                     \
3166 static void glue(gen_qemu_, stop)(DisasContext *ctx,                    \
3167                                   TCGv val,                             \
3168                                   TCGv addr)                            \
3169 {                                                                       \
3170     tcg_gen_qemu_st_tl(val, addr, ctx->mem_idx, op);                    \
3171 }
3172
3173 #if defined(TARGET_PPC64) || !defined(CONFIG_USER_ONLY)
3174 GEN_QEMU_STORE_TL(st8,  DEF_MEMOP(MO_UB))
3175 #endif
3176 GEN_QEMU_STORE_TL(st16, DEF_MEMOP(MO_UW))
3177 GEN_QEMU_STORE_TL(st32, DEF_MEMOP(MO_UL))
3178
3179 GEN_QEMU_STORE_TL(st16r, BSWAP_MEMOP(MO_UW))
3180 GEN_QEMU_STORE_TL(st32r, BSWAP_MEMOP(MO_UL))
3181
3182 #define GEN_QEMU_STORE_64(stop, op)                               \
3183 static void glue(gen_qemu_, glue(stop, _i64))(DisasContext *ctx,  \
3184                                               TCGv_i64 val,       \
3185                                               TCGv addr)          \
3186 {                                                                 \
3187     tcg_gen_qemu_st_i64(val, addr, ctx->mem_idx, op);             \
3188 }
3189
3190 GEN_QEMU_STORE_64(st8,  DEF_MEMOP(MO_UB))
3191 GEN_QEMU_STORE_64(st16, DEF_MEMOP(MO_UW))
3192 GEN_QEMU_STORE_64(st32, DEF_MEMOP(MO_UL))
3193 GEN_QEMU_STORE_64(st64, DEF_MEMOP(MO_UQ))
3194
3195 #if defined(TARGET_PPC64)
3196 GEN_QEMU_STORE_64(st64r, BSWAP_MEMOP(MO_UQ))
3197 #endif
3198
3199 #define GEN_LDX_E(name, ldop, opc2, opc3, type, type2, chk)                   \
3200 static void glue(gen_, name##x)(DisasContext *ctx)                            \
3201 {                                                                             \
3202     TCGv EA;                                                                  \
3203     chk(ctx);                                                                 \
3204     gen_set_access_type(ctx, ACCESS_INT);                                     \
3205     EA = tcg_temp_new();                                                      \
3206     gen_addr_reg_index(ctx, EA);                                              \
3207     gen_qemu_##ldop(ctx, cpu_gpr[rD(ctx->opcode)], EA);                       \
3208 }
3209
3210 #define GEN_LDX(name, ldop, opc2, opc3, type)                                 \
3211     GEN_LDX_E(name, ldop, opc2, opc3, type, PPC_NONE, CHK_NONE)
3212
3213 #define GEN_LDX_HVRM(name, ldop, opc2, opc3, type)                            \
3214     GEN_LDX_E(name, ldop, opc2, opc3, type, PPC_NONE, CHK_HVRM)
3215
3216 #define GEN_LDEPX(name, ldop, opc2, opc3)                                     \
3217 static void glue(gen_, name##epx)(DisasContext *ctx)                          \
3218 {                                                                             \
3219     TCGv EA;                                                                  \
3220     CHK_SV(ctx);                                                              \
3221     gen_set_access_type(ctx, ACCESS_INT);                                     \
3222     EA = tcg_temp_new();                                                      \
3223     gen_addr_reg_index(ctx, EA);                                              \
3224     tcg_gen_qemu_ld_tl(cpu_gpr[rD(ctx->opcode)], EA, PPC_TLB_EPID_LOAD, ldop);\
3225 }
3226
3227 GEN_LDEPX(lb, DEF_MEMOP(MO_UB), 0x1F, 0x02)
3228 GEN_LDEPX(lh, DEF_MEMOP(MO_UW), 0x1F, 0x08)
3229 GEN_LDEPX(lw, DEF_MEMOP(MO_UL), 0x1F, 0x00)
3230 #if defined(TARGET_PPC64)
3231 GEN_LDEPX(ld, DEF_MEMOP(MO_UQ), 0x1D, 0x00)
3232 #endif
3233
3234 #if defined(TARGET_PPC64)
3235 /* CI load/store variants */
3236 GEN_LDX_HVRM(ldcix, ld64_i64, 0x15, 0x1b, PPC_CILDST)
3237 GEN_LDX_HVRM(lwzcix, ld32u, 0x15, 0x15, PPC_CILDST)
3238 GEN_LDX_HVRM(lhzcix, ld16u, 0x15, 0x19, PPC_CILDST)
3239 GEN_LDX_HVRM(lbzcix, ld8u, 0x15, 0x1a, PPC_CILDST)
3240 #endif
3241
3242 /***                              Integer store                            ***/
3243 #define GEN_STX_E(name, stop, opc2, opc3, type, type2, chk)                   \
3244 static void glue(gen_, name##x)(DisasContext *ctx)                            \
3245 {                                                                             \
3246     TCGv EA;                                                                  \
3247     chk(ctx);                                                                 \
3248     gen_set_access_type(ctx, ACCESS_INT);                                     \
3249     EA = tcg_temp_new();                                                      \
3250     gen_addr_reg_index(ctx, EA);                                              \
3251     gen_qemu_##stop(ctx, cpu_gpr[rS(ctx->opcode)], EA);                       \
3252 }
3253 #define GEN_STX(name, stop, opc2, opc3, type)                                 \
3254     GEN_STX_E(name, stop, opc2, opc3, type, PPC_NONE, CHK_NONE)
3255
3256 #define GEN_STX_HVRM(name, stop, opc2, opc3, type)                            \
3257     GEN_STX_E(name, stop, opc2, opc3, type, PPC_NONE, CHK_HVRM)
3258
3259 #define GEN_STEPX(name, stop, opc2, opc3)                                     \
3260 static void glue(gen_, name##epx)(DisasContext *ctx)                          \
3261 {                                                                             \
3262     TCGv EA;                                                                  \
3263     CHK_SV(ctx);                                                              \
3264     gen_set_access_type(ctx, ACCESS_INT);                                     \
3265     EA = tcg_temp_new();                                                      \
3266     gen_addr_reg_index(ctx, EA);                                              \
3267     tcg_gen_qemu_st_tl(                                                       \
3268         cpu_gpr[rD(ctx->opcode)], EA, PPC_TLB_EPID_STORE, stop);              \
3269 }
3270
3271 GEN_STEPX(stb, DEF_MEMOP(MO_UB), 0x1F, 0x06)
3272 GEN_STEPX(sth, DEF_MEMOP(MO_UW), 0x1F, 0x0C)
3273 GEN_STEPX(stw, DEF_MEMOP(MO_UL), 0x1F, 0x04)
3274 #if defined(TARGET_PPC64)
3275 GEN_STEPX(std, DEF_MEMOP(MO_UQ), 0x1d, 0x04)
3276 #endif
3277
3278 #if defined(TARGET_PPC64)
3279 GEN_STX_HVRM(stdcix, st64_i64, 0x15, 0x1f, PPC_CILDST)
3280 GEN_STX_HVRM(stwcix, st32, 0x15, 0x1c, PPC_CILDST)
3281 GEN_STX_HVRM(sthcix, st16, 0x15, 0x1d, PPC_CILDST)
3282 GEN_STX_HVRM(stbcix, st8, 0x15, 0x1e, PPC_CILDST)
3283 #endif
3284 /***                Integer load and store with byte reverse               ***/
3285
3286 /* lhbrx */
3287 GEN_LDX(lhbr, ld16ur, 0x16, 0x18, PPC_INTEGER);
3288
3289 /* lwbrx */
3290 GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER);
3291
3292 #if defined(TARGET_PPC64)
3293 /* ldbrx */
3294 GEN_LDX_E(ldbr, ld64ur_i64, 0x14, 0x10, PPC_NONE, PPC2_DBRX, CHK_NONE);
3295 /* stdbrx */
3296 GEN_STX_E(stdbr, st64r_i64, 0x14, 0x14, PPC_NONE, PPC2_DBRX, CHK_NONE);
3297 #endif  /* TARGET_PPC64 */
3298
3299 /* sthbrx */
3300 GEN_STX(sthbr, st16r, 0x16, 0x1C, PPC_INTEGER);
3301 /* stwbrx */
3302 GEN_STX(stwbr, st32r, 0x16, 0x14, PPC_INTEGER);
3303
3304 /***                    Integer load and store multiple                    ***/
3305
3306 /* lmw */
3307 static void gen_lmw(DisasContext *ctx)
3308 {
3309     TCGv t0;
3310     TCGv_i32 t1;
3311
3312     if (ctx->le_mode) {
3313         gen_align_no_le(ctx);
3314         return;
3315     }
3316     gen_set_access_type(ctx, ACCESS_INT);
3317     t0 = tcg_temp_new();
3318     t1 = tcg_constant_i32(rD(ctx->opcode));
3319     gen_addr_imm_index(ctx, t0, 0);
3320     gen_helper_lmw(cpu_env, t0, t1);
3321 }
3322
3323 /* stmw */
3324 static void gen_stmw(DisasContext *ctx)
3325 {
3326     TCGv t0;
3327     TCGv_i32 t1;
3328
3329     if (ctx->le_mode) {
3330         gen_align_no_le(ctx);
3331         return;
3332     }
3333     gen_set_access_type(ctx, ACCESS_INT);
3334     t0 = tcg_temp_new();
3335     t1 = tcg_constant_i32(rS(ctx->opcode));
3336     gen_addr_imm_index(ctx, t0, 0);
3337     gen_helper_stmw(cpu_env, t0, t1);
3338 }
3339
3340 /***                    Integer load and store strings                     ***/
3341
3342 /* lswi */
3343 /*
3344  * PowerPC32 specification says we must generate an exception if rA is
3345  * in the range of registers to be loaded.  In an other hand, IBM says
3346  * this is valid, but rA won't be loaded.  For now, I'll follow the
3347  * spec...
3348  */
3349 static void gen_lswi(DisasContext *ctx)
3350 {
3351     TCGv t0;
3352     TCGv_i32 t1, t2;
3353     int nb = NB(ctx->opcode);
3354     int start = rD(ctx->opcode);
3355     int ra = rA(ctx->opcode);
3356     int nr;
3357
3358     if (ctx->le_mode) {
3359         gen_align_no_le(ctx);
3360         return;
3361     }
3362     if (nb == 0) {
3363         nb = 32;
3364     }
3365     nr = DIV_ROUND_UP(nb, 4);
3366     if (unlikely(lsw_reg_in_range(start, nr, ra))) {
3367         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_LSWX);
3368         return;
3369     }
3370     gen_set_access_type(ctx, ACCESS_INT);
3371     t0 = tcg_temp_new();
3372     gen_addr_register(ctx, t0);
3373     t1 = tcg_constant_i32(nb);
3374     t2 = tcg_constant_i32(start);
3375     gen_helper_lsw(cpu_env, t0, t1, t2);
3376 }
3377
3378 /* lswx */
3379 static void gen_lswx(DisasContext *ctx)
3380 {
3381     TCGv t0;
3382     TCGv_i32 t1, t2, t3;
3383
3384     if (ctx->le_mode) {
3385         gen_align_no_le(ctx);
3386         return;
3387     }
3388     gen_set_access_type(ctx, ACCESS_INT);
3389     t0 = tcg_temp_new();
3390     gen_addr_reg_index(ctx, t0);
3391     t1 = tcg_constant_i32(rD(ctx->opcode));
3392     t2 = tcg_constant_i32(rA(ctx->opcode));
3393     t3 = tcg_constant_i32(rB(ctx->opcode));
3394     gen_helper_lswx(cpu_env, t0, t1, t2, t3);
3395 }
3396
3397 /* stswi */
3398 static void gen_stswi(DisasContext *ctx)
3399 {
3400     TCGv t0;
3401     TCGv_i32 t1, t2;
3402     int nb = NB(ctx->opcode);
3403
3404     if (ctx->le_mode) {
3405         gen_align_no_le(ctx);
3406         return;
3407     }
3408     gen_set_access_type(ctx, ACCESS_INT);
3409     t0 = tcg_temp_new();
3410     gen_addr_register(ctx, t0);
3411     if (nb == 0) {
3412         nb = 32;
3413     }
3414     t1 = tcg_constant_i32(nb);
3415     t2 = tcg_constant_i32(rS(ctx->opcode));
3416     gen_helper_stsw(cpu_env, t0, t1, t2);
3417 }
3418
3419 /* stswx */
3420 static void gen_stswx(DisasContext *ctx)
3421 {
3422     TCGv t0;
3423     TCGv_i32 t1, t2;
3424
3425     if (ctx->le_mode) {
3426         gen_align_no_le(ctx);
3427         return;
3428     }
3429     gen_set_access_type(ctx, ACCESS_INT);
3430     t0 = tcg_temp_new();
3431     gen_addr_reg_index(ctx, t0);
3432     t1 = tcg_temp_new_i32();
3433     tcg_gen_trunc_tl_i32(t1, cpu_xer);
3434     tcg_gen_andi_i32(t1, t1, 0x7F);
3435     t2 = tcg_constant_i32(rS(ctx->opcode));
3436     gen_helper_stsw(cpu_env, t0, t1, t2);
3437 }
3438
3439 /***                        Memory synchronisation                         ***/
3440 /* eieio */
3441 static void gen_eieio(DisasContext *ctx)
3442 {
3443     TCGBar bar = TCG_MO_ALL;
3444
3445     /*
3446      * eieio has complex semanitcs. It provides memory ordering between
3447      * operations in the set:
3448      * - loads from CI memory.
3449      * - stores to CI memory.
3450      * - stores to WT memory.
3451      *
3452      * It separately also orders memory for operations in the set:
3453      * - stores to cacheble memory.
3454      *
3455      * It also serializes instructions:
3456      * - dcbt and dcbst.
3457      *
3458      * It separately serializes:
3459      * - tlbie and tlbsync.
3460      *
3461      * And separately serializes:
3462      * - slbieg, slbiag, and slbsync.
3463      *
3464      * The end result is that CI memory ordering requires TCG_MO_ALL
3465      * and it is not possible to special-case more relaxed ordering for
3466      * cacheable accesses. TCG_BAR_SC is required to provide this
3467      * serialization.
3468      */
3469
3470     /*
3471      * POWER9 has a eieio instruction variant using bit 6 as a hint to
3472      * tell the CPU it is a store-forwarding barrier.
3473      */
3474     if (ctx->opcode & 0x2000000) {
3475         /*
3476          * ISA says that "Reserved fields in instructions are ignored
3477          * by the processor". So ignore the bit 6 on non-POWER9 CPU but
3478          * as this is not an instruction software should be using,
3479          * complain to the user.
3480          */
3481         if (!(ctx->insns_flags2 & PPC2_ISA300)) {
3482             qemu_log_mask(LOG_GUEST_ERROR, "invalid eieio using bit 6 at @"
3483                           TARGET_FMT_lx "\n", ctx->cia);
3484         } else {
3485             bar = TCG_MO_ST_LD;
3486         }
3487     }
3488
3489     tcg_gen_mb(bar | TCG_BAR_SC);
3490 }
3491
3492 #if !defined(CONFIG_USER_ONLY)
3493 static inline void gen_check_tlb_flush(DisasContext *ctx, bool global)
3494 {
3495     TCGv_i32 t;
3496     TCGLabel *l;
3497
3498     if (!ctx->lazy_tlb_flush) {
3499         return;
3500     }
3501     l = gen_new_label();
3502     t = tcg_temp_new_i32();
3503     tcg_gen_ld_i32(t, cpu_env, offsetof(CPUPPCState, tlb_need_flush));
3504     tcg_gen_brcondi_i32(TCG_COND_EQ, t, 0, l);
3505     if (global) {
3506         gen_helper_check_tlb_flush_global(cpu_env);
3507     } else {
3508         gen_helper_check_tlb_flush_local(cpu_env);
3509     }
3510     gen_set_label(l);
3511 }
3512 #else
3513 static inline void gen_check_tlb_flush(DisasContext *ctx, bool global) { }
3514 #endif
3515
3516 /* isync */
3517 static void gen_isync(DisasContext *ctx)
3518 {
3519     /*
3520      * We need to check for a pending TLB flush. This can only happen in
3521      * kernel mode however so check MSR_PR
3522      */
3523     if (!ctx->pr) {
3524         gen_check_tlb_flush(ctx, false);
3525     }
3526     tcg_gen_mb(TCG_MO_ALL | TCG_BAR_SC);
3527     ctx->base.is_jmp = DISAS_EXIT_UPDATE;
3528 }
3529
3530 #define MEMOP_GET_SIZE(x)  (1 << ((x) & MO_SIZE))
3531
3532 static void gen_load_locked(DisasContext *ctx, MemOp memop)
3533 {
3534     TCGv gpr = cpu_gpr[rD(ctx->opcode)];
3535     TCGv t0 = tcg_temp_new();
3536
3537     gen_set_access_type(ctx, ACCESS_RES);
3538     gen_addr_reg_index(ctx, t0);
3539     tcg_gen_qemu_ld_tl(gpr, t0, ctx->mem_idx, memop | MO_ALIGN);
3540     tcg_gen_mov_tl(cpu_reserve, t0);
3541     tcg_gen_movi_tl(cpu_reserve_length, memop_size(memop));
3542     tcg_gen_mov_tl(cpu_reserve_val, gpr);
3543 }
3544
3545 #define LARX(name, memop)                  \
3546 static void gen_##name(DisasContext *ctx)  \
3547 {                                          \
3548     gen_load_locked(ctx, memop);           \
3549 }
3550
3551 /* lwarx */
3552 LARX(lbarx, DEF_MEMOP(MO_UB))
3553 LARX(lharx, DEF_MEMOP(MO_UW))
3554 LARX(lwarx, DEF_MEMOP(MO_UL))
3555
3556 static void gen_fetch_inc_conditional(DisasContext *ctx, MemOp memop,
3557                                       TCGv EA, TCGCond cond, int addend)
3558 {
3559     TCGv t = tcg_temp_new();
3560     TCGv t2 = tcg_temp_new();
3561     TCGv u = tcg_temp_new();
3562
3563     tcg_gen_qemu_ld_tl(t, EA, ctx->mem_idx, memop);
3564     tcg_gen_addi_tl(t2, EA, MEMOP_GET_SIZE(memop));
3565     tcg_gen_qemu_ld_tl(t2, t2, ctx->mem_idx, memop);
3566     tcg_gen_addi_tl(u, t, addend);
3567
3568     /* E.g. for fetch and increment bounded... */
3569     /* mem(EA,s) = (t != t2 ? u = t + 1 : t) */
3570     tcg_gen_movcond_tl(cond, u, t, t2, u, t);
3571     tcg_gen_qemu_st_tl(u, EA, ctx->mem_idx, memop);
3572
3573     /* RT = (t != t2 ? t : u = 1<<(s*8-1)) */
3574     tcg_gen_movi_tl(u, 1 << (MEMOP_GET_SIZE(memop) * 8 - 1));
3575     tcg_gen_movcond_tl(cond, cpu_gpr[rD(ctx->opcode)], t, t2, t, u);
3576 }
3577
3578 static void gen_ld_atomic(DisasContext *ctx, MemOp memop)
3579 {
3580     uint32_t gpr_FC = FC(ctx->opcode);
3581     TCGv EA = tcg_temp_new();
3582     int rt = rD(ctx->opcode);
3583     bool need_serial;
3584     TCGv src, dst;
3585
3586     gen_addr_register(ctx, EA);
3587     dst = cpu_gpr[rt];
3588     src = cpu_gpr[(rt + 1) & 31];
3589
3590     need_serial = false;
3591     memop |= MO_ALIGN;
3592     switch (gpr_FC) {
3593     case 0: /* Fetch and add */
3594         tcg_gen_atomic_fetch_add_tl(dst, EA, src, ctx->mem_idx, memop);
3595         break;
3596     case 1: /* Fetch and xor */
3597         tcg_gen_atomic_fetch_xor_tl(dst, EA, src, ctx->mem_idx, memop);
3598         break;
3599     case 2: /* Fetch and or */
3600         tcg_gen_atomic_fetch_or_tl(dst, EA, src, ctx->mem_idx, memop);
3601         break;
3602     case 3: /* Fetch and 'and' */
3603         tcg_gen_atomic_fetch_and_tl(dst, EA, src, ctx->mem_idx, memop);
3604         break;
3605     case 4:  /* Fetch and max unsigned */
3606         tcg_gen_atomic_fetch_umax_tl(dst, EA, src, ctx->mem_idx, memop);
3607         break;
3608     case 5:  /* Fetch and max signed */
3609         tcg_gen_atomic_fetch_smax_tl(dst, EA, src, ctx->mem_idx, memop);
3610         break;
3611     case 6:  /* Fetch and min unsigned */
3612         tcg_gen_atomic_fetch_umin_tl(dst, EA, src, ctx->mem_idx, memop);
3613         break;
3614     case 7:  /* Fetch and min signed */
3615         tcg_gen_atomic_fetch_smin_tl(dst, EA, src, ctx->mem_idx, memop);
3616         break;
3617     case 8: /* Swap */
3618         tcg_gen_atomic_xchg_tl(dst, EA, src, ctx->mem_idx, memop);
3619         break;
3620
3621     case 16: /* Compare and swap not equal */
3622         if (tb_cflags(ctx->base.tb) & CF_PARALLEL) {
3623             need_serial = true;
3624         } else {
3625             TCGv t0 = tcg_temp_new();
3626             TCGv t1 = tcg_temp_new();
3627
3628             tcg_gen_qemu_ld_tl(t0, EA, ctx->mem_idx, memop);
3629             if ((memop & MO_SIZE) == MO_64 || TARGET_LONG_BITS == 32) {
3630                 tcg_gen_mov_tl(t1, src);
3631             } else {
3632                 tcg_gen_ext32u_tl(t1, src);
3633             }
3634             tcg_gen_movcond_tl(TCG_COND_NE, t1, t0, t1,
3635                                cpu_gpr[(rt + 2) & 31], t0);
3636             tcg_gen_qemu_st_tl(t1, EA, ctx->mem_idx, memop);
3637             tcg_gen_mov_tl(dst, t0);
3638         }
3639         break;
3640
3641     case 24: /* Fetch and increment bounded */
3642         if (tb_cflags(ctx->base.tb) & CF_PARALLEL) {
3643             need_serial = true;
3644         } else {
3645             gen_fetch_inc_conditional(ctx, memop, EA, TCG_COND_NE, 1);
3646         }
3647         break;
3648     case 25: /* Fetch and increment equal */
3649         if (tb_cflags(ctx->base.tb) & CF_PARALLEL) {
3650             need_serial = true;
3651         } else {
3652             gen_fetch_inc_conditional(ctx, memop, EA, TCG_COND_EQ, 1);
3653         }
3654         break;
3655     case 28: /* Fetch and decrement bounded */
3656         if (tb_cflags(ctx->base.tb) & CF_PARALLEL) {
3657             need_serial = true;
3658         } else {
3659             gen_fetch_inc_conditional(ctx, memop, EA, TCG_COND_NE, -1);
3660         }
3661         break;
3662
3663     default:
3664         /* invoke data storage error handler */
3665         gen_exception_err(ctx, POWERPC_EXCP_DSI, POWERPC_EXCP_INVAL);
3666     }
3667
3668     if (need_serial) {
3669         /* Restart with exclusive lock.  */
3670         gen_helper_exit_atomic(cpu_env);
3671         ctx->base.is_jmp = DISAS_NORETURN;
3672     }
3673 }
3674
3675 static void gen_lwat(DisasContext *ctx)
3676 {
3677     gen_ld_atomic(ctx, DEF_MEMOP(MO_UL));
3678 }
3679
3680 #ifdef TARGET_PPC64
3681 static void gen_ldat(DisasContext *ctx)
3682 {
3683     gen_ld_atomic(ctx, DEF_MEMOP(MO_UQ));
3684 }
3685 #endif
3686
3687 static void gen_st_atomic(DisasContext *ctx, MemOp memop)
3688 {
3689     uint32_t gpr_FC = FC(ctx->opcode);
3690     TCGv EA = tcg_temp_new();
3691     TCGv src, discard;
3692
3693     gen_addr_register(ctx, EA);
3694     src = cpu_gpr[rD(ctx->opcode)];
3695     discard = tcg_temp_new();
3696
3697     memop |= MO_ALIGN;
3698     switch (gpr_FC) {
3699     case 0: /* add and Store */
3700         tcg_gen_atomic_add_fetch_tl(discard, EA, src, ctx->mem_idx, memop);
3701         break;
3702     case 1: /* xor and Store */
3703         tcg_gen_atomic_xor_fetch_tl(discard, EA, src, ctx->mem_idx, memop);
3704         break;
3705     case 2: /* Or and Store */
3706         tcg_gen_atomic_or_fetch_tl(discard, EA, src, ctx->mem_idx, memop);
3707         break;
3708     case 3: /* 'and' and Store */
3709         tcg_gen_atomic_and_fetch_tl(discard, EA, src, ctx->mem_idx, memop);
3710         break;
3711     case 4:  /* Store max unsigned */
3712         tcg_gen_atomic_umax_fetch_tl(discard, EA, src, ctx->mem_idx, memop);
3713         break;
3714     case 5:  /* Store max signed */
3715         tcg_gen_atomic_smax_fetch_tl(discard, EA, src, ctx->mem_idx, memop);
3716         break;
3717     case 6:  /* Store min unsigned */
3718         tcg_gen_atomic_umin_fetch_tl(discard, EA, src, ctx->mem_idx, memop);
3719         break;
3720     case 7:  /* Store min signed */
3721         tcg_gen_atomic_smin_fetch_tl(discard, EA, src, ctx->mem_idx, memop);
3722         break;
3723     case 24: /* Store twin  */
3724         if (tb_cflags(ctx->base.tb) & CF_PARALLEL) {
3725             /* Restart with exclusive lock.  */
3726             gen_helper_exit_atomic(cpu_env);
3727             ctx->base.is_jmp = DISAS_NORETURN;
3728         } else {
3729             TCGv t = tcg_temp_new();
3730             TCGv t2 = tcg_temp_new();
3731             TCGv s = tcg_temp_new();
3732             TCGv s2 = tcg_temp_new();
3733             TCGv ea_plus_s = tcg_temp_new();
3734
3735             tcg_gen_qemu_ld_tl(t, EA, ctx->mem_idx, memop);
3736             tcg_gen_addi_tl(ea_plus_s, EA, MEMOP_GET_SIZE(memop));
3737             tcg_gen_qemu_ld_tl(t2, ea_plus_s, ctx->mem_idx, memop);
3738             tcg_gen_movcond_tl(TCG_COND_EQ, s, t, t2, src, t);
3739             tcg_gen_movcond_tl(TCG_COND_EQ, s2, t, t2, src, t2);
3740             tcg_gen_qemu_st_tl(s, EA, ctx->mem_idx, memop);
3741             tcg_gen_qemu_st_tl(s2, ea_plus_s, ctx->mem_idx, memop);
3742         }
3743         break;
3744     default:
3745         /* invoke data storage error handler */
3746         gen_exception_err(ctx, POWERPC_EXCP_DSI, POWERPC_EXCP_INVAL);
3747     }
3748 }
3749
3750 static void gen_stwat(DisasContext *ctx)
3751 {
3752     gen_st_atomic(ctx, DEF_MEMOP(MO_UL));
3753 }
3754
3755 #ifdef TARGET_PPC64
3756 static void gen_stdat(DisasContext *ctx)
3757 {
3758     gen_st_atomic(ctx, DEF_MEMOP(MO_UQ));
3759 }
3760 #endif
3761
3762 static void gen_conditional_store(DisasContext *ctx, MemOp memop)
3763 {
3764     TCGLabel *lfail;
3765     TCGv EA;
3766     TCGv cr0;
3767     TCGv t0;
3768     int rs = rS(ctx->opcode);
3769
3770     lfail = gen_new_label();
3771     EA = tcg_temp_new();
3772     cr0 = tcg_temp_new();
3773     t0 = tcg_temp_new();
3774
3775     tcg_gen_mov_tl(cr0, cpu_so);
3776     gen_set_access_type(ctx, ACCESS_RES);
3777     gen_addr_reg_index(ctx, EA);
3778     tcg_gen_brcond_tl(TCG_COND_NE, EA, cpu_reserve, lfail);
3779     tcg_gen_brcondi_tl(TCG_COND_NE, cpu_reserve_length, memop_size(memop), lfail);
3780
3781     tcg_gen_atomic_cmpxchg_tl(t0, cpu_reserve, cpu_reserve_val,
3782                               cpu_gpr[rs], ctx->mem_idx,
3783                               DEF_MEMOP(memop) | MO_ALIGN);
3784     tcg_gen_setcond_tl(TCG_COND_EQ, t0, t0, cpu_reserve_val);
3785     tcg_gen_shli_tl(t0, t0, CRF_EQ_BIT);
3786     tcg_gen_or_tl(cr0, cr0, t0);
3787
3788     gen_set_label(lfail);
3789     tcg_gen_trunc_tl_i32(cpu_crf[0], cr0);
3790     tcg_gen_movi_tl(cpu_reserve, -1);
3791 }
3792
3793 #define STCX(name, memop)                  \
3794 static void gen_##name(DisasContext *ctx)  \
3795 {                                          \
3796     gen_conditional_store(ctx, memop);     \
3797 }
3798
3799 STCX(stbcx_, DEF_MEMOP(MO_UB))
3800 STCX(sthcx_, DEF_MEMOP(MO_UW))
3801 STCX(stwcx_, DEF_MEMOP(MO_UL))
3802
3803 #if defined(TARGET_PPC64)
3804 /* ldarx */
3805 LARX(ldarx, DEF_MEMOP(MO_UQ))
3806 /* stdcx. */
3807 STCX(stdcx_, DEF_MEMOP(MO_UQ))
3808
3809 /* lqarx */
3810 static void gen_lqarx(DisasContext *ctx)
3811 {
3812     int rd = rD(ctx->opcode);
3813     TCGv EA, hi, lo;
3814     TCGv_i128 t16;
3815
3816     if (unlikely((rd & 1) || (rd == rA(ctx->opcode)) ||
3817                  (rd == rB(ctx->opcode)))) {
3818         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
3819         return;
3820     }
3821
3822     gen_set_access_type(ctx, ACCESS_RES);
3823     EA = tcg_temp_new();
3824     gen_addr_reg_index(ctx, EA);
3825
3826     /* Note that the low part is always in RD+1, even in LE mode.  */
3827     lo = cpu_gpr[rd + 1];
3828     hi = cpu_gpr[rd];
3829
3830     t16 = tcg_temp_new_i128();
3831     tcg_gen_qemu_ld_i128(t16, EA, ctx->mem_idx, DEF_MEMOP(MO_128 | MO_ALIGN));
3832     tcg_gen_extr_i128_i64(lo, hi, t16);
3833
3834     tcg_gen_mov_tl(cpu_reserve, EA);
3835     tcg_gen_movi_tl(cpu_reserve_length, 16);
3836     tcg_gen_st_tl(hi, cpu_env, offsetof(CPUPPCState, reserve_val));
3837     tcg_gen_st_tl(lo, cpu_env, offsetof(CPUPPCState, reserve_val2));
3838 }
3839
3840 /* stqcx. */
3841 static void gen_stqcx_(DisasContext *ctx)
3842 {
3843     TCGLabel *lfail;
3844     TCGv EA, t0, t1;
3845     TCGv cr0;
3846     TCGv_i128 cmp, val;
3847     int rs = rS(ctx->opcode);
3848
3849     if (unlikely(rs & 1)) {
3850         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
3851         return;
3852     }
3853
3854     lfail = gen_new_label();
3855     EA = tcg_temp_new();
3856     cr0 = tcg_temp_new();
3857
3858     tcg_gen_mov_tl(cr0, cpu_so);
3859     gen_set_access_type(ctx, ACCESS_RES);
3860     gen_addr_reg_index(ctx, EA);
3861     tcg_gen_brcond_tl(TCG_COND_NE, EA, cpu_reserve, lfail);
3862     tcg_gen_brcondi_tl(TCG_COND_NE, cpu_reserve_length, 16, lfail);
3863
3864     cmp = tcg_temp_new_i128();
3865     val = tcg_temp_new_i128();
3866
3867     tcg_gen_concat_i64_i128(cmp, cpu_reserve_val2, cpu_reserve_val);
3868
3869     /* Note that the low part is always in RS+1, even in LE mode.  */
3870     tcg_gen_concat_i64_i128(val, cpu_gpr[rs + 1], cpu_gpr[rs]);
3871
3872     tcg_gen_atomic_cmpxchg_i128(val, cpu_reserve, cmp, val, ctx->mem_idx,
3873                                 DEF_MEMOP(MO_128 | MO_ALIGN));
3874
3875     t0 = tcg_temp_new();
3876     t1 = tcg_temp_new();
3877     tcg_gen_extr_i128_i64(t1, t0, val);
3878
3879     tcg_gen_xor_tl(t1, t1, cpu_reserve_val2);
3880     tcg_gen_xor_tl(t0, t0, cpu_reserve_val);
3881     tcg_gen_or_tl(t0, t0, t1);
3882
3883     tcg_gen_setcondi_tl(TCG_COND_EQ, t0, t0, 0);
3884     tcg_gen_shli_tl(t0, t0, CRF_EQ_BIT);
3885     tcg_gen_or_tl(cr0, cr0, t0);
3886
3887     gen_set_label(lfail);
3888     tcg_gen_trunc_tl_i32(cpu_crf[0], cr0);
3889     tcg_gen_movi_tl(cpu_reserve, -1);
3890 }
3891 #endif /* defined(TARGET_PPC64) */
3892
3893 /* sync */
3894 static void gen_sync(DisasContext *ctx)
3895 {
3896     TCGBar bar = TCG_MO_ALL;
3897     uint32_t l = (ctx->opcode >> 21) & 3;
3898
3899     if ((l == 1) && (ctx->insns_flags2 & PPC2_MEM_LWSYNC)) {
3900         bar = TCG_MO_LD_LD | TCG_MO_LD_ST | TCG_MO_ST_ST;
3901     }
3902
3903     /*
3904      * We may need to check for a pending TLB flush.
3905      *
3906      * We do this on ptesync (l == 2) on ppc64 and any sync pn ppc32.
3907      *
3908      * Additionally, this can only happen in kernel mode however so
3909      * check MSR_PR as well.
3910      */
3911     if (((l == 2) || !(ctx->insns_flags & PPC_64B)) && !ctx->pr) {
3912         gen_check_tlb_flush(ctx, true);
3913     }
3914
3915     tcg_gen_mb(bar | TCG_BAR_SC);
3916 }
3917
3918 /* wait */
3919 static void gen_wait(DisasContext *ctx)
3920 {
3921     uint32_t wc;
3922
3923     if (ctx->insns_flags & PPC_WAIT) {
3924         /* v2.03-v2.07 define an older incompatible 'wait' encoding. */
3925
3926         if (ctx->insns_flags2 & PPC2_PM_ISA206) {
3927             /* v2.06 introduced the WC field. WC > 0 may be treated as no-op. */
3928             wc = WC(ctx->opcode);
3929         } else {
3930             wc = 0;
3931         }
3932
3933     } else if (ctx->insns_flags2 & PPC2_ISA300) {
3934         /* v3.0 defines a new 'wait' encoding. */
3935         wc = WC(ctx->opcode);
3936         if (ctx->insns_flags2 & PPC2_ISA310) {
3937             uint32_t pl = PL(ctx->opcode);
3938
3939             /* WC 1,2 may be treated as no-op. WC 3 is reserved. */
3940             if (wc == 3) {
3941                 gen_invalid(ctx);
3942                 return;
3943             }
3944
3945             /* PL 1-3 are reserved. If WC=2 then the insn is treated as noop. */
3946             if (pl > 0 && wc != 2) {
3947                 gen_invalid(ctx);
3948                 return;
3949             }
3950
3951         } else { /* ISA300 */
3952             /* WC 1-3 are reserved */
3953             if (wc > 0) {
3954                 gen_invalid(ctx);
3955                 return;
3956             }
3957         }
3958
3959     } else {
3960         warn_report("wait instruction decoded with wrong ISA flags.");
3961         gen_invalid(ctx);
3962         return;
3963     }
3964
3965     /*
3966      * wait without WC field or with WC=0 waits for an exception / interrupt
3967      * to occur.
3968      */
3969     if (wc == 0) {
3970         TCGv_i32 t0 = tcg_constant_i32(1);
3971         tcg_gen_st_i32(t0, cpu_env,
3972                        -offsetof(PowerPCCPU, env) + offsetof(CPUState, halted));
3973         /* Stop translation, as the CPU is supposed to sleep from now */
3974         gen_exception_nip(ctx, EXCP_HLT, ctx->base.pc_next);
3975     }
3976
3977     /*
3978      * Other wait types must not just wait until an exception occurs because
3979      * ignoring their other wake-up conditions could cause a hang.
3980      *
3981      * For v2.06 and 2.07, wc=1,2,3 are architected but may be implemented as
3982      * no-ops.
3983      *
3984      * wc=1 and wc=3 explicitly allow the instruction to be treated as a no-op.
3985      *
3986      * wc=2 waits for an implementation-specific condition, such could be
3987      * always true, so it can be implemented as a no-op.
3988      *
3989      * For v3.1, wc=1,2 are architected but may be implemented as no-ops.
3990      *
3991      * wc=1 (waitrsv) waits for an exception or a reservation to be lost.
3992      * Reservation-loss may have implementation-specific conditions, so it
3993      * can be implemented as a no-op.
3994      *
3995      * wc=2 waits for an exception or an amount of time to pass. This
3996      * amount is implementation-specific so it can be implemented as a
3997      * no-op.
3998      *
3999      * ISA v3.1 allows for execution to resume "in the rare case of
4000      * an implementation-dependent event", so in any case software must
4001      * not depend on the architected resumption condition to become
4002      * true, so no-op implementations should be architecturally correct
4003      * (if suboptimal).
4004      */
4005 }
4006
4007 #if defined(TARGET_PPC64)
4008 static void gen_doze(DisasContext *ctx)
4009 {
4010 #if defined(CONFIG_USER_ONLY)
4011     GEN_PRIV(ctx);
4012 #else
4013     TCGv_i32 t;
4014
4015     CHK_HV(ctx);
4016     translator_io_start(&ctx->base);
4017     t = tcg_constant_i32(PPC_PM_DOZE);
4018     gen_helper_pminsn(cpu_env, t);
4019     /* Stop translation, as the CPU is supposed to sleep from now */
4020     gen_exception_nip(ctx, EXCP_HLT, ctx->base.pc_next);
4021 #endif /* defined(CONFIG_USER_ONLY) */
4022 }
4023
4024 static void gen_nap(DisasContext *ctx)
4025 {
4026 #if defined(CONFIG_USER_ONLY)
4027     GEN_PRIV(ctx);
4028 #else
4029     TCGv_i32 t;
4030
4031     CHK_HV(ctx);
4032     translator_io_start(&ctx->base);
4033     t = tcg_constant_i32(PPC_PM_NAP);
4034     gen_helper_pminsn(cpu_env, t);
4035     /* Stop translation, as the CPU is supposed to sleep from now */
4036     gen_exception_nip(ctx, EXCP_HLT, ctx->base.pc_next);
4037 #endif /* defined(CONFIG_USER_ONLY) */
4038 }
4039
4040 static void gen_stop(DisasContext *ctx)
4041 {
4042 #if defined(CONFIG_USER_ONLY)
4043     GEN_PRIV(ctx);
4044 #else
4045     TCGv_i32 t;
4046
4047     CHK_HV(ctx);
4048     translator_io_start(&ctx->base);
4049     t = tcg_constant_i32(PPC_PM_STOP);
4050     gen_helper_pminsn(cpu_env, t);
4051     /* Stop translation, as the CPU is supposed to sleep from now */
4052     gen_exception_nip(ctx, EXCP_HLT, ctx->base.pc_next);
4053 #endif /* defined(CONFIG_USER_ONLY) */
4054 }
4055
4056 static void gen_sleep(DisasContext *ctx)
4057 {
4058 #if defined(CONFIG_USER_ONLY)
4059     GEN_PRIV(ctx);
4060 #else
4061     TCGv_i32 t;
4062
4063     CHK_HV(ctx);
4064     translator_io_start(&ctx->base);
4065     t = tcg_constant_i32(PPC_PM_SLEEP);
4066     gen_helper_pminsn(cpu_env, t);
4067     /* Stop translation, as the CPU is supposed to sleep from now */
4068     gen_exception_nip(ctx, EXCP_HLT, ctx->base.pc_next);
4069 #endif /* defined(CONFIG_USER_ONLY) */
4070 }
4071
4072 static void gen_rvwinkle(DisasContext *ctx)
4073 {
4074 #if defined(CONFIG_USER_ONLY)
4075     GEN_PRIV(ctx);
4076 #else
4077     TCGv_i32 t;
4078
4079     CHK_HV(ctx);
4080     translator_io_start(&ctx->base);
4081     t = tcg_constant_i32(PPC_PM_RVWINKLE);
4082     gen_helper_pminsn(cpu_env, t);
4083     /* Stop translation, as the CPU is supposed to sleep from now */
4084     gen_exception_nip(ctx, EXCP_HLT, ctx->base.pc_next);
4085 #endif /* defined(CONFIG_USER_ONLY) */
4086 }
4087 #endif /* #if defined(TARGET_PPC64) */
4088
4089 static inline void gen_update_cfar(DisasContext *ctx, target_ulong nip)
4090 {
4091 #if defined(TARGET_PPC64)
4092     if (ctx->has_cfar) {
4093         tcg_gen_movi_tl(cpu_cfar, nip);
4094     }
4095 #endif
4096 }
4097
4098 #if defined(TARGET_PPC64)
4099 static void pmu_count_insns(DisasContext *ctx)
4100 {
4101     /*
4102      * Do not bother calling the helper if the PMU isn't counting
4103      * instructions.
4104      */
4105     if (!ctx->pmu_insn_cnt) {
4106         return;
4107     }
4108
4109  #if !defined(CONFIG_USER_ONLY)
4110     TCGLabel *l;
4111     TCGv t0;
4112
4113     /*
4114      * The PMU insns_inc() helper stops the internal PMU timer if a
4115      * counter overflows happens. In that case, if the guest is
4116      * running with icount and we do not handle it beforehand,
4117      * the helper can trigger a 'bad icount read'.
4118      */
4119     translator_io_start(&ctx->base);
4120
4121     /* Avoid helper calls when only PMC5-6 are enabled. */
4122     if (!ctx->pmc_other) {
4123         l = gen_new_label();
4124         t0 = tcg_temp_new();
4125
4126         gen_load_spr(t0, SPR_POWER_PMC5);
4127         tcg_gen_addi_tl(t0, t0, ctx->base.num_insns);
4128         gen_store_spr(SPR_POWER_PMC5, t0);
4129         /* Check for overflow, if it's enabled */
4130         if (ctx->mmcr0_pmcjce) {
4131             tcg_gen_brcondi_tl(TCG_COND_LT, t0, PMC_COUNTER_NEGATIVE_VAL, l);
4132             gen_helper_handle_pmc5_overflow(cpu_env);
4133         }
4134
4135         gen_set_label(l);
4136     } else {
4137         gen_helper_insns_inc(cpu_env, tcg_constant_i32(ctx->base.num_insns));
4138     }
4139   #else
4140     /*
4141      * User mode can read (but not write) PMC5 and start/stop
4142      * the PMU via MMCR0_FC. In this case just increment
4143      * PMC5 with base.num_insns.
4144      */
4145     TCGv t0 = tcg_temp_new();
4146
4147     gen_load_spr(t0, SPR_POWER_PMC5);
4148     tcg_gen_addi_tl(t0, t0, ctx->base.num_insns);
4149     gen_store_spr(SPR_POWER_PMC5, t0);
4150   #endif /* #if !defined(CONFIG_USER_ONLY) */
4151 }
4152 #else
4153 static void pmu_count_insns(DisasContext *ctx)
4154 {
4155     return;
4156 }
4157 #endif /* #if defined(TARGET_PPC64) */
4158
4159 static inline bool use_goto_tb(DisasContext *ctx, target_ulong dest)
4160 {
4161     return translator_use_goto_tb(&ctx->base, dest);
4162 }
4163
4164 static void gen_lookup_and_goto_ptr(DisasContext *ctx)
4165 {
4166     if (unlikely(ctx->singlestep_enabled)) {
4167         gen_debug_exception(ctx);
4168     } else {
4169         /*
4170          * tcg_gen_lookup_and_goto_ptr will exit the TB if
4171          * CF_NO_GOTO_PTR is set. Count insns now.
4172          */
4173         if (ctx->base.tb->flags & CF_NO_GOTO_PTR) {
4174             pmu_count_insns(ctx);
4175         }
4176
4177         tcg_gen_lookup_and_goto_ptr();
4178     }
4179 }
4180
4181 /***                                Branch                                 ***/
4182 static void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
4183 {
4184     if (NARROW_MODE(ctx)) {
4185         dest = (uint32_t) dest;
4186     }
4187     if (use_goto_tb(ctx, dest)) {
4188         pmu_count_insns(ctx);
4189         tcg_gen_goto_tb(n);
4190         tcg_gen_movi_tl(cpu_nip, dest & ~3);
4191         tcg_gen_exit_tb(ctx->base.tb, n);
4192     } else {
4193         tcg_gen_movi_tl(cpu_nip, dest & ~3);
4194         gen_lookup_and_goto_ptr(ctx);
4195     }
4196 }
4197
4198 static inline void gen_setlr(DisasContext *ctx, target_ulong nip)
4199 {
4200     if (NARROW_MODE(ctx)) {
4201         nip = (uint32_t)nip;
4202     }
4203     tcg_gen_movi_tl(cpu_lr, nip);
4204 }
4205
4206 /* b ba bl bla */
4207 static void gen_b(DisasContext *ctx)
4208 {
4209     target_ulong li, target;
4210
4211     /* sign extend LI */
4212     li = LI(ctx->opcode);
4213     li = (li ^ 0x02000000) - 0x02000000;
4214     if (likely(AA(ctx->opcode) == 0)) {
4215         target = ctx->cia + li;
4216     } else {
4217         target = li;
4218     }
4219     if (LK(ctx->opcode)) {
4220         gen_setlr(ctx, ctx->base.pc_next);
4221     }
4222     gen_update_cfar(ctx, ctx->cia);
4223     gen_goto_tb(ctx, 0, target);
4224     ctx->base.is_jmp = DISAS_NORETURN;
4225 }
4226
4227 #define BCOND_IM  0
4228 #define BCOND_LR  1
4229 #define BCOND_CTR 2
4230 #define BCOND_TAR 3
4231
4232 static void gen_bcond(DisasContext *ctx, int type)
4233 {
4234     uint32_t bo = BO(ctx->opcode);
4235     TCGLabel *l1;
4236     TCGv target;
4237
4238     if (type == BCOND_LR || type == BCOND_CTR || type == BCOND_TAR) {
4239         target = tcg_temp_new();
4240         if (type == BCOND_CTR) {
4241             tcg_gen_mov_tl(target, cpu_ctr);
4242         } else if (type == BCOND_TAR) {
4243             gen_load_spr(target, SPR_TAR);
4244         } else {
4245             tcg_gen_mov_tl(target, cpu_lr);
4246         }
4247     } else {
4248         target = NULL;
4249     }
4250     if (LK(ctx->opcode)) {
4251         gen_setlr(ctx, ctx->base.pc_next);
4252     }
4253     l1 = gen_new_label();
4254     if ((bo & 0x4) == 0) {
4255         /* Decrement and test CTR */
4256         TCGv temp = tcg_temp_new();
4257
4258         if (type == BCOND_CTR) {
4259             /*
4260              * All ISAs up to v3 describe this form of bcctr as invalid but
4261              * some processors, ie. 64-bit server processors compliant with
4262              * arch 2.x, do implement a "test and decrement" logic instead,
4263              * as described in their respective UMs. This logic involves CTR
4264              * to act as both the branch target and a counter, which makes
4265              * it basically useless and thus never used in real code.
4266              *
4267              * This form was hence chosen to trigger extra micro-architectural
4268              * side-effect on real HW needed for the Spectre v2 workaround.
4269              * It is up to guests that implement such workaround, ie. linux, to
4270              * use this form in a way it just triggers the side-effect without
4271              * doing anything else harmful.
4272              */
4273             if (unlikely(!is_book3s_arch2x(ctx))) {
4274                 gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
4275                 return;
4276             }
4277
4278             if (NARROW_MODE(ctx)) {
4279                 tcg_gen_ext32u_tl(temp, cpu_ctr);
4280             } else {
4281                 tcg_gen_mov_tl(temp, cpu_ctr);
4282             }
4283             if (bo & 0x2) {
4284                 tcg_gen_brcondi_tl(TCG_COND_NE, temp, 0, l1);
4285             } else {
4286                 tcg_gen_brcondi_tl(TCG_COND_EQ, temp, 0, l1);
4287             }
4288             tcg_gen_subi_tl(cpu_ctr, cpu_ctr, 1);
4289         } else {
4290             tcg_gen_subi_tl(cpu_ctr, cpu_ctr, 1);
4291             if (NARROW_MODE(ctx)) {
4292                 tcg_gen_ext32u_tl(temp, cpu_ctr);
4293             } else {
4294                 tcg_gen_mov_tl(temp, cpu_ctr);
4295             }
4296             if (bo & 0x2) {
4297                 tcg_gen_brcondi_tl(TCG_COND_NE, temp, 0, l1);
4298             } else {
4299                 tcg_gen_brcondi_tl(TCG_COND_EQ, temp, 0, l1);
4300             }
4301         }
4302     }
4303     if ((bo & 0x10) == 0) {
4304         /* Test CR */
4305         uint32_t bi = BI(ctx->opcode);
4306         uint32_t mask = 0x08 >> (bi & 0x03);
4307         TCGv_i32 temp = tcg_temp_new_i32();
4308
4309         if (bo & 0x8) {
4310             tcg_gen_andi_i32(temp, cpu_crf[bi >> 2], mask);
4311             tcg_gen_brcondi_i32(TCG_COND_EQ, temp, 0, l1);
4312         } else {
4313             tcg_gen_andi_i32(temp, cpu_crf[bi >> 2], mask);
4314             tcg_gen_brcondi_i32(TCG_COND_NE, temp, 0, l1);
4315         }
4316     }
4317     gen_update_cfar(ctx, ctx->cia);
4318     if (type == BCOND_IM) {
4319         target_ulong li = (target_long)((int16_t)(BD(ctx->opcode)));
4320         if (likely(AA(ctx->opcode) == 0)) {
4321             gen_goto_tb(ctx, 0, ctx->cia + li);
4322         } else {
4323             gen_goto_tb(ctx, 0, li);
4324         }
4325     } else {
4326         if (NARROW_MODE(ctx)) {
4327             tcg_gen_andi_tl(cpu_nip, target, (uint32_t)~3);
4328         } else {
4329             tcg_gen_andi_tl(cpu_nip, target, ~3);
4330         }
4331         gen_lookup_and_goto_ptr(ctx);
4332     }
4333     if ((bo & 0x14) != 0x14) {
4334         /* fallthrough case */
4335         gen_set_label(l1);
4336         gen_goto_tb(ctx, 1, ctx->base.pc_next);
4337     }
4338     ctx->base.is_jmp = DISAS_NORETURN;
4339 }
4340
4341 static void gen_bc(DisasContext *ctx)
4342 {
4343     gen_bcond(ctx, BCOND_IM);
4344 }
4345
4346 static void gen_bcctr(DisasContext *ctx)
4347 {
4348     gen_bcond(ctx, BCOND_CTR);
4349 }
4350
4351 static void gen_bclr(DisasContext *ctx)
4352 {
4353     gen_bcond(ctx, BCOND_LR);
4354 }
4355
4356 static void gen_bctar(DisasContext *ctx)
4357 {
4358     gen_bcond(ctx, BCOND_TAR);
4359 }
4360
4361 /***                      Condition register logical                       ***/
4362 #define GEN_CRLOGIC(name, tcg_op, opc)                                        \
4363 static void glue(gen_, name)(DisasContext *ctx)                               \
4364 {                                                                             \
4365     uint8_t bitmask;                                                          \
4366     int sh;                                                                   \
4367     TCGv_i32 t0, t1;                                                          \
4368     sh = (crbD(ctx->opcode) & 0x03) - (crbA(ctx->opcode) & 0x03);             \
4369     t0 = tcg_temp_new_i32();                                                  \
4370     if (sh > 0)                                                               \
4371         tcg_gen_shri_i32(t0, cpu_crf[crbA(ctx->opcode) >> 2], sh);            \
4372     else if (sh < 0)                                                          \
4373         tcg_gen_shli_i32(t0, cpu_crf[crbA(ctx->opcode) >> 2], -sh);           \
4374     else                                                                      \
4375         tcg_gen_mov_i32(t0, cpu_crf[crbA(ctx->opcode) >> 2]);                 \
4376     t1 = tcg_temp_new_i32();                                                  \
4377     sh = (crbD(ctx->opcode) & 0x03) - (crbB(ctx->opcode) & 0x03);             \
4378     if (sh > 0)                                                               \
4379         tcg_gen_shri_i32(t1, cpu_crf[crbB(ctx->opcode) >> 2], sh);            \
4380     else if (sh < 0)                                                          \
4381         tcg_gen_shli_i32(t1, cpu_crf[crbB(ctx->opcode) >> 2], -sh);           \
4382     else                                                                      \
4383         tcg_gen_mov_i32(t1, cpu_crf[crbB(ctx->opcode) >> 2]);                 \
4384     tcg_op(t0, t0, t1);                                                       \
4385     bitmask = 0x08 >> (crbD(ctx->opcode) & 0x03);                             \
4386     tcg_gen_andi_i32(t0, t0, bitmask);                                        \
4387     tcg_gen_andi_i32(t1, cpu_crf[crbD(ctx->opcode) >> 2], ~bitmask);          \
4388     tcg_gen_or_i32(cpu_crf[crbD(ctx->opcode) >> 2], t0, t1);                  \
4389 }
4390
4391 /* crand */
4392 GEN_CRLOGIC(crand, tcg_gen_and_i32, 0x08);
4393 /* crandc */
4394 GEN_CRLOGIC(crandc, tcg_gen_andc_i32, 0x04);
4395 /* creqv */
4396 GEN_CRLOGIC(creqv, tcg_gen_eqv_i32, 0x09);
4397 /* crnand */
4398 GEN_CRLOGIC(crnand, tcg_gen_nand_i32, 0x07);
4399 /* crnor */
4400 GEN_CRLOGIC(crnor, tcg_gen_nor_i32, 0x01);
4401 /* cror */
4402 GEN_CRLOGIC(cror, tcg_gen_or_i32, 0x0E);
4403 /* crorc */
4404 GEN_CRLOGIC(crorc, tcg_gen_orc_i32, 0x0D);
4405 /* crxor */
4406 GEN_CRLOGIC(crxor, tcg_gen_xor_i32, 0x06);
4407
4408 /* mcrf */
4409 static void gen_mcrf(DisasContext *ctx)
4410 {
4411     tcg_gen_mov_i32(cpu_crf[crfD(ctx->opcode)], cpu_crf[crfS(ctx->opcode)]);
4412 }
4413
4414 /***                           System linkage                              ***/
4415
4416 /* rfi (supervisor only) */
4417 static void gen_rfi(DisasContext *ctx)
4418 {
4419 #if defined(CONFIG_USER_ONLY)
4420     GEN_PRIV(ctx);
4421 #else
4422     /*
4423      * This instruction doesn't exist anymore on 64-bit server
4424      * processors compliant with arch 2.x
4425      */
4426     if (is_book3s_arch2x(ctx)) {
4427         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
4428         return;
4429     }
4430     /* Restore CPU state */
4431     CHK_SV(ctx);
4432     translator_io_start(&ctx->base);
4433     gen_update_cfar(ctx, ctx->cia);
4434     gen_helper_rfi(cpu_env);
4435     ctx->base.is_jmp = DISAS_EXIT;
4436 #endif
4437 }
4438
4439 #if defined(TARGET_PPC64)
4440 static void gen_rfid(DisasContext *ctx)
4441 {
4442 #if defined(CONFIG_USER_ONLY)
4443     GEN_PRIV(ctx);
4444 #else
4445     /* Restore CPU state */
4446     CHK_SV(ctx);
4447     translator_io_start(&ctx->base);
4448     gen_update_cfar(ctx, ctx->cia);
4449     gen_helper_rfid(cpu_env);
4450     ctx->base.is_jmp = DISAS_EXIT;
4451 #endif
4452 }
4453
4454 #if !defined(CONFIG_USER_ONLY)
4455 static void gen_rfscv(DisasContext *ctx)
4456 {
4457 #if defined(CONFIG_USER_ONLY)
4458     GEN_PRIV(ctx);
4459 #else
4460     /* Restore CPU state */
4461     CHK_SV(ctx);
4462     translator_io_start(&ctx->base);
4463     gen_update_cfar(ctx, ctx->cia);
4464     gen_helper_rfscv(cpu_env);
4465     ctx->base.is_jmp = DISAS_EXIT;
4466 #endif
4467 }
4468 #endif
4469
4470 static void gen_hrfid(DisasContext *ctx)
4471 {
4472 #if defined(CONFIG_USER_ONLY)
4473     GEN_PRIV(ctx);
4474 #else
4475     /* Restore CPU state */
4476     CHK_HV(ctx);
4477     translator_io_start(&ctx->base);
4478     gen_helper_hrfid(cpu_env);
4479     ctx->base.is_jmp = DISAS_EXIT;
4480 #endif
4481 }
4482 #endif
4483
4484 /* sc */
4485 #if defined(CONFIG_USER_ONLY)
4486 #define POWERPC_SYSCALL POWERPC_EXCP_SYSCALL_USER
4487 #else
4488 #define POWERPC_SYSCALL POWERPC_EXCP_SYSCALL
4489 #define POWERPC_SYSCALL_VECTORED POWERPC_EXCP_SYSCALL_VECTORED
4490 #endif
4491 static void gen_sc(DisasContext *ctx)
4492 {
4493     uint32_t lev;
4494
4495     /*
4496      * LEV is a 7-bit field, but the top 6 bits are treated as a reserved
4497      * field (i.e., ignored). ISA v3.1 changes that to 5 bits, but that is
4498      * for Ultravisor which TCG does not support, so just ignore the top 6.
4499      */
4500     lev = (ctx->opcode >> 5) & 0x1;
4501     gen_exception_err(ctx, POWERPC_SYSCALL, lev);
4502 }
4503
4504 #if defined(TARGET_PPC64)
4505 #if !defined(CONFIG_USER_ONLY)
4506 static void gen_scv(DisasContext *ctx)
4507 {
4508     uint32_t lev = (ctx->opcode >> 5) & 0x7F;
4509
4510     /* Set the PC back to the faulting instruction. */
4511     gen_update_nip(ctx, ctx->cia);
4512     gen_helper_scv(cpu_env, tcg_constant_i32(lev));
4513
4514     ctx->base.is_jmp = DISAS_NORETURN;
4515 }
4516 #endif
4517 #endif
4518
4519 /***                                Trap                                   ***/
4520
4521 /* Check for unconditional traps (always or never) */
4522 static bool check_unconditional_trap(DisasContext *ctx)
4523 {
4524     /* Trap never */
4525     if (TO(ctx->opcode) == 0) {
4526         return true;
4527     }
4528     /* Trap always */
4529     if (TO(ctx->opcode) == 31) {
4530         gen_exception_err(ctx, POWERPC_EXCP_PROGRAM, POWERPC_EXCP_TRAP);
4531         return true;
4532     }
4533     return false;
4534 }
4535
4536 /* tw */
4537 static void gen_tw(DisasContext *ctx)
4538 {
4539     TCGv_i32 t0;
4540
4541     if (check_unconditional_trap(ctx)) {
4542         return;
4543     }
4544     t0 = tcg_constant_i32(TO(ctx->opcode));
4545     gen_helper_tw(cpu_env, cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],
4546                   t0);
4547 }
4548
4549 /* twi */
4550 static void gen_twi(DisasContext *ctx)
4551 {
4552     TCGv t0;
4553     TCGv_i32 t1;
4554
4555     if (check_unconditional_trap(ctx)) {
4556         return;
4557     }
4558     t0 = tcg_constant_tl(SIMM(ctx->opcode));
4559     t1 = tcg_constant_i32(TO(ctx->opcode));
4560     gen_helper_tw(cpu_env, cpu_gpr[rA(ctx->opcode)], t0, t1);
4561 }
4562
4563 #if defined(TARGET_PPC64)
4564 /* td */
4565 static void gen_td(DisasContext *ctx)
4566 {
4567     TCGv_i32 t0;
4568
4569     if (check_unconditional_trap(ctx)) {
4570         return;
4571     }
4572     t0 = tcg_constant_i32(TO(ctx->opcode));
4573     gen_helper_td(cpu_env, cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)],
4574                   t0);
4575 }
4576
4577 /* tdi */
4578 static void gen_tdi(DisasContext *ctx)
4579 {
4580     TCGv t0;
4581     TCGv_i32 t1;
4582
4583     if (check_unconditional_trap(ctx)) {
4584         return;
4585     }
4586     t0 = tcg_constant_tl(SIMM(ctx->opcode));
4587     t1 = tcg_constant_i32(TO(ctx->opcode));
4588     gen_helper_td(cpu_env, cpu_gpr[rA(ctx->opcode)], t0, t1);
4589 }
4590 #endif
4591
4592 /***                          Processor control                            ***/
4593
4594 /* mcrxr */
4595 static void gen_mcrxr(DisasContext *ctx)
4596 {
4597     TCGv_i32 t0 = tcg_temp_new_i32();
4598     TCGv_i32 t1 = tcg_temp_new_i32();
4599     TCGv_i32 dst = cpu_crf[crfD(ctx->opcode)];
4600
4601     tcg_gen_trunc_tl_i32(t0, cpu_so);
4602     tcg_gen_trunc_tl_i32(t1, cpu_ov);
4603     tcg_gen_trunc_tl_i32(dst, cpu_ca);
4604     tcg_gen_shli_i32(t0, t0, 3);
4605     tcg_gen_shli_i32(t1, t1, 2);
4606     tcg_gen_shli_i32(dst, dst, 1);
4607     tcg_gen_or_i32(dst, dst, t0);
4608     tcg_gen_or_i32(dst, dst, t1);
4609
4610     tcg_gen_movi_tl(cpu_so, 0);
4611     tcg_gen_movi_tl(cpu_ov, 0);
4612     tcg_gen_movi_tl(cpu_ca, 0);
4613 }
4614
4615 #ifdef TARGET_PPC64
4616 /* mcrxrx */
4617 static void gen_mcrxrx(DisasContext *ctx)
4618 {
4619     TCGv t0 = tcg_temp_new();
4620     TCGv t1 = tcg_temp_new();
4621     TCGv_i32 dst = cpu_crf[crfD(ctx->opcode)];
4622
4623     /* copy OV and OV32 */
4624     tcg_gen_shli_tl(t0, cpu_ov, 1);
4625     tcg_gen_or_tl(t0, t0, cpu_ov32);
4626     tcg_gen_shli_tl(t0, t0, 2);
4627     /* copy CA and CA32 */
4628     tcg_gen_shli_tl(t1, cpu_ca, 1);
4629     tcg_gen_or_tl(t1, t1, cpu_ca32);
4630     tcg_gen_or_tl(t0, t0, t1);
4631     tcg_gen_trunc_tl_i32(dst, t0);
4632 }
4633 #endif
4634
4635 /* mfcr mfocrf */
4636 static void gen_mfcr(DisasContext *ctx)
4637 {
4638     uint32_t crm, crn;
4639
4640     if (likely(ctx->opcode & 0x00100000)) {
4641         crm = CRM(ctx->opcode);
4642         if (likely(crm && ((crm & (crm - 1)) == 0))) {
4643             crn = ctz32(crm);
4644             tcg_gen_extu_i32_tl(cpu_gpr[rD(ctx->opcode)], cpu_crf[7 - crn]);
4645             tcg_gen_shli_tl(cpu_gpr[rD(ctx->opcode)],
4646                             cpu_gpr[rD(ctx->opcode)], crn * 4);
4647         }
4648     } else {
4649         TCGv_i32 t0 = tcg_temp_new_i32();
4650         tcg_gen_mov_i32(t0, cpu_crf[0]);
4651         tcg_gen_shli_i32(t0, t0, 4);
4652         tcg_gen_or_i32(t0, t0, cpu_crf[1]);
4653         tcg_gen_shli_i32(t0, t0, 4);
4654         tcg_gen_or_i32(t0, t0, cpu_crf[2]);
4655         tcg_gen_shli_i32(t0, t0, 4);
4656         tcg_gen_or_i32(t0, t0, cpu_crf[3]);
4657         tcg_gen_shli_i32(t0, t0, 4);
4658         tcg_gen_or_i32(t0, t0, cpu_crf[4]);
4659         tcg_gen_shli_i32(t0, t0, 4);
4660         tcg_gen_or_i32(t0, t0, cpu_crf[5]);
4661         tcg_gen_shli_i32(t0, t0, 4);
4662         tcg_gen_or_i32(t0, t0, cpu_crf[6]);
4663         tcg_gen_shli_i32(t0, t0, 4);
4664         tcg_gen_or_i32(t0, t0, cpu_crf[7]);
4665         tcg_gen_extu_i32_tl(cpu_gpr[rD(ctx->opcode)], t0);
4666     }
4667 }
4668
4669 /* mfmsr */
4670 static void gen_mfmsr(DisasContext *ctx)
4671 {
4672     CHK_SV(ctx);
4673     tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_msr);
4674 }
4675
4676 /* mfspr */
4677 static inline void gen_op_mfspr(DisasContext *ctx)
4678 {
4679     void (*read_cb)(DisasContext *ctx, int gprn, int sprn);
4680     uint32_t sprn = SPR(ctx->opcode);
4681
4682 #if defined(CONFIG_USER_ONLY)
4683     read_cb = ctx->spr_cb[sprn].uea_read;
4684 #else
4685     if (ctx->pr) {
4686         read_cb = ctx->spr_cb[sprn].uea_read;
4687     } else if (ctx->hv) {
4688         read_cb = ctx->spr_cb[sprn].hea_read;
4689     } else {
4690         read_cb = ctx->spr_cb[sprn].oea_read;
4691     }
4692 #endif
4693     if (likely(read_cb != NULL)) {
4694         if (likely(read_cb != SPR_NOACCESS)) {
4695             (*read_cb)(ctx, rD(ctx->opcode), sprn);
4696         } else {
4697             /* Privilege exception */
4698             /*
4699              * This is a hack to avoid warnings when running Linux:
4700              * this OS breaks the PowerPC virtualisation model,
4701              * allowing userland application to read the PVR
4702              */
4703             if (sprn != SPR_PVR) {
4704                 qemu_log_mask(LOG_GUEST_ERROR, "Trying to read privileged spr "
4705                               "%d (0x%03x) at " TARGET_FMT_lx "\n", sprn, sprn,
4706                               ctx->cia);
4707             }
4708             gen_priv_exception(ctx, POWERPC_EXCP_PRIV_REG);
4709         }
4710     } else {
4711         /* ISA 2.07 defines these as no-ops */
4712         if ((ctx->insns_flags2 & PPC2_ISA207S) &&
4713             (sprn >= 808 && sprn <= 811)) {
4714             /* This is a nop */
4715             return;
4716         }
4717         /* Not defined */
4718         qemu_log_mask(LOG_GUEST_ERROR,
4719                       "Trying to read invalid spr %d (0x%03x) at "
4720                       TARGET_FMT_lx "\n", sprn, sprn, ctx->cia);
4721
4722         /*
4723          * The behaviour depends on MSR:PR and SPR# bit 0x10, it can
4724          * generate a priv, a hv emu or a no-op
4725          */
4726         if (sprn & 0x10) {
4727             if (ctx->pr) {
4728                 gen_priv_exception(ctx, POWERPC_EXCP_PRIV_REG);
4729             }
4730         } else {
4731             if (ctx->pr || sprn == 0 || sprn == 4 || sprn == 5 || sprn == 6) {
4732                 gen_hvpriv_exception(ctx, POWERPC_EXCP_PRIV_REG);
4733             }
4734         }
4735     }
4736 }
4737
4738 static void gen_mfspr(DisasContext *ctx)
4739 {
4740     gen_op_mfspr(ctx);
4741 }
4742
4743 /* mftb */
4744 static void gen_mftb(DisasContext *ctx)
4745 {
4746     gen_op_mfspr(ctx);
4747 }
4748
4749 /* mtcrf mtocrf*/
4750 static void gen_mtcrf(DisasContext *ctx)
4751 {
4752     uint32_t crm, crn;
4753
4754     crm = CRM(ctx->opcode);
4755     if (likely((ctx->opcode & 0x00100000))) {
4756         if (crm && ((crm & (crm - 1)) == 0)) {
4757             TCGv_i32 temp = tcg_temp_new_i32();
4758             crn = ctz32(crm);
4759             tcg_gen_trunc_tl_i32(temp, cpu_gpr[rS(ctx->opcode)]);
4760             tcg_gen_shri_i32(temp, temp, crn * 4);
4761             tcg_gen_andi_i32(cpu_crf[7 - crn], temp, 0xf);
4762         }
4763     } else {
4764         TCGv_i32 temp = tcg_temp_new_i32();
4765         tcg_gen_trunc_tl_i32(temp, cpu_gpr[rS(ctx->opcode)]);
4766         for (crn = 0 ; crn < 8 ; crn++) {
4767             if (crm & (1 << crn)) {
4768                     tcg_gen_shri_i32(cpu_crf[7 - crn], temp, crn * 4);
4769                     tcg_gen_andi_i32(cpu_crf[7 - crn], cpu_crf[7 - crn], 0xf);
4770             }
4771         }
4772     }
4773 }
4774
4775 /* mtmsr */
4776 #if defined(TARGET_PPC64)
4777 static void gen_mtmsrd(DisasContext *ctx)
4778 {
4779     if (unlikely(!is_book3s_arch2x(ctx))) {
4780         gen_invalid(ctx);
4781         return;
4782     }
4783
4784     CHK_SV(ctx);
4785
4786 #if !defined(CONFIG_USER_ONLY)
4787     TCGv t0, t1;
4788     target_ulong mask;
4789
4790     t0 = tcg_temp_new();
4791     t1 = tcg_temp_new();
4792
4793     translator_io_start(&ctx->base);
4794
4795     if (ctx->opcode & 0x00010000) {
4796         /* L=1 form only updates EE and RI */
4797         mask = (1ULL << MSR_RI) | (1ULL << MSR_EE);
4798     } else {
4799         /* mtmsrd does not alter HV, S, ME, or LE */
4800         mask = ~((1ULL << MSR_LE) | (1ULL << MSR_ME) | (1ULL << MSR_S) |
4801                  (1ULL << MSR_HV));
4802         /*
4803          * XXX: we need to update nip before the store if we enter
4804          *      power saving mode, we will exit the loop directly from
4805          *      ppc_store_msr
4806          */
4807         gen_update_nip(ctx, ctx->base.pc_next);
4808     }
4809
4810     tcg_gen_andi_tl(t0, cpu_gpr[rS(ctx->opcode)], mask);
4811     tcg_gen_andi_tl(t1, cpu_msr, ~mask);
4812     tcg_gen_or_tl(t0, t0, t1);
4813
4814     gen_helper_store_msr(cpu_env, t0);
4815
4816     /* Must stop the translation as machine state (may have) changed */
4817     ctx->base.is_jmp = DISAS_EXIT_UPDATE;
4818 #endif /* !defined(CONFIG_USER_ONLY) */
4819 }
4820 #endif /* defined(TARGET_PPC64) */
4821
4822 static void gen_mtmsr(DisasContext *ctx)
4823 {
4824     CHK_SV(ctx);
4825
4826 #if !defined(CONFIG_USER_ONLY)
4827     TCGv t0, t1;
4828     target_ulong mask = 0xFFFFFFFF;
4829
4830     t0 = tcg_temp_new();
4831     t1 = tcg_temp_new();
4832
4833     translator_io_start(&ctx->base);
4834     if (ctx->opcode & 0x00010000) {
4835         /* L=1 form only updates EE and RI */
4836         mask &= (1ULL << MSR_RI) | (1ULL << MSR_EE);
4837     } else {
4838         /* mtmsr does not alter S, ME, or LE */
4839         mask &= ~((1ULL << MSR_LE) | (1ULL << MSR_ME) | (1ULL << MSR_S));
4840
4841         /*
4842          * XXX: we need to update nip before the store if we enter
4843          *      power saving mode, we will exit the loop directly from
4844          *      ppc_store_msr
4845          */
4846         gen_update_nip(ctx, ctx->base.pc_next);
4847     }
4848
4849     tcg_gen_andi_tl(t0, cpu_gpr[rS(ctx->opcode)], mask);
4850     tcg_gen_andi_tl(t1, cpu_msr, ~mask);
4851     tcg_gen_or_tl(t0, t0, t1);
4852
4853     gen_helper_store_msr(cpu_env, t0);
4854
4855     /* Must stop the translation as machine state (may have) changed */
4856     ctx->base.is_jmp = DISAS_EXIT_UPDATE;
4857 #endif
4858 }
4859
4860 /* mtspr */
4861 static void gen_mtspr(DisasContext *ctx)
4862 {
4863     void (*write_cb)(DisasContext *ctx, int sprn, int gprn);
4864     uint32_t sprn = SPR(ctx->opcode);
4865
4866 #if defined(CONFIG_USER_ONLY)
4867     write_cb = ctx->spr_cb[sprn].uea_write;
4868 #else
4869     if (ctx->pr) {
4870         write_cb = ctx->spr_cb[sprn].uea_write;
4871     } else if (ctx->hv) {
4872         write_cb = ctx->spr_cb[sprn].hea_write;
4873     } else {
4874         write_cb = ctx->spr_cb[sprn].oea_write;
4875     }
4876 #endif
4877     if (likely(write_cb != NULL)) {
4878         if (likely(write_cb != SPR_NOACCESS)) {
4879             (*write_cb)(ctx, sprn, rS(ctx->opcode));
4880         } else {
4881             /* Privilege exception */
4882             qemu_log_mask(LOG_GUEST_ERROR, "Trying to write privileged spr "
4883                           "%d (0x%03x) at " TARGET_FMT_lx "\n", sprn, sprn,
4884                           ctx->cia);
4885             gen_priv_exception(ctx, POWERPC_EXCP_PRIV_REG);
4886         }
4887     } else {
4888         /* ISA 2.07 defines these as no-ops */
4889         if ((ctx->insns_flags2 & PPC2_ISA207S) &&
4890             (sprn >= 808 && sprn <= 811)) {
4891             /* This is a nop */
4892             return;
4893         }
4894
4895         /* Not defined */
4896         qemu_log_mask(LOG_GUEST_ERROR,
4897                       "Trying to write invalid spr %d (0x%03x) at "
4898                       TARGET_FMT_lx "\n", sprn, sprn, ctx->cia);
4899
4900
4901         /*
4902          * The behaviour depends on MSR:PR and SPR# bit 0x10, it can
4903          * generate a priv, a hv emu or a no-op
4904          */
4905         if (sprn & 0x10) {
4906             if (ctx->pr) {
4907                 gen_priv_exception(ctx, POWERPC_EXCP_PRIV_REG);
4908             }
4909         } else {
4910             if (ctx->pr || sprn == 0) {
4911                 gen_hvpriv_exception(ctx, POWERPC_EXCP_PRIV_REG);
4912             }
4913         }
4914     }
4915 }
4916
4917 #if defined(TARGET_PPC64)
4918 /* setb */
4919 static void gen_setb(DisasContext *ctx)
4920 {
4921     TCGv_i32 t0 = tcg_temp_new_i32();
4922     TCGv_i32 t8 = tcg_constant_i32(8);
4923     TCGv_i32 tm1 = tcg_constant_i32(-1);
4924     int crf = crfS(ctx->opcode);
4925
4926     tcg_gen_setcondi_i32(TCG_COND_GEU, t0, cpu_crf[crf], 4);
4927     tcg_gen_movcond_i32(TCG_COND_GEU, t0, cpu_crf[crf], t8, tm1, t0);
4928     tcg_gen_ext_i32_tl(cpu_gpr[rD(ctx->opcode)], t0);
4929 }
4930 #endif
4931
4932 /***                         Cache management                              ***/
4933
4934 /* dcbf */
4935 static void gen_dcbf(DisasContext *ctx)
4936 {
4937     /* XXX: specification says this is treated as a load by the MMU */
4938     TCGv t0;
4939     gen_set_access_type(ctx, ACCESS_CACHE);
4940     t0 = tcg_temp_new();
4941     gen_addr_reg_index(ctx, t0);
4942     gen_qemu_ld8u(ctx, t0, t0);
4943 }
4944
4945 /* dcbfep (external PID dcbf) */
4946 static void gen_dcbfep(DisasContext *ctx)
4947 {
4948     /* XXX: specification says this is treated as a load by the MMU */
4949     TCGv t0;
4950     CHK_SV(ctx);
4951     gen_set_access_type(ctx, ACCESS_CACHE);
4952     t0 = tcg_temp_new();
4953     gen_addr_reg_index(ctx, t0);
4954     tcg_gen_qemu_ld_tl(t0, t0, PPC_TLB_EPID_LOAD, DEF_MEMOP(MO_UB));
4955 }
4956
4957 /* dcbi (Supervisor only) */
4958 static void gen_dcbi(DisasContext *ctx)
4959 {
4960 #if defined(CONFIG_USER_ONLY)
4961     GEN_PRIV(ctx);
4962 #else
4963     TCGv EA, val;
4964
4965     CHK_SV(ctx);
4966     EA = tcg_temp_new();
4967     gen_set_access_type(ctx, ACCESS_CACHE);
4968     gen_addr_reg_index(ctx, EA);
4969     val = tcg_temp_new();
4970     /* XXX: specification says this should be treated as a store by the MMU */
4971     gen_qemu_ld8u(ctx, val, EA);
4972     gen_qemu_st8(ctx, val, EA);
4973 #endif /* defined(CONFIG_USER_ONLY) */
4974 }
4975
4976 /* dcdst */
4977 static void gen_dcbst(DisasContext *ctx)
4978 {
4979     /* XXX: specification say this is treated as a load by the MMU */
4980     TCGv t0;
4981     gen_set_access_type(ctx, ACCESS_CACHE);
4982     t0 = tcg_temp_new();
4983     gen_addr_reg_index(ctx, t0);
4984     gen_qemu_ld8u(ctx, t0, t0);
4985 }
4986
4987 /* dcbstep (dcbstep External PID version) */
4988 static void gen_dcbstep(DisasContext *ctx)
4989 {
4990     /* XXX: specification say this is treated as a load by the MMU */
4991     TCGv t0;
4992     gen_set_access_type(ctx, ACCESS_CACHE);
4993     t0 = tcg_temp_new();
4994     gen_addr_reg_index(ctx, t0);
4995     tcg_gen_qemu_ld_tl(t0, t0, PPC_TLB_EPID_LOAD, DEF_MEMOP(MO_UB));
4996 }
4997
4998 /* dcbt */
4999 static void gen_dcbt(DisasContext *ctx)
5000 {
5001     /*
5002      * interpreted as no-op
5003      * XXX: specification say this is treated as a load by the MMU but
5004      *      does not generate any exception
5005      */
5006 }
5007
5008 /* dcbtep */
5009 static void gen_dcbtep(DisasContext *ctx)
5010 {
5011     /*
5012      * interpreted as no-op
5013      * XXX: specification say this is treated as a load by the MMU but
5014      *      does not generate any exception
5015      */
5016 }
5017
5018 /* dcbtst */
5019 static void gen_dcbtst(DisasContext *ctx)
5020 {
5021     /*
5022      * interpreted as no-op
5023      * XXX: specification say this is treated as a load by the MMU but
5024      *      does not generate any exception
5025      */
5026 }
5027
5028 /* dcbtstep */
5029 static void gen_dcbtstep(DisasContext *ctx)
5030 {
5031     /*
5032      * interpreted as no-op
5033      * XXX: specification say this is treated as a load by the MMU but
5034      *      does not generate any exception
5035      */
5036 }
5037
5038 /* dcbtls */
5039 static void gen_dcbtls(DisasContext *ctx)
5040 {
5041     /* Always fails locking the cache */
5042     TCGv t0 = tcg_temp_new();
5043     gen_load_spr(t0, SPR_Exxx_L1CSR0);
5044     tcg_gen_ori_tl(t0, t0, L1CSR0_CUL);
5045     gen_store_spr(SPR_Exxx_L1CSR0, t0);
5046 }
5047
5048 /* dcblc */
5049 static void gen_dcblc(DisasContext *ctx)
5050 {
5051     /*
5052      * interpreted as no-op
5053      */
5054 }
5055
5056 /* dcbz */
5057 static void gen_dcbz(DisasContext *ctx)
5058 {
5059     TCGv tcgv_addr;
5060     TCGv_i32 tcgv_op;
5061
5062     gen_set_access_type(ctx, ACCESS_CACHE);
5063     tcgv_addr = tcg_temp_new();
5064     tcgv_op = tcg_constant_i32(ctx->opcode & 0x03FF000);
5065     gen_addr_reg_index(ctx, tcgv_addr);
5066     gen_helper_dcbz(cpu_env, tcgv_addr, tcgv_op);
5067 }
5068
5069 /* dcbzep */
5070 static void gen_dcbzep(DisasContext *ctx)
5071 {
5072     TCGv tcgv_addr;
5073     TCGv_i32 tcgv_op;
5074
5075     gen_set_access_type(ctx, ACCESS_CACHE);
5076     tcgv_addr = tcg_temp_new();
5077     tcgv_op = tcg_constant_i32(ctx->opcode & 0x03FF000);
5078     gen_addr_reg_index(ctx, tcgv_addr);
5079     gen_helper_dcbzep(cpu_env, tcgv_addr, tcgv_op);
5080 }
5081
5082 /* dst / dstt */
5083 static void gen_dst(DisasContext *ctx)
5084 {
5085     if (rA(ctx->opcode) == 0) {
5086         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5087     } else {
5088         /* interpreted as no-op */
5089     }
5090 }
5091
5092 /* dstst /dststt */
5093 static void gen_dstst(DisasContext *ctx)
5094 {
5095     if (rA(ctx->opcode) == 0) {
5096         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5097     } else {
5098         /* interpreted as no-op */
5099     }
5100
5101 }
5102
5103 /* dss / dssall */
5104 static void gen_dss(DisasContext *ctx)
5105 {
5106     /* interpreted as no-op */
5107 }
5108
5109 /* icbi */
5110 static void gen_icbi(DisasContext *ctx)
5111 {
5112     TCGv t0;
5113     gen_set_access_type(ctx, ACCESS_CACHE);
5114     t0 = tcg_temp_new();
5115     gen_addr_reg_index(ctx, t0);
5116     gen_helper_icbi(cpu_env, t0);
5117 }
5118
5119 /* icbiep */
5120 static void gen_icbiep(DisasContext *ctx)
5121 {
5122     TCGv t0;
5123     gen_set_access_type(ctx, ACCESS_CACHE);
5124     t0 = tcg_temp_new();
5125     gen_addr_reg_index(ctx, t0);
5126     gen_helper_icbiep(cpu_env, t0);
5127 }
5128
5129 /* Optional: */
5130 /* dcba */
5131 static void gen_dcba(DisasContext *ctx)
5132 {
5133     /*
5134      * interpreted as no-op
5135      * XXX: specification say this is treated as a store by the MMU
5136      *      but does not generate any exception
5137      */
5138 }
5139
5140 /***                    Segment register manipulation                      ***/
5141 /* Supervisor only: */
5142
5143 /* mfsr */
5144 static void gen_mfsr(DisasContext *ctx)
5145 {
5146 #if defined(CONFIG_USER_ONLY)
5147     GEN_PRIV(ctx);
5148 #else
5149     TCGv t0;
5150
5151     CHK_SV(ctx);
5152     t0 = tcg_constant_tl(SR(ctx->opcode));
5153     gen_helper_load_sr(cpu_gpr[rD(ctx->opcode)], cpu_env, t0);
5154 #endif /* defined(CONFIG_USER_ONLY) */
5155 }
5156
5157 /* mfsrin */
5158 static void gen_mfsrin(DisasContext *ctx)
5159 {
5160 #if defined(CONFIG_USER_ONLY)
5161     GEN_PRIV(ctx);
5162 #else
5163     TCGv t0;
5164
5165     CHK_SV(ctx);
5166     t0 = tcg_temp_new();
5167     tcg_gen_extract_tl(t0, cpu_gpr[rB(ctx->opcode)], 28, 4);
5168     gen_helper_load_sr(cpu_gpr[rD(ctx->opcode)], cpu_env, t0);
5169 #endif /* defined(CONFIG_USER_ONLY) */
5170 }
5171
5172 /* mtsr */
5173 static void gen_mtsr(DisasContext *ctx)
5174 {
5175 #if defined(CONFIG_USER_ONLY)
5176     GEN_PRIV(ctx);
5177 #else
5178     TCGv t0;
5179
5180     CHK_SV(ctx);
5181     t0 = tcg_constant_tl(SR(ctx->opcode));
5182     gen_helper_store_sr(cpu_env, t0, cpu_gpr[rS(ctx->opcode)]);
5183 #endif /* defined(CONFIG_USER_ONLY) */
5184 }
5185
5186 /* mtsrin */
5187 static void gen_mtsrin(DisasContext *ctx)
5188 {
5189 #if defined(CONFIG_USER_ONLY)
5190     GEN_PRIV(ctx);
5191 #else
5192     TCGv t0;
5193     CHK_SV(ctx);
5194
5195     t0 = tcg_temp_new();
5196     tcg_gen_extract_tl(t0, cpu_gpr[rB(ctx->opcode)], 28, 4);
5197     gen_helper_store_sr(cpu_env, t0, cpu_gpr[rD(ctx->opcode)]);
5198 #endif /* defined(CONFIG_USER_ONLY) */
5199 }
5200
5201 #if defined(TARGET_PPC64)
5202 /* Specific implementation for PowerPC 64 "bridge" emulation using SLB */
5203
5204 /* mfsr */
5205 static void gen_mfsr_64b(DisasContext *ctx)
5206 {
5207 #if defined(CONFIG_USER_ONLY)
5208     GEN_PRIV(ctx);
5209 #else
5210     TCGv t0;
5211
5212     CHK_SV(ctx);
5213     t0 = tcg_constant_tl(SR(ctx->opcode));
5214     gen_helper_load_sr(cpu_gpr[rD(ctx->opcode)], cpu_env, t0);
5215 #endif /* defined(CONFIG_USER_ONLY) */
5216 }
5217
5218 /* mfsrin */
5219 static void gen_mfsrin_64b(DisasContext *ctx)
5220 {
5221 #if defined(CONFIG_USER_ONLY)
5222     GEN_PRIV(ctx);
5223 #else
5224     TCGv t0;
5225
5226     CHK_SV(ctx);
5227     t0 = tcg_temp_new();
5228     tcg_gen_extract_tl(t0, cpu_gpr[rB(ctx->opcode)], 28, 4);
5229     gen_helper_load_sr(cpu_gpr[rD(ctx->opcode)], cpu_env, t0);
5230 #endif /* defined(CONFIG_USER_ONLY) */
5231 }
5232
5233 /* mtsr */
5234 static void gen_mtsr_64b(DisasContext *ctx)
5235 {
5236 #if defined(CONFIG_USER_ONLY)
5237     GEN_PRIV(ctx);
5238 #else
5239     TCGv t0;
5240
5241     CHK_SV(ctx);
5242     t0 = tcg_constant_tl(SR(ctx->opcode));
5243     gen_helper_store_sr(cpu_env, t0, cpu_gpr[rS(ctx->opcode)]);
5244 #endif /* defined(CONFIG_USER_ONLY) */
5245 }
5246
5247 /* mtsrin */
5248 static void gen_mtsrin_64b(DisasContext *ctx)
5249 {
5250 #if defined(CONFIG_USER_ONLY)
5251     GEN_PRIV(ctx);
5252 #else
5253     TCGv t0;
5254
5255     CHK_SV(ctx);
5256     t0 = tcg_temp_new();
5257     tcg_gen_extract_tl(t0, cpu_gpr[rB(ctx->opcode)], 28, 4);
5258     gen_helper_store_sr(cpu_env, t0, cpu_gpr[rS(ctx->opcode)]);
5259 #endif /* defined(CONFIG_USER_ONLY) */
5260 }
5261
5262 #endif /* defined(TARGET_PPC64) */
5263
5264 /***                      Lookaside buffer management                      ***/
5265 /* Optional & supervisor only: */
5266
5267 /* tlbia */
5268 static void gen_tlbia(DisasContext *ctx)
5269 {
5270 #if defined(CONFIG_USER_ONLY)
5271     GEN_PRIV(ctx);
5272 #else
5273     CHK_HV(ctx);
5274
5275     gen_helper_tlbia(cpu_env);
5276 #endif  /* defined(CONFIG_USER_ONLY) */
5277 }
5278
5279 /* tlbsync */
5280 static void gen_tlbsync(DisasContext *ctx)
5281 {
5282 #if defined(CONFIG_USER_ONLY)
5283     GEN_PRIV(ctx);
5284 #else
5285
5286     if (ctx->gtse) {
5287         CHK_SV(ctx); /* If gtse is set then tlbsync is supervisor privileged */
5288     } else {
5289         CHK_HV(ctx); /* Else hypervisor privileged */
5290     }
5291
5292     /* BookS does both ptesync and tlbsync make tlbsync a nop for server */
5293     if (ctx->insns_flags & PPC_BOOKE) {
5294         gen_check_tlb_flush(ctx, true);
5295     }
5296 #endif /* defined(CONFIG_USER_ONLY) */
5297 }
5298
5299 /***                              External control                         ***/
5300 /* Optional: */
5301
5302 /* eciwx */
5303 static void gen_eciwx(DisasContext *ctx)
5304 {
5305     TCGv t0;
5306     /* Should check EAR[E] ! */
5307     gen_set_access_type(ctx, ACCESS_EXT);
5308     t0 = tcg_temp_new();
5309     gen_addr_reg_index(ctx, t0);
5310     tcg_gen_qemu_ld_tl(cpu_gpr[rD(ctx->opcode)], t0, ctx->mem_idx,
5311                        DEF_MEMOP(MO_UL | MO_ALIGN));
5312 }
5313
5314 /* ecowx */
5315 static void gen_ecowx(DisasContext *ctx)
5316 {
5317     TCGv t0;
5318     /* Should check EAR[E] ! */
5319     gen_set_access_type(ctx, ACCESS_EXT);
5320     t0 = tcg_temp_new();
5321     gen_addr_reg_index(ctx, t0);
5322     tcg_gen_qemu_st_tl(cpu_gpr[rD(ctx->opcode)], t0, ctx->mem_idx,
5323                        DEF_MEMOP(MO_UL | MO_ALIGN));
5324 }
5325
5326 /* 602 - 603 - G2 TLB management */
5327
5328 /* tlbld */
5329 static void gen_tlbld_6xx(DisasContext *ctx)
5330 {
5331 #if defined(CONFIG_USER_ONLY)
5332     GEN_PRIV(ctx);
5333 #else
5334     CHK_SV(ctx);
5335     gen_helper_6xx_tlbd(cpu_env, cpu_gpr[rB(ctx->opcode)]);
5336 #endif /* defined(CONFIG_USER_ONLY) */
5337 }
5338
5339 /* tlbli */
5340 static void gen_tlbli_6xx(DisasContext *ctx)
5341 {
5342 #if defined(CONFIG_USER_ONLY)
5343     GEN_PRIV(ctx);
5344 #else
5345     CHK_SV(ctx);
5346     gen_helper_6xx_tlbi(cpu_env, cpu_gpr[rB(ctx->opcode)]);
5347 #endif /* defined(CONFIG_USER_ONLY) */
5348 }
5349
5350 /* BookE specific instructions */
5351
5352 /* XXX: not implemented on 440 ? */
5353 static void gen_mfapidi(DisasContext *ctx)
5354 {
5355     /* XXX: TODO */
5356     gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5357 }
5358
5359 /* XXX: not implemented on 440 ? */
5360 static void gen_tlbiva(DisasContext *ctx)
5361 {
5362 #if defined(CONFIG_USER_ONLY)
5363     GEN_PRIV(ctx);
5364 #else
5365     TCGv t0;
5366
5367     CHK_SV(ctx);
5368     t0 = tcg_temp_new();
5369     gen_addr_reg_index(ctx, t0);
5370     gen_helper_tlbiva(cpu_env, cpu_gpr[rB(ctx->opcode)]);
5371 #endif /* defined(CONFIG_USER_ONLY) */
5372 }
5373
5374 /* All 405 MAC instructions are translated here */
5375 static inline void gen_405_mulladd_insn(DisasContext *ctx, int opc2, int opc3,
5376                                         int ra, int rb, int rt, int Rc)
5377 {
5378     TCGv t0, t1;
5379
5380     t0 = tcg_temp_new();
5381     t1 = tcg_temp_new();
5382
5383     switch (opc3 & 0x0D) {
5384     case 0x05:
5385         /* macchw    - macchw.    - macchwo   - macchwo.   */
5386         /* macchws   - macchws.   - macchwso  - macchwso.  */
5387         /* nmacchw   - nmacchw.   - nmacchwo  - nmacchwo.  */
5388         /* nmacchws  - nmacchws.  - nmacchwso - nmacchwso. */
5389         /* mulchw - mulchw. */
5390         tcg_gen_ext16s_tl(t0, cpu_gpr[ra]);
5391         tcg_gen_sari_tl(t1, cpu_gpr[rb], 16);
5392         tcg_gen_ext16s_tl(t1, t1);
5393         break;
5394     case 0x04:
5395         /* macchwu   - macchwu.   - macchwuo  - macchwuo.  */
5396         /* macchwsu  - macchwsu.  - macchwsuo - macchwsuo. */
5397         /* mulchwu - mulchwu. */
5398         tcg_gen_ext16u_tl(t0, cpu_gpr[ra]);
5399         tcg_gen_shri_tl(t1, cpu_gpr[rb], 16);
5400         tcg_gen_ext16u_tl(t1, t1);
5401         break;
5402     case 0x01:
5403         /* machhw    - machhw.    - machhwo   - machhwo.   */
5404         /* machhws   - machhws.   - machhwso  - machhwso.  */
5405         /* nmachhw   - nmachhw.   - nmachhwo  - nmachhwo.  */
5406         /* nmachhws  - nmachhws.  - nmachhwso - nmachhwso. */
5407         /* mulhhw - mulhhw. */
5408         tcg_gen_sari_tl(t0, cpu_gpr[ra], 16);
5409         tcg_gen_ext16s_tl(t0, t0);
5410         tcg_gen_sari_tl(t1, cpu_gpr[rb], 16);
5411         tcg_gen_ext16s_tl(t1, t1);
5412         break;
5413     case 0x00:
5414         /* machhwu   - machhwu.   - machhwuo  - machhwuo.  */
5415         /* machhwsu  - machhwsu.  - machhwsuo - machhwsuo. */
5416         /* mulhhwu - mulhhwu. */
5417         tcg_gen_shri_tl(t0, cpu_gpr[ra], 16);
5418         tcg_gen_ext16u_tl(t0, t0);
5419         tcg_gen_shri_tl(t1, cpu_gpr[rb], 16);
5420         tcg_gen_ext16u_tl(t1, t1);
5421         break;
5422     case 0x0D:
5423         /* maclhw    - maclhw.    - maclhwo   - maclhwo.   */
5424         /* maclhws   - maclhws.   - maclhwso  - maclhwso.  */
5425         /* nmaclhw   - nmaclhw.   - nmaclhwo  - nmaclhwo.  */
5426         /* nmaclhws  - nmaclhws.  - nmaclhwso - nmaclhwso. */
5427         /* mullhw - mullhw. */
5428         tcg_gen_ext16s_tl(t0, cpu_gpr[ra]);
5429         tcg_gen_ext16s_tl(t1, cpu_gpr[rb]);
5430         break;
5431     case 0x0C:
5432         /* maclhwu   - maclhwu.   - maclhwuo  - maclhwuo.  */
5433         /* maclhwsu  - maclhwsu.  - maclhwsuo - maclhwsuo. */
5434         /* mullhwu - mullhwu. */
5435         tcg_gen_ext16u_tl(t0, cpu_gpr[ra]);
5436         tcg_gen_ext16u_tl(t1, cpu_gpr[rb]);
5437         break;
5438     }
5439     if (opc2 & 0x04) {
5440         /* (n)multiply-and-accumulate (0x0C / 0x0E) */
5441         tcg_gen_mul_tl(t1, t0, t1);
5442         if (opc2 & 0x02) {
5443             /* nmultiply-and-accumulate (0x0E) */
5444             tcg_gen_sub_tl(t0, cpu_gpr[rt], t1);
5445         } else {
5446             /* multiply-and-accumulate (0x0C) */
5447             tcg_gen_add_tl(t0, cpu_gpr[rt], t1);
5448         }
5449
5450         if (opc3 & 0x12) {
5451             /* Check overflow and/or saturate */
5452             TCGLabel *l1 = gen_new_label();
5453
5454             if (opc3 & 0x10) {
5455                 /* Start with XER OV disabled, the most likely case */
5456                 tcg_gen_movi_tl(cpu_ov, 0);
5457             }
5458             if (opc3 & 0x01) {
5459                 /* Signed */
5460                 tcg_gen_xor_tl(t1, cpu_gpr[rt], t1);
5461                 tcg_gen_brcondi_tl(TCG_COND_GE, t1, 0, l1);
5462                 tcg_gen_xor_tl(t1, cpu_gpr[rt], t0);
5463                 tcg_gen_brcondi_tl(TCG_COND_LT, t1, 0, l1);
5464                 if (opc3 & 0x02) {
5465                     /* Saturate */
5466                     tcg_gen_sari_tl(t0, cpu_gpr[rt], 31);
5467                     tcg_gen_xori_tl(t0, t0, 0x7fffffff);
5468                 }
5469             } else {
5470                 /* Unsigned */
5471                 tcg_gen_brcond_tl(TCG_COND_GEU, t0, t1, l1);
5472                 if (opc3 & 0x02) {
5473                     /* Saturate */
5474                     tcg_gen_movi_tl(t0, UINT32_MAX);
5475                 }
5476             }
5477             if (opc3 & 0x10) {
5478                 /* Check overflow */
5479                 tcg_gen_movi_tl(cpu_ov, 1);
5480                 tcg_gen_movi_tl(cpu_so, 1);
5481             }
5482             gen_set_label(l1);
5483             tcg_gen_mov_tl(cpu_gpr[rt], t0);
5484         }
5485     } else {
5486         tcg_gen_mul_tl(cpu_gpr[rt], t0, t1);
5487     }
5488     if (unlikely(Rc) != 0) {
5489         /* Update Rc0 */
5490         gen_set_Rc0(ctx, cpu_gpr[rt]);
5491     }
5492 }
5493
5494 #define GEN_MAC_HANDLER(name, opc2, opc3)                                     \
5495 static void glue(gen_, name)(DisasContext *ctx)                               \
5496 {                                                                             \
5497     gen_405_mulladd_insn(ctx, opc2, opc3, rA(ctx->opcode), rB(ctx->opcode),   \
5498                          rD(ctx->opcode), Rc(ctx->opcode));                   \
5499 }
5500
5501 /* macchw    - macchw.    */
5502 GEN_MAC_HANDLER(macchw, 0x0C, 0x05);
5503 /* macchwo   - macchwo.   */
5504 GEN_MAC_HANDLER(macchwo, 0x0C, 0x15);
5505 /* macchws   - macchws.   */
5506 GEN_MAC_HANDLER(macchws, 0x0C, 0x07);
5507 /* macchwso  - macchwso.  */
5508 GEN_MAC_HANDLER(macchwso, 0x0C, 0x17);
5509 /* macchwsu  - macchwsu.  */
5510 GEN_MAC_HANDLER(macchwsu, 0x0C, 0x06);
5511 /* macchwsuo - macchwsuo. */
5512 GEN_MAC_HANDLER(macchwsuo, 0x0C, 0x16);
5513 /* macchwu   - macchwu.   */
5514 GEN_MAC_HANDLER(macchwu, 0x0C, 0x04);
5515 /* macchwuo  - macchwuo.  */
5516 GEN_MAC_HANDLER(macchwuo, 0x0C, 0x14);
5517 /* machhw    - machhw.    */
5518 GEN_MAC_HANDLER(machhw, 0x0C, 0x01);
5519 /* machhwo   - machhwo.   */
5520 GEN_MAC_HANDLER(machhwo, 0x0C, 0x11);
5521 /* machhws   - machhws.   */
5522 GEN_MAC_HANDLER(machhws, 0x0C, 0x03);
5523 /* machhwso  - machhwso.  */
5524 GEN_MAC_HANDLER(machhwso, 0x0C, 0x13);
5525 /* machhwsu  - machhwsu.  */
5526 GEN_MAC_HANDLER(machhwsu, 0x0C, 0x02);
5527 /* machhwsuo - machhwsuo. */
5528 GEN_MAC_HANDLER(machhwsuo, 0x0C, 0x12);
5529 /* machhwu   - machhwu.   */
5530 GEN_MAC_HANDLER(machhwu, 0x0C, 0x00);
5531 /* machhwuo  - machhwuo.  */
5532 GEN_MAC_HANDLER(machhwuo, 0x0C, 0x10);
5533 /* maclhw    - maclhw.    */
5534 GEN_MAC_HANDLER(maclhw, 0x0C, 0x0D);
5535 /* maclhwo   - maclhwo.   */
5536 GEN_MAC_HANDLER(maclhwo, 0x0C, 0x1D);
5537 /* maclhws   - maclhws.   */
5538 GEN_MAC_HANDLER(maclhws, 0x0C, 0x0F);
5539 /* maclhwso  - maclhwso.  */
5540 GEN_MAC_HANDLER(maclhwso, 0x0C, 0x1F);
5541 /* maclhwu   - maclhwu.   */
5542 GEN_MAC_HANDLER(maclhwu, 0x0C, 0x0C);
5543 /* maclhwuo  - maclhwuo.  */
5544 GEN_MAC_HANDLER(maclhwuo, 0x0C, 0x1C);
5545 /* maclhwsu  - maclhwsu.  */
5546 GEN_MAC_HANDLER(maclhwsu, 0x0C, 0x0E);
5547 /* maclhwsuo - maclhwsuo. */
5548 GEN_MAC_HANDLER(maclhwsuo, 0x0C, 0x1E);
5549 /* nmacchw   - nmacchw.   */
5550 GEN_MAC_HANDLER(nmacchw, 0x0E, 0x05);
5551 /* nmacchwo  - nmacchwo.  */
5552 GEN_MAC_HANDLER(nmacchwo, 0x0E, 0x15);
5553 /* nmacchws  - nmacchws.  */
5554 GEN_MAC_HANDLER(nmacchws, 0x0E, 0x07);
5555 /* nmacchwso - nmacchwso. */
5556 GEN_MAC_HANDLER(nmacchwso, 0x0E, 0x17);
5557 /* nmachhw   - nmachhw.   */
5558 GEN_MAC_HANDLER(nmachhw, 0x0E, 0x01);
5559 /* nmachhwo  - nmachhwo.  */
5560 GEN_MAC_HANDLER(nmachhwo, 0x0E, 0x11);
5561 /* nmachhws  - nmachhws.  */
5562 GEN_MAC_HANDLER(nmachhws, 0x0E, 0x03);
5563 /* nmachhwso - nmachhwso. */
5564 GEN_MAC_HANDLER(nmachhwso, 0x0E, 0x13);
5565 /* nmaclhw   - nmaclhw.   */
5566 GEN_MAC_HANDLER(nmaclhw, 0x0E, 0x0D);
5567 /* nmaclhwo  - nmaclhwo.  */
5568 GEN_MAC_HANDLER(nmaclhwo, 0x0E, 0x1D);
5569 /* nmaclhws  - nmaclhws.  */
5570 GEN_MAC_HANDLER(nmaclhws, 0x0E, 0x0F);
5571 /* nmaclhwso - nmaclhwso. */
5572 GEN_MAC_HANDLER(nmaclhwso, 0x0E, 0x1F);
5573
5574 /* mulchw  - mulchw.  */
5575 GEN_MAC_HANDLER(mulchw, 0x08, 0x05);
5576 /* mulchwu - mulchwu. */
5577 GEN_MAC_HANDLER(mulchwu, 0x08, 0x04);
5578 /* mulhhw  - mulhhw.  */
5579 GEN_MAC_HANDLER(mulhhw, 0x08, 0x01);
5580 /* mulhhwu - mulhhwu. */
5581 GEN_MAC_HANDLER(mulhhwu, 0x08, 0x00);
5582 /* mullhw  - mullhw.  */
5583 GEN_MAC_HANDLER(mullhw, 0x08, 0x0D);
5584 /* mullhwu - mullhwu. */
5585 GEN_MAC_HANDLER(mullhwu, 0x08, 0x0C);
5586
5587 /* mfdcr */
5588 static void gen_mfdcr(DisasContext *ctx)
5589 {
5590 #if defined(CONFIG_USER_ONLY)
5591     GEN_PRIV(ctx);
5592 #else
5593     TCGv dcrn;
5594
5595     CHK_SV(ctx);
5596     dcrn = tcg_constant_tl(SPR(ctx->opcode));
5597     gen_helper_load_dcr(cpu_gpr[rD(ctx->opcode)], cpu_env, dcrn);
5598 #endif /* defined(CONFIG_USER_ONLY) */
5599 }
5600
5601 /* mtdcr */
5602 static void gen_mtdcr(DisasContext *ctx)
5603 {
5604 #if defined(CONFIG_USER_ONLY)
5605     GEN_PRIV(ctx);
5606 #else
5607     TCGv dcrn;
5608
5609     CHK_SV(ctx);
5610     dcrn = tcg_constant_tl(SPR(ctx->opcode));
5611     gen_helper_store_dcr(cpu_env, dcrn, cpu_gpr[rS(ctx->opcode)]);
5612 #endif /* defined(CONFIG_USER_ONLY) */
5613 }
5614
5615 /* mfdcrx */
5616 /* XXX: not implemented on 440 ? */
5617 static void gen_mfdcrx(DisasContext *ctx)
5618 {
5619 #if defined(CONFIG_USER_ONLY)
5620     GEN_PRIV(ctx);
5621 #else
5622     CHK_SV(ctx);
5623     gen_helper_load_dcr(cpu_gpr[rD(ctx->opcode)], cpu_env,
5624                         cpu_gpr[rA(ctx->opcode)]);
5625     /* Note: Rc update flag set leads to undefined state of Rc0 */
5626 #endif /* defined(CONFIG_USER_ONLY) */
5627 }
5628
5629 /* mtdcrx */
5630 /* XXX: not implemented on 440 ? */
5631 static void gen_mtdcrx(DisasContext *ctx)
5632 {
5633 #if defined(CONFIG_USER_ONLY)
5634     GEN_PRIV(ctx);
5635 #else
5636     CHK_SV(ctx);
5637     gen_helper_store_dcr(cpu_env, cpu_gpr[rA(ctx->opcode)],
5638                          cpu_gpr[rS(ctx->opcode)]);
5639     /* Note: Rc update flag set leads to undefined state of Rc0 */
5640 #endif /* defined(CONFIG_USER_ONLY) */
5641 }
5642
5643 /* dccci */
5644 static void gen_dccci(DisasContext *ctx)
5645 {
5646     CHK_SV(ctx);
5647     /* interpreted as no-op */
5648 }
5649
5650 /* dcread */
5651 static void gen_dcread(DisasContext *ctx)
5652 {
5653 #if defined(CONFIG_USER_ONLY)
5654     GEN_PRIV(ctx);
5655 #else
5656     TCGv EA, val;
5657
5658     CHK_SV(ctx);
5659     gen_set_access_type(ctx, ACCESS_CACHE);
5660     EA = tcg_temp_new();
5661     gen_addr_reg_index(ctx, EA);
5662     val = tcg_temp_new();
5663     gen_qemu_ld32u(ctx, val, EA);
5664     tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], EA);
5665 #endif /* defined(CONFIG_USER_ONLY) */
5666 }
5667
5668 /* icbt */
5669 static void gen_icbt_40x(DisasContext *ctx)
5670 {
5671     /*
5672      * interpreted as no-op
5673      * XXX: specification say this is treated as a load by the MMU but
5674      *      does not generate any exception
5675      */
5676 }
5677
5678 /* iccci */
5679 static void gen_iccci(DisasContext *ctx)
5680 {
5681     CHK_SV(ctx);
5682     /* interpreted as no-op */
5683 }
5684
5685 /* icread */
5686 static void gen_icread(DisasContext *ctx)
5687 {
5688     CHK_SV(ctx);
5689     /* interpreted as no-op */
5690 }
5691
5692 /* rfci (supervisor only) */
5693 static void gen_rfci_40x(DisasContext *ctx)
5694 {
5695 #if defined(CONFIG_USER_ONLY)
5696     GEN_PRIV(ctx);
5697 #else
5698     CHK_SV(ctx);
5699     /* Restore CPU state */
5700     gen_helper_40x_rfci(cpu_env);
5701     ctx->base.is_jmp = DISAS_EXIT;
5702 #endif /* defined(CONFIG_USER_ONLY) */
5703 }
5704
5705 static void gen_rfci(DisasContext *ctx)
5706 {
5707 #if defined(CONFIG_USER_ONLY)
5708     GEN_PRIV(ctx);
5709 #else
5710     CHK_SV(ctx);
5711     /* Restore CPU state */
5712     gen_helper_rfci(cpu_env);
5713     ctx->base.is_jmp = DISAS_EXIT;
5714 #endif /* defined(CONFIG_USER_ONLY) */
5715 }
5716
5717 /* BookE specific */
5718
5719 /* XXX: not implemented on 440 ? */
5720 static void gen_rfdi(DisasContext *ctx)
5721 {
5722 #if defined(CONFIG_USER_ONLY)
5723     GEN_PRIV(ctx);
5724 #else
5725     CHK_SV(ctx);
5726     /* Restore CPU state */
5727     gen_helper_rfdi(cpu_env);
5728     ctx->base.is_jmp = DISAS_EXIT;
5729 #endif /* defined(CONFIG_USER_ONLY) */
5730 }
5731
5732 /* XXX: not implemented on 440 ? */
5733 static void gen_rfmci(DisasContext *ctx)
5734 {
5735 #if defined(CONFIG_USER_ONLY)
5736     GEN_PRIV(ctx);
5737 #else
5738     CHK_SV(ctx);
5739     /* Restore CPU state */
5740     gen_helper_rfmci(cpu_env);
5741     ctx->base.is_jmp = DISAS_EXIT;
5742 #endif /* defined(CONFIG_USER_ONLY) */
5743 }
5744
5745 /* TLB management - PowerPC 405 implementation */
5746
5747 /* tlbre */
5748 static void gen_tlbre_40x(DisasContext *ctx)
5749 {
5750 #if defined(CONFIG_USER_ONLY)
5751     GEN_PRIV(ctx);
5752 #else
5753     CHK_SV(ctx);
5754     switch (rB(ctx->opcode)) {
5755     case 0:
5756         gen_helper_4xx_tlbre_hi(cpu_gpr[rD(ctx->opcode)], cpu_env,
5757                                 cpu_gpr[rA(ctx->opcode)]);
5758         break;
5759     case 1:
5760         gen_helper_4xx_tlbre_lo(cpu_gpr[rD(ctx->opcode)], cpu_env,
5761                                 cpu_gpr[rA(ctx->opcode)]);
5762         break;
5763     default:
5764         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5765         break;
5766     }
5767 #endif /* defined(CONFIG_USER_ONLY) */
5768 }
5769
5770 /* tlbsx - tlbsx. */
5771 static void gen_tlbsx_40x(DisasContext *ctx)
5772 {
5773 #if defined(CONFIG_USER_ONLY)
5774     GEN_PRIV(ctx);
5775 #else
5776     TCGv t0;
5777
5778     CHK_SV(ctx);
5779     t0 = tcg_temp_new();
5780     gen_addr_reg_index(ctx, t0);
5781     gen_helper_4xx_tlbsx(cpu_gpr[rD(ctx->opcode)], cpu_env, t0);
5782     if (Rc(ctx->opcode)) {
5783         TCGLabel *l1 = gen_new_label();
5784         tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_so);
5785         tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr[rD(ctx->opcode)], -1, l1);
5786         tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 0x02);
5787         gen_set_label(l1);
5788     }
5789 #endif /* defined(CONFIG_USER_ONLY) */
5790 }
5791
5792 /* tlbwe */
5793 static void gen_tlbwe_40x(DisasContext *ctx)
5794 {
5795 #if defined(CONFIG_USER_ONLY)
5796     GEN_PRIV(ctx);
5797 #else
5798     CHK_SV(ctx);
5799
5800     switch (rB(ctx->opcode)) {
5801     case 0:
5802         gen_helper_4xx_tlbwe_hi(cpu_env, cpu_gpr[rA(ctx->opcode)],
5803                                 cpu_gpr[rS(ctx->opcode)]);
5804         break;
5805     case 1:
5806         gen_helper_4xx_tlbwe_lo(cpu_env, cpu_gpr[rA(ctx->opcode)],
5807                                 cpu_gpr[rS(ctx->opcode)]);
5808         break;
5809     default:
5810         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5811         break;
5812     }
5813 #endif /* defined(CONFIG_USER_ONLY) */
5814 }
5815
5816 /* TLB management - PowerPC 440 implementation */
5817
5818 /* tlbre */
5819 static void gen_tlbre_440(DisasContext *ctx)
5820 {
5821 #if defined(CONFIG_USER_ONLY)
5822     GEN_PRIV(ctx);
5823 #else
5824     CHK_SV(ctx);
5825
5826     switch (rB(ctx->opcode)) {
5827     case 0:
5828     case 1:
5829     case 2:
5830         {
5831             TCGv_i32 t0 = tcg_constant_i32(rB(ctx->opcode));
5832             gen_helper_440_tlbre(cpu_gpr[rD(ctx->opcode)], cpu_env,
5833                                  t0, cpu_gpr[rA(ctx->opcode)]);
5834         }
5835         break;
5836     default:
5837         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5838         break;
5839     }
5840 #endif /* defined(CONFIG_USER_ONLY) */
5841 }
5842
5843 /* tlbsx - tlbsx. */
5844 static void gen_tlbsx_440(DisasContext *ctx)
5845 {
5846 #if defined(CONFIG_USER_ONLY)
5847     GEN_PRIV(ctx);
5848 #else
5849     TCGv t0;
5850
5851     CHK_SV(ctx);
5852     t0 = tcg_temp_new();
5853     gen_addr_reg_index(ctx, t0);
5854     gen_helper_440_tlbsx(cpu_gpr[rD(ctx->opcode)], cpu_env, t0);
5855     if (Rc(ctx->opcode)) {
5856         TCGLabel *l1 = gen_new_label();
5857         tcg_gen_trunc_tl_i32(cpu_crf[0], cpu_so);
5858         tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_gpr[rD(ctx->opcode)], -1, l1);
5859         tcg_gen_ori_i32(cpu_crf[0], cpu_crf[0], 0x02);
5860         gen_set_label(l1);
5861     }
5862 #endif /* defined(CONFIG_USER_ONLY) */
5863 }
5864
5865 /* tlbwe */
5866 static void gen_tlbwe_440(DisasContext *ctx)
5867 {
5868 #if defined(CONFIG_USER_ONLY)
5869     GEN_PRIV(ctx);
5870 #else
5871     CHK_SV(ctx);
5872     switch (rB(ctx->opcode)) {
5873     case 0:
5874     case 1:
5875     case 2:
5876         {
5877             TCGv_i32 t0 = tcg_constant_i32(rB(ctx->opcode));
5878             gen_helper_440_tlbwe(cpu_env, t0, cpu_gpr[rA(ctx->opcode)],
5879                                  cpu_gpr[rS(ctx->opcode)]);
5880         }
5881         break;
5882     default:
5883         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5884         break;
5885     }
5886 #endif /* defined(CONFIG_USER_ONLY) */
5887 }
5888
5889 /* TLB management - PowerPC BookE 2.06 implementation */
5890
5891 /* tlbre */
5892 static void gen_tlbre_booke206(DisasContext *ctx)
5893 {
5894  #if defined(CONFIG_USER_ONLY)
5895     GEN_PRIV(ctx);
5896 #else
5897    CHK_SV(ctx);
5898     gen_helper_booke206_tlbre(cpu_env);
5899 #endif /* defined(CONFIG_USER_ONLY) */
5900 }
5901
5902 /* tlbsx - tlbsx. */
5903 static void gen_tlbsx_booke206(DisasContext *ctx)
5904 {
5905 #if defined(CONFIG_USER_ONLY)
5906     GEN_PRIV(ctx);
5907 #else
5908     TCGv t0;
5909
5910     CHK_SV(ctx);
5911     if (rA(ctx->opcode)) {
5912         t0 = tcg_temp_new();
5913         tcg_gen_add_tl(t0, cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
5914     } else {
5915         t0 = cpu_gpr[rB(ctx->opcode)];
5916     }
5917     gen_helper_booke206_tlbsx(cpu_env, t0);
5918 #endif /* defined(CONFIG_USER_ONLY) */
5919 }
5920
5921 /* tlbwe */
5922 static void gen_tlbwe_booke206(DisasContext *ctx)
5923 {
5924 #if defined(CONFIG_USER_ONLY)
5925     GEN_PRIV(ctx);
5926 #else
5927     CHK_SV(ctx);
5928     gen_helper_booke206_tlbwe(cpu_env);
5929 #endif /* defined(CONFIG_USER_ONLY) */
5930 }
5931
5932 static void gen_tlbivax_booke206(DisasContext *ctx)
5933 {
5934 #if defined(CONFIG_USER_ONLY)
5935     GEN_PRIV(ctx);
5936 #else
5937     TCGv t0;
5938
5939     CHK_SV(ctx);
5940     t0 = tcg_temp_new();
5941     gen_addr_reg_index(ctx, t0);
5942     gen_helper_booke206_tlbivax(cpu_env, t0);
5943 #endif /* defined(CONFIG_USER_ONLY) */
5944 }
5945
5946 static void gen_tlbilx_booke206(DisasContext *ctx)
5947 {
5948 #if defined(CONFIG_USER_ONLY)
5949     GEN_PRIV(ctx);
5950 #else
5951     TCGv t0;
5952
5953     CHK_SV(ctx);
5954     t0 = tcg_temp_new();
5955     gen_addr_reg_index(ctx, t0);
5956
5957     switch ((ctx->opcode >> 21) & 0x3) {
5958     case 0:
5959         gen_helper_booke206_tlbilx0(cpu_env, t0);
5960         break;
5961     case 1:
5962         gen_helper_booke206_tlbilx1(cpu_env, t0);
5963         break;
5964     case 3:
5965         gen_helper_booke206_tlbilx3(cpu_env, t0);
5966         break;
5967     default:
5968         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
5969         break;
5970     }
5971 #endif /* defined(CONFIG_USER_ONLY) */
5972 }
5973
5974 /* wrtee */
5975 static void gen_wrtee(DisasContext *ctx)
5976 {
5977 #if defined(CONFIG_USER_ONLY)
5978     GEN_PRIV(ctx);
5979 #else
5980     TCGv t0;
5981
5982     CHK_SV(ctx);
5983     t0 = tcg_temp_new();
5984     tcg_gen_andi_tl(t0, cpu_gpr[rD(ctx->opcode)], (1 << MSR_EE));
5985     tcg_gen_andi_tl(cpu_msr, cpu_msr, ~(1 << MSR_EE));
5986     tcg_gen_or_tl(cpu_msr, cpu_msr, t0);
5987     gen_ppc_maybe_interrupt(ctx);
5988     /*
5989      * Stop translation to have a chance to raise an exception if we
5990      * just set msr_ee to 1
5991      */
5992     ctx->base.is_jmp = DISAS_EXIT_UPDATE;
5993 #endif /* defined(CONFIG_USER_ONLY) */
5994 }
5995
5996 /* wrteei */
5997 static void gen_wrteei(DisasContext *ctx)
5998 {
5999 #if defined(CONFIG_USER_ONLY)
6000     GEN_PRIV(ctx);
6001 #else
6002     CHK_SV(ctx);
6003     if (ctx->opcode & 0x00008000) {
6004         tcg_gen_ori_tl(cpu_msr, cpu_msr, (1 << MSR_EE));
6005         gen_ppc_maybe_interrupt(ctx);
6006         /* Stop translation to have a chance to raise an exception */
6007         ctx->base.is_jmp = DISAS_EXIT_UPDATE;
6008     } else {
6009         tcg_gen_andi_tl(cpu_msr, cpu_msr, ~(1 << MSR_EE));
6010     }
6011 #endif /* defined(CONFIG_USER_ONLY) */
6012 }
6013
6014 /* PowerPC 440 specific instructions */
6015
6016 /* dlmzb */
6017 static void gen_dlmzb(DisasContext *ctx)
6018 {
6019     TCGv_i32 t0 = tcg_constant_i32(Rc(ctx->opcode));
6020     gen_helper_dlmzb(cpu_gpr[rA(ctx->opcode)], cpu_env,
6021                      cpu_gpr[rS(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], t0);
6022 }
6023
6024 /* mbar replaces eieio on 440 */
6025 static void gen_mbar(DisasContext *ctx)
6026 {
6027     /* interpreted as no-op */
6028 }
6029
6030 /* msync replaces sync on 440 */
6031 static void gen_msync_4xx(DisasContext *ctx)
6032 {
6033     /* Only e500 seems to treat reserved bits as invalid */
6034     if ((ctx->insns_flags2 & PPC2_BOOKE206) &&
6035         (ctx->opcode & 0x03FFF801)) {
6036         gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL);
6037     }
6038     /* otherwise interpreted as no-op */
6039 }
6040
6041 /* icbt */
6042 static void gen_icbt_440(DisasContext *ctx)
6043 {
6044     /*
6045      * interpreted as no-op
6046      * XXX: specification say this is treated as a load by the MMU but
6047      *      does not generate any exception
6048      */
6049 }
6050
6051 #if defined(TARGET_PPC64)
6052 static void gen_maddld(DisasContext *ctx)
6053 {
6054     TCGv_i64 t1 = tcg_temp_new_i64();
6055
6056     tcg_gen_mul_i64(t1, cpu_gpr[rA(ctx->opcode)], cpu_gpr[rB(ctx->opcode)]);
6057     tcg_gen_add_i64(cpu_gpr[rD(ctx->opcode)], t1, cpu_gpr[rC(ctx->opcode)]);
6058 }
6059
6060 /* maddhd maddhdu */
6061 static void gen_maddhd_maddhdu(DisasContext *ctx)
6062 {
6063     TCGv_i64 lo = tcg_temp_new_i64();
6064     TCGv_i64 hi = tcg_temp_new_i64();
6065     TCGv_i64 t1 = tcg_temp_new_i64();
6066
6067     if (Rc(ctx->opcode)) {
6068         tcg_gen_mulu2_i64(lo, hi, cpu_gpr[rA(ctx->opcode)],
6069                           cpu_gpr[rB(ctx->opcode)]);
6070         tcg_gen_movi_i64(t1, 0);
6071     } else {
6072         tcg_gen_muls2_i64(lo, hi, cpu_gpr[rA(ctx->opcode)],
6073                           cpu_gpr[rB(ctx->opcode)]);
6074         tcg_gen_sari_i64(t1, cpu_gpr[rC(ctx->opcode)], 63);
6075     }
6076     tcg_gen_add2_i64(t1, cpu_gpr[rD(ctx->opcode)], lo, hi,
6077                      cpu_gpr[rC(ctx->opcode)], t1);
6078 }
6079 #endif /* defined(TARGET_PPC64) */
6080
6081 static void gen_tbegin(DisasContext *ctx)
6082 {
6083     if (unlikely(!ctx->tm_enabled)) {
6084         gen_exception_err(ctx, POWERPC_EXCP_FU, FSCR_IC_TM);
6085         return;
6086     }
6087     gen_helper_tbegin(cpu_env);
6088 }
6089
6090 #define GEN_TM_NOOP(name)                                      \
6091 static inline void gen_##name(DisasContext *ctx)               \
6092 {                                                              \
6093     if (unlikely(!ctx->tm_enabled)) {                          \
6094         gen_exception_err(ctx, POWERPC_EXCP_FU, FSCR_IC_TM);   \
6095         return;                                                \
6096     }                                                          \
6097     /*                                                         \
6098      * Because tbegin always fails in QEMU, these user         \
6099      * space instructions all have a simple implementation:    \
6100      *                                                         \
6101      *     CR[0] = 0b0 || MSR[TS] || 0b0                       \
6102      *           = 0b0 || 0b00    || 0b0                       \
6103      */                                                        \
6104     tcg_gen_movi_i32(cpu_crf[0], 0);                           \
6105 }
6106
6107 GEN_TM_NOOP(tend);
6108 GEN_TM_NOOP(tabort);
6109 GEN_TM_NOOP(tabortwc);
6110 GEN_TM_NOOP(tabortwci);
6111 GEN_TM_NOOP(tabortdc);
6112 GEN_TM_NOOP(tabortdci);
6113 GEN_TM_NOOP(tsr);
6114
6115 static inline void gen_cp_abort(DisasContext *ctx)
6116 {
6117     /* Do Nothing */
6118 }
6119
6120 #define GEN_CP_PASTE_NOOP(name)                           \
6121 static inline void gen_##name(DisasContext *ctx)          \
6122 {                                                         \
6123     /*                                                    \
6124      * Generate invalid exception until we have an        \
6125      * implementation of the copy paste facility          \
6126      */                                                   \
6127     gen_invalid(ctx);                                     \
6128 }
6129
6130 GEN_CP_PASTE_NOOP(copy)
6131 GEN_CP_PASTE_NOOP(paste)
6132
6133 static void gen_tcheck(DisasContext *ctx)
6134 {
6135     if (unlikely(!ctx->tm_enabled)) {
6136         gen_exception_err(ctx, POWERPC_EXCP_FU, FSCR_IC_TM);
6137         return;
6138     }
6139     /*
6140      * Because tbegin always fails, the tcheck implementation is
6141      * simple:
6142      *
6143      * CR[CRF] = TDOOMED || MSR[TS] || 0b0
6144      *         = 0b1 || 0b00 || 0b0
6145      */
6146     tcg_gen_movi_i32(cpu_crf[crfD(ctx->opcode)], 0x8);
6147 }
6148
6149 #if defined(CONFIG_USER_ONLY)
6150 #define GEN_TM_PRIV_NOOP(name)                                 \
6151 static inline void gen_##name(DisasContext *ctx)               \
6152 {                                                              \
6153     gen_priv_opc(ctx);                                         \
6154 }
6155
6156 #else
6157
6158 #define GEN_TM_PRIV_NOOP(name)                                 \
6159 static inline void gen_##name(DisasContext *ctx)               \
6160 {                                                              \
6161     CHK_SV(ctx);                                               \
6162     if (unlikely(!ctx->tm_enabled)) {                          \
6163         gen_exception_err(ctx, POWERPC_EXCP_FU, FSCR_IC_TM);   \
6164         return;                                                \
6165     }                                                          \
6166     /*                                                         \
6167      * Because tbegin always fails, the implementation is      \
6168      * simple:                                                 \
6169      *                                                         \
6170      *   CR[0] = 0b0 || MSR[TS] || 0b0                         \
6171      *         = 0b0 || 0b00 | 0b0                             \
6172      */                                                        \
6173     tcg_gen_movi_i32(cpu_crf[0], 0);                           \
6174 }
6175
6176 #endif
6177
6178 GEN_TM_PRIV_NOOP(treclaim);
6179 GEN_TM_PRIV_NOOP(trechkpt);
6180
6181 static inline void get_fpr(TCGv_i64 dst, int regno)
6182 {
6183     tcg_gen_ld_i64(dst, cpu_env, fpr_offset(regno));
6184 }
6185
6186 static inline void set_fpr(int regno, TCGv_i64 src)
6187 {
6188     tcg_gen_st_i64(src, cpu_env, fpr_offset(regno));
6189     /*
6190      * Before PowerISA v3.1 the result of doubleword 1 of the VSR
6191      * corresponding to the target FPR was undefined. However,
6192      * most (if not all) real hardware were setting the result to 0.
6193      * Starting at ISA v3.1, the result for doubleword 1 is now defined
6194      * to be 0.
6195      */
6196     tcg_gen_st_i64(tcg_constant_i64(0), cpu_env, vsr64_offset(regno, false));
6197 }
6198
6199 static inline void get_avr64(TCGv_i64 dst, int regno, bool high)
6200 {
6201     tcg_gen_ld_i64(dst, cpu_env, avr64_offset(regno, high));
6202 }
6203
6204 static inline void set_avr64(int regno, TCGv_i64 src, bool high)
6205 {
6206     tcg_gen_st_i64(src, cpu_env, avr64_offset(regno, high));
6207 }
6208
6209 /*
6210  * Helpers for decodetree used by !function for decoding arguments.
6211  */
6212 static int times_2(DisasContext *ctx, int x)
6213 {
6214     return x * 2;
6215 }
6216
6217 static int times_4(DisasContext *ctx, int x)
6218 {
6219     return x * 4;
6220 }
6221
6222 static int times_16(DisasContext *ctx, int x)
6223 {
6224     return x * 16;
6225 }
6226
6227 static int64_t dw_compose_ea(DisasContext *ctx, int x)
6228 {
6229     return deposit64(0xfffffffffffffe00, 3, 6, x);
6230 }
6231
6232 /*
6233  * Helpers for trans_* functions to check for specific insns flags.
6234  * Use token pasting to ensure that we use the proper flag with the
6235  * proper variable.
6236  */
6237 #define REQUIRE_INSNS_FLAGS(CTX, NAME) \
6238     do {                                                \
6239         if (((CTX)->insns_flags & PPC_##NAME) == 0) {   \
6240             return false;                               \
6241         }                                               \
6242     } while (0)
6243
6244 #define REQUIRE_INSNS_FLAGS2(CTX, NAME) \
6245     do {                                                \
6246         if (((CTX)->insns_flags2 & PPC2_##NAME) == 0) { \
6247             return false;                               \
6248         }                                               \
6249     } while (0)
6250
6251 /* Then special-case the check for 64-bit so that we elide code for ppc32. */
6252 #if TARGET_LONG_BITS == 32
6253 # define REQUIRE_64BIT(CTX)  return false
6254 #else
6255 # define REQUIRE_64BIT(CTX)  REQUIRE_INSNS_FLAGS(CTX, 64B)
6256 #endif
6257
6258 #define REQUIRE_VECTOR(CTX)                             \
6259     do {                                                \
6260         if (unlikely(!(CTX)->altivec_enabled)) {        \
6261             gen_exception((CTX), POWERPC_EXCP_VPU);     \
6262             return true;                                \
6263         }                                               \
6264     } while (0)
6265
6266 #define REQUIRE_VSX(CTX)                                \
6267     do {                                                \
6268         if (unlikely(!(CTX)->vsx_enabled)) {            \
6269             gen_exception((CTX), POWERPC_EXCP_VSXU);    \
6270             return true;                                \
6271         }                                               \
6272     } while (0)
6273
6274 #define REQUIRE_FPU(ctx)                                \
6275     do {                                                \
6276         if (unlikely(!(ctx)->fpu_enabled)) {            \
6277             gen_exception((ctx), POWERPC_EXCP_FPU);     \
6278             return true;                                \
6279         }                                               \
6280     } while (0)
6281
6282 #if !defined(CONFIG_USER_ONLY)
6283 #define REQUIRE_SV(CTX)             \
6284     do {                            \
6285         if (unlikely((CTX)->pr)) {  \
6286             gen_priv_opc(CTX);      \
6287             return true;            \
6288         }                           \
6289     } while (0)
6290
6291 #define REQUIRE_HV(CTX)                             \
6292     do {                                            \
6293         if (unlikely((CTX)->pr || !(CTX)->hv)) {    \
6294             gen_priv_opc(CTX);                      \
6295             return true;                            \
6296         }                                           \
6297     } while (0)
6298 #else
6299 #define REQUIRE_SV(CTX) do { gen_priv_opc(CTX); return true; } while (0)
6300 #define REQUIRE_HV(CTX) do { gen_priv_opc(CTX); return true; } while (0)
6301 #endif
6302
6303 /*
6304  * Helpers for implementing sets of trans_* functions.
6305  * Defer the implementation of NAME to FUNC, with optional extra arguments.
6306  */
6307 #define TRANS(NAME, FUNC, ...) \
6308     static bool trans_##NAME(DisasContext *ctx, arg_##NAME *a) \
6309     { return FUNC(ctx, a, __VA_ARGS__); }
6310 #define TRANS_FLAGS(FLAGS, NAME, FUNC, ...) \
6311     static bool trans_##NAME(DisasContext *ctx, arg_##NAME *a) \
6312     {                                                          \
6313         REQUIRE_INSNS_FLAGS(ctx, FLAGS);                       \
6314         return FUNC(ctx, a, __VA_ARGS__);                      \
6315     }
6316 #define TRANS_FLAGS2(FLAGS2, NAME, FUNC, ...) \
6317     static bool trans_##NAME(DisasContext *ctx, arg_##NAME *a) \
6318     {                                                          \
6319         REQUIRE_INSNS_FLAGS2(ctx, FLAGS2);                     \
6320         return FUNC(ctx, a, __VA_ARGS__);                      \
6321     }
6322
6323 #define TRANS64(NAME, FUNC, ...) \
6324     static bool trans_##NAME(DisasContext *ctx, arg_##NAME *a) \
6325     { REQUIRE_64BIT(ctx); return FUNC(ctx, a, __VA_ARGS__); }
6326 #define TRANS64_FLAGS2(FLAGS2, NAME, FUNC, ...) \
6327     static bool trans_##NAME(DisasContext *ctx, arg_##NAME *a) \
6328     {                                                          \
6329         REQUIRE_64BIT(ctx);                                    \
6330         REQUIRE_INSNS_FLAGS2(ctx, FLAGS2);                     \
6331         return FUNC(ctx, a, __VA_ARGS__);                      \
6332     }
6333
6334 /* TODO: More TRANS* helpers for extra insn_flags checks. */
6335
6336
6337 #include "decode-insn32.c.inc"
6338 #include "decode-insn64.c.inc"
6339 #include "power8-pmu-regs.c.inc"
6340
6341 /*
6342  * Incorporate CIA into the constant when R=1.
6343  * Validate that when R=1, RA=0.
6344  */
6345 static bool resolve_PLS_D(DisasContext *ctx, arg_D *d, arg_PLS_D *a)
6346 {
6347     d->rt = a->rt;
6348     d->ra = a->ra;
6349     d->si = a->si;
6350     if (a->r) {
6351         if (unlikely(a->ra != 0)) {
6352             gen_invalid(ctx);
6353             return false;
6354         }
6355         d->si += ctx->cia;
6356     }
6357     return true;
6358 }
6359
6360 #include "translate/fixedpoint-impl.c.inc"
6361
6362 #include "translate/fp-impl.c.inc"
6363
6364 #include "translate/vmx-impl.c.inc"
6365
6366 #include "translate/vsx-impl.c.inc"
6367
6368 #include "translate/dfp-impl.c.inc"
6369
6370 #include "translate/spe-impl.c.inc"
6371
6372 #include "translate/branch-impl.c.inc"
6373
6374 #include "translate/processor-ctrl-impl.c.inc"
6375
6376 #include "translate/storage-ctrl-impl.c.inc"
6377
6378 /* Handles lfdp */
6379 static void gen_dform39(DisasContext *ctx)
6380 {
6381     if ((ctx->opcode & 0x3) == 0) {
6382         if (ctx->insns_flags2 & PPC2_ISA205) {
6383             return gen_lfdp(ctx);
6384         }
6385     }
6386     return gen_invalid(ctx);
6387 }
6388
6389 /* Handles stfdp */
6390 static void gen_dform3D(DisasContext *ctx)
6391 {
6392     if ((ctx->opcode & 3) == 0) { /* DS-FORM */
6393         /* stfdp */
6394         if (ctx->insns_flags2 & PPC2_ISA205) {
6395             return gen_stfdp(ctx);
6396         }
6397     }
6398     return gen_invalid(ctx);
6399 }
6400
6401 #if defined(TARGET_PPC64)
6402 /* brd */
6403 static void gen_brd(DisasContext *ctx)
6404 {
6405     tcg_gen_bswap64_i64(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
6406 }
6407
6408 /* brw */
6409 static void gen_brw(DisasContext *ctx)
6410 {
6411     tcg_gen_bswap64_i64(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opcode)]);
6412     tcg_gen_rotli_i64(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 32);
6413
6414 }
6415
6416 /* brh */
6417 static void gen_brh(DisasContext *ctx)
6418 {
6419     TCGv_i64 mask = tcg_constant_i64(0x00ff00ff00ff00ffull);
6420     TCGv_i64 t1 = tcg_temp_new_i64();
6421     TCGv_i64 t2 = tcg_temp_new_i64();
6422
6423     tcg_gen_shri_i64(t1, cpu_gpr[rS(ctx->opcode)], 8);
6424     tcg_gen_and_i64(t2, t1, mask);
6425     tcg_gen_and_i64(t1, cpu_gpr[rS(ctx->opcode)], mask);
6426     tcg_gen_shli_i64(t1, t1, 8);
6427     tcg_gen_or_i64(cpu_gpr[rA(ctx->opcode)], t1, t2);
6428 }
6429 #endif
6430
6431 static opcode_t opcodes[] = {
6432 #if defined(TARGET_PPC64)
6433 GEN_HANDLER_E(brd, 0x1F, 0x1B, 0x05, 0x0000F801, PPC_NONE, PPC2_ISA310),
6434 GEN_HANDLER_E(brw, 0x1F, 0x1B, 0x04, 0x0000F801, PPC_NONE, PPC2_ISA310),
6435 GEN_HANDLER_E(brh, 0x1F, 0x1B, 0x06, 0x0000F801, PPC_NONE, PPC2_ISA310),
6436 #endif
6437 GEN_HANDLER(invalid, 0x00, 0x00, 0x00, 0xFFFFFFFF, PPC_NONE),
6438 #if defined(TARGET_PPC64)
6439 GEN_HANDLER_E(cmpeqb, 0x1F, 0x00, 0x07, 0x00600000, PPC_NONE, PPC2_ISA300),
6440 #endif
6441 GEN_HANDLER_E(cmpb, 0x1F, 0x1C, 0x0F, 0x00000001, PPC_NONE, PPC2_ISA205),
6442 GEN_HANDLER_E(cmprb, 0x1F, 0x00, 0x06, 0x00400001, PPC_NONE, PPC2_ISA300),
6443 GEN_HANDLER(isel, 0x1F, 0x0F, 0xFF, 0x00000001, PPC_ISEL),
6444 GEN_HANDLER(addic, 0x0C, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6445 GEN_HANDLER2(addic_, "addic.", 0x0D, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6446 GEN_HANDLER(mulhw, 0x1F, 0x0B, 0x02, 0x00000400, PPC_INTEGER),
6447 GEN_HANDLER(mulhwu, 0x1F, 0x0B, 0x00, 0x00000400, PPC_INTEGER),
6448 GEN_HANDLER(mullw, 0x1F, 0x0B, 0x07, 0x00000000, PPC_INTEGER),
6449 GEN_HANDLER(mullwo, 0x1F, 0x0B, 0x17, 0x00000000, PPC_INTEGER),
6450 GEN_HANDLER(mulli, 0x07, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6451 #if defined(TARGET_PPC64)
6452 GEN_HANDLER(mulld, 0x1F, 0x09, 0x07, 0x00000000, PPC_64B),
6453 #endif
6454 GEN_HANDLER(neg, 0x1F, 0x08, 0x03, 0x0000F800, PPC_INTEGER),
6455 GEN_HANDLER(nego, 0x1F, 0x08, 0x13, 0x0000F800, PPC_INTEGER),
6456 GEN_HANDLER(subfic, 0x08, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6457 GEN_HANDLER2(andi_, "andi.", 0x1C, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6458 GEN_HANDLER2(andis_, "andis.", 0x1D, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6459 GEN_HANDLER(cntlzw, 0x1F, 0x1A, 0x00, 0x00000000, PPC_INTEGER),
6460 GEN_HANDLER_E(cnttzw, 0x1F, 0x1A, 0x10, 0x00000000, PPC_NONE, PPC2_ISA300),
6461 GEN_HANDLER_E(copy, 0x1F, 0x06, 0x18, 0x03C00001, PPC_NONE, PPC2_ISA300),
6462 GEN_HANDLER_E(cp_abort, 0x1F, 0x06, 0x1A, 0x03FFF801, PPC_NONE, PPC2_ISA300),
6463 GEN_HANDLER_E(paste, 0x1F, 0x06, 0x1C, 0x03C00000, PPC_NONE, PPC2_ISA300),
6464 GEN_HANDLER(or, 0x1F, 0x1C, 0x0D, 0x00000000, PPC_INTEGER),
6465 GEN_HANDLER(xor, 0x1F, 0x1C, 0x09, 0x00000000, PPC_INTEGER),
6466 GEN_HANDLER(ori, 0x18, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6467 GEN_HANDLER(oris, 0x19, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6468 GEN_HANDLER(xori, 0x1A, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6469 GEN_HANDLER(xoris, 0x1B, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6470 GEN_HANDLER(popcntb, 0x1F, 0x1A, 0x03, 0x0000F801, PPC_POPCNTB),
6471 GEN_HANDLER(popcntw, 0x1F, 0x1A, 0x0b, 0x0000F801, PPC_POPCNTWD),
6472 GEN_HANDLER_E(prtyw, 0x1F, 0x1A, 0x04, 0x0000F801, PPC_NONE, PPC2_ISA205),
6473 #if defined(TARGET_PPC64)
6474 GEN_HANDLER(popcntd, 0x1F, 0x1A, 0x0F, 0x0000F801, PPC_POPCNTWD),
6475 GEN_HANDLER(cntlzd, 0x1F, 0x1A, 0x01, 0x00000000, PPC_64B),
6476 GEN_HANDLER_E(cnttzd, 0x1F, 0x1A, 0x11, 0x00000000, PPC_NONE, PPC2_ISA300),
6477 GEN_HANDLER_E(darn, 0x1F, 0x13, 0x17, 0x001CF801, PPC_NONE, PPC2_ISA300),
6478 GEN_HANDLER_E(prtyd, 0x1F, 0x1A, 0x05, 0x0000F801, PPC_NONE, PPC2_ISA205),
6479 GEN_HANDLER_E(bpermd, 0x1F, 0x1C, 0x07, 0x00000001, PPC_NONE, PPC2_PERM_ISA206),
6480 #endif
6481 GEN_HANDLER(rlwimi, 0x14, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6482 GEN_HANDLER(rlwinm, 0x15, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6483 GEN_HANDLER(rlwnm, 0x17, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6484 GEN_HANDLER(slw, 0x1F, 0x18, 0x00, 0x00000000, PPC_INTEGER),
6485 GEN_HANDLER(sraw, 0x1F, 0x18, 0x18, 0x00000000, PPC_INTEGER),
6486 GEN_HANDLER(srawi, 0x1F, 0x18, 0x19, 0x00000000, PPC_INTEGER),
6487 GEN_HANDLER(srw, 0x1F, 0x18, 0x10, 0x00000000, PPC_INTEGER),
6488 #if defined(TARGET_PPC64)
6489 GEN_HANDLER(sld, 0x1F, 0x1B, 0x00, 0x00000000, PPC_64B),
6490 GEN_HANDLER(srad, 0x1F, 0x1A, 0x18, 0x00000000, PPC_64B),
6491 GEN_HANDLER2(sradi0, "sradi", 0x1F, 0x1A, 0x19, 0x00000000, PPC_64B),
6492 GEN_HANDLER2(sradi1, "sradi", 0x1F, 0x1B, 0x19, 0x00000000, PPC_64B),
6493 GEN_HANDLER(srd, 0x1F, 0x1B, 0x10, 0x00000000, PPC_64B),
6494 GEN_HANDLER2_E(extswsli0, "extswsli", 0x1F, 0x1A, 0x1B, 0x00000000,
6495                PPC_NONE, PPC2_ISA300),
6496 GEN_HANDLER2_E(extswsli1, "extswsli", 0x1F, 0x1B, 0x1B, 0x00000000,
6497                PPC_NONE, PPC2_ISA300),
6498 #endif
6499 /* handles lfdp, lxsd, lxssp */
6500 GEN_HANDLER_E(dform39, 0x39, 0xFF, 0xFF, 0x00000000, PPC_NONE, PPC2_ISA205),
6501 /* handles stfdp, stxsd, stxssp */
6502 GEN_HANDLER_E(dform3D, 0x3D, 0xFF, 0xFF, 0x00000000, PPC_NONE, PPC2_ISA205),
6503 GEN_HANDLER(lmw, 0x2E, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6504 GEN_HANDLER(stmw, 0x2F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER),
6505 GEN_HANDLER(lswi, 0x1F, 0x15, 0x12, 0x00000001, PPC_STRING),
6506 GEN_HANDLER(lswx, 0x1F, 0x15, 0x10, 0x00000001, PPC_STRING),
6507 GEN_HANDLER(stswi, 0x1F, 0x15, 0x16, 0x00000001, PPC_STRING),
6508 GEN_HANDLER(stswx, 0x1F, 0x15, 0x14, 0x00000001, PPC_STRING),
6509 GEN_HANDLER(eieio, 0x1F, 0x16, 0x1A, 0x01FFF801, PPC_MEM_EIEIO),
6510 GEN_HANDLER(isync, 0x13, 0x16, 0x04, 0x03FFF801, PPC_MEM),
6511 GEN_HANDLER_E(lbarx, 0x1F, 0x14, 0x01, 0, PPC_NONE, PPC2_ATOMIC_ISA206),
6512 GEN_HANDLER_E(lharx, 0x1F, 0x14, 0x03, 0, PPC_NONE, PPC2_ATOMIC_ISA206),
6513 GEN_HANDLER(lwarx, 0x1F, 0x14, 0x00, 0x00000000, PPC_RES),
6514 GEN_HANDLER_E(lwat, 0x1F, 0x06, 0x12, 0x00000001, PPC_NONE, PPC2_ISA300),
6515 GEN_HANDLER_E(stwat, 0x1F, 0x06, 0x16, 0x00000001, PPC_NONE, PPC2_ISA300),
6516 GEN_HANDLER_E(stbcx_, 0x1F, 0x16, 0x15, 0, PPC_NONE, PPC2_ATOMIC_ISA206),
6517 GEN_HANDLER_E(sthcx_, 0x1F, 0x16, 0x16, 0, PPC_NONE, PPC2_ATOMIC_ISA206),
6518 GEN_HANDLER2(stwcx_, "stwcx.", 0x1F, 0x16, 0x04, 0x00000000, PPC_RES),
6519 #if defined(TARGET_PPC64)
6520 GEN_HANDLER_E(ldat, 0x1F, 0x06, 0x13, 0x00000001, PPC_NONE, PPC2_ISA300),
6521 GEN_HANDLER_E(stdat, 0x1F, 0x06, 0x17, 0x00000001, PPC_NONE, PPC2_ISA300),
6522 GEN_HANDLER(ldarx, 0x1F, 0x14, 0x02, 0x00000000, PPC_64B),
6523 GEN_HANDLER_E(lqarx, 0x1F, 0x14, 0x08, 0, PPC_NONE, PPC2_LSQ_ISA207),
6524 GEN_HANDLER2(stdcx_, "stdcx.", 0x1F, 0x16, 0x06, 0x00000000, PPC_64B),
6525 GEN_HANDLER_E(stqcx_, 0x1F, 0x16, 0x05, 0, PPC_NONE, PPC2_LSQ_ISA207),
6526 #endif
6527 GEN_HANDLER(sync, 0x1F, 0x16, 0x12, 0x039FF801, PPC_MEM_SYNC),
6528 /* ISA v3.0 changed the extended opcode from 62 to 30 */
6529 GEN_HANDLER(wait, 0x1F, 0x1E, 0x01, 0x039FF801, PPC_WAIT),
6530 GEN_HANDLER_E(wait, 0x1F, 0x1E, 0x00, 0x039CF801, PPC_NONE, PPC2_ISA300),
6531 GEN_HANDLER(b, 0x12, 0xFF, 0xFF, 0x00000000, PPC_FLOW),
6532 GEN_HANDLER(bc, 0x10, 0xFF, 0xFF, 0x00000000, PPC_FLOW),
6533 GEN_HANDLER(bcctr, 0x13, 0x10, 0x10, 0x00000000, PPC_FLOW),
6534 GEN_HANDLER(bclr, 0x13, 0x10, 0x00, 0x00000000, PPC_FLOW),
6535 GEN_HANDLER_E(bctar, 0x13, 0x10, 0x11, 0x0000E000, PPC_NONE, PPC2_BCTAR_ISA207),
6536 GEN_HANDLER(mcrf, 0x13, 0x00, 0xFF, 0x00000001, PPC_INTEGER),
6537 GEN_HANDLER(rfi, 0x13, 0x12, 0x01, 0x03FF8001, PPC_FLOW),
6538 #if defined(TARGET_PPC64)
6539 GEN_HANDLER(rfid, 0x13, 0x12, 0x00, 0x03FF8001, PPC_64B),
6540 #if !defined(CONFIG_USER_ONLY)
6541 /* Top bit of opc2 corresponds with low bit of LEV, so use two handlers */
6542 GEN_HANDLER_E(scv, 0x11, 0x10, 0xFF, 0x03FFF01E, PPC_NONE, PPC2_ISA300),
6543 GEN_HANDLER_E(scv, 0x11, 0x00, 0xFF, 0x03FFF01E, PPC_NONE, PPC2_ISA300),
6544 GEN_HANDLER_E(rfscv, 0x13, 0x12, 0x02, 0x03FF8001, PPC_NONE, PPC2_ISA300),
6545 #endif
6546 GEN_HANDLER_E(stop, 0x13, 0x12, 0x0b, 0x03FFF801, PPC_NONE, PPC2_ISA300),
6547 GEN_HANDLER_E(doze, 0x13, 0x12, 0x0c, 0x03FFF801, PPC_NONE, PPC2_PM_ISA206),
6548 GEN_HANDLER_E(nap, 0x13, 0x12, 0x0d, 0x03FFF801, PPC_NONE, PPC2_PM_ISA206),
6549 GEN_HANDLER_E(sleep, 0x13, 0x12, 0x0e, 0x03FFF801, PPC_NONE, PPC2_PM_ISA206),
6550 GEN_HANDLER_E(rvwinkle, 0x13, 0x12, 0x0f, 0x03FFF801, PPC_NONE, PPC2_PM_ISA206),
6551 GEN_HANDLER(hrfid, 0x13, 0x12, 0x08, 0x03FF8001, PPC_64H),
6552 #endif
6553 /* Top bit of opc2 corresponds with low bit of LEV, so use two handlers */
6554 GEN_HANDLER(sc, 0x11, 0x11, 0xFF, 0x03FFF01D, PPC_FLOW),
6555 GEN_HANDLER(sc, 0x11, 0x01, 0xFF, 0x03FFF01D, PPC_FLOW),
6556 GEN_HANDLER(tw, 0x1F, 0x04, 0x00, 0x00000001, PPC_FLOW),
6557 GEN_HANDLER(twi, 0x03, 0xFF, 0xFF, 0x00000000, PPC_FLOW),
6558 #if defined(TARGET_PPC64)
6559 GEN_HANDLER(td, 0x1F, 0x04, 0x02, 0x00000001, PPC_64B),
6560 GEN_HANDLER(tdi, 0x02, 0xFF, 0xFF, 0x00000000, PPC_64B),
6561 #endif
6562 GEN_HANDLER(mcrxr, 0x1F, 0x00, 0x10, 0x007FF801, PPC_MISC),
6563 GEN_HANDLER(mfcr, 0x1F, 0x13, 0x00, 0x00000801, PPC_MISC),
6564 GEN_HANDLER(mfmsr, 0x1F, 0x13, 0x02, 0x001FF801, PPC_MISC),
6565 GEN_HANDLER(mfspr, 0x1F, 0x13, 0x0A, 0x00000001, PPC_MISC),
6566 GEN_HANDLER(mftb, 0x1F, 0x13, 0x0B, 0x00000001, PPC_MFTB),
6567 GEN_HANDLER(mtcrf, 0x1F, 0x10, 0x04, 0x00000801, PPC_MISC),
6568 #if defined(TARGET_PPC64)
6569 GEN_HANDLER(mtmsrd, 0x1F, 0x12, 0x05, 0x001EF801, PPC_64B),
6570 GEN_HANDLER_E(setb, 0x1F, 0x00, 0x04, 0x0003F801, PPC_NONE, PPC2_ISA300),
6571 GEN_HANDLER_E(mcrxrx, 0x1F, 0x00, 0x12, 0x007FF801, PPC_NONE, PPC2_ISA300),
6572 #endif
6573 GEN_HANDLER(mtmsr, 0x1F, 0x12, 0x04, 0x001EF801, PPC_MISC),
6574 GEN_HANDLER(mtspr, 0x1F, 0x13, 0x0E, 0x00000000, PPC_MISC),
6575 GEN_HANDLER(dcbf, 0x1F, 0x16, 0x02, 0x03C00001, PPC_CACHE),
6576 GEN_HANDLER_E(dcbfep, 0x1F, 0x1F, 0x03, 0x03C00001, PPC_NONE, PPC2_BOOKE206),
6577 GEN_HANDLER(dcbi, 0x1F, 0x16, 0x0E, 0x03E00001, PPC_CACHE),
6578 GEN_HANDLER(dcbst, 0x1F, 0x16, 0x01, 0x03E00001, PPC_CACHE),
6579 GEN_HANDLER_E(dcbstep, 0x1F, 0x1F, 0x01, 0x03E00001, PPC_NONE, PPC2_BOOKE206),
6580 GEN_HANDLER(dcbt, 0x1F, 0x16, 0x08, 0x00000001, PPC_CACHE),
6581 GEN_HANDLER_E(dcbtep, 0x1F, 0x1F, 0x09, 0x00000001, PPC_NONE, PPC2_BOOKE206),
6582 GEN_HANDLER(dcbtst, 0x1F, 0x16, 0x07, 0x00000001, PPC_CACHE),
6583 GEN_HANDLER_E(dcbtstep, 0x1F, 0x1F, 0x07, 0x00000001, PPC_NONE, PPC2_BOOKE206),
6584 GEN_HANDLER_E(dcbtls, 0x1F, 0x06, 0x05, 0x02000001, PPC_BOOKE, PPC2_BOOKE206),
6585 GEN_HANDLER_E(dcblc, 0x1F, 0x06, 0x0c, 0x02000001, PPC_BOOKE, PPC2_BOOKE206),
6586 GEN_HANDLER(dcbz, 0x1F, 0x16, 0x1F, 0x03C00001, PPC_CACHE_DCBZ),
6587 GEN_HANDLER_E(dcbzep, 0x1F, 0x1F, 0x1F, 0x03C00001, PPC_NONE, PPC2_BOOKE206),
6588 GEN_HANDLER(dst, 0x1F, 0x16, 0x0A, 0x01800001, PPC_ALTIVEC),
6589 GEN_HANDLER(dstst, 0x1F, 0x16, 0x0B, 0x01800001, PPC_ALTIVEC),
6590 GEN_HANDLER(dss, 0x1F, 0x16, 0x19, 0x019FF801, PPC_ALTIVEC),
6591 GEN_HANDLER(icbi, 0x1F, 0x16, 0x1E, 0x03E00001, PPC_CACHE_ICBI),
6592 GEN_HANDLER_E(icbiep, 0x1F, 0x1F, 0x1E, 0x03E00001, PPC_NONE, PPC2_BOOKE206),
6593 GEN_HANDLER(dcba, 0x1F, 0x16, 0x17, 0x03E00001, PPC_CACHE_DCBA),
6594 GEN_HANDLER(mfsr, 0x1F, 0x13, 0x12, 0x0010F801, PPC_SEGMENT),
6595 GEN_HANDLER(mfsrin, 0x1F, 0x13, 0x14, 0x001F0001, PPC_SEGMENT),
6596 GEN_HANDLER(mtsr, 0x1F, 0x12, 0x06, 0x0010F801, PPC_SEGMENT),
6597 GEN_HANDLER(mtsrin, 0x1F, 0x12, 0x07, 0x001F0001, PPC_SEGMENT),
6598 #if defined(TARGET_PPC64)
6599 GEN_HANDLER2(mfsr_64b, "mfsr", 0x1F, 0x13, 0x12, 0x0010F801, PPC_SEGMENT_64B),
6600 GEN_HANDLER2(mfsrin_64b, "mfsrin", 0x1F, 0x13, 0x14, 0x001F0001,
6601              PPC_SEGMENT_64B),
6602 GEN_HANDLER2(mtsr_64b, "mtsr", 0x1F, 0x12, 0x06, 0x0010F801, PPC_SEGMENT_64B),
6603 GEN_HANDLER2(mtsrin_64b, "mtsrin", 0x1F, 0x12, 0x07, 0x001F0001,
6604              PPC_SEGMENT_64B),
6605 #endif
6606 GEN_HANDLER(tlbia, 0x1F, 0x12, 0x0B, 0x03FFFC01, PPC_MEM_TLBIA),
6607 /*
6608  * XXX Those instructions will need to be handled differently for
6609  * different ISA versions
6610  */
6611 GEN_HANDLER(tlbsync, 0x1F, 0x16, 0x11, 0x03FFF801, PPC_MEM_TLBSYNC),
6612 GEN_HANDLER(eciwx, 0x1F, 0x16, 0x0D, 0x00000001, PPC_EXTERN),
6613 GEN_HANDLER(ecowx, 0x1F, 0x16, 0x09, 0x00000001, PPC_EXTERN),
6614 GEN_HANDLER2(tlbld_6xx, "tlbld", 0x1F, 0x12, 0x1E, 0x03FF0001, PPC_6xx_TLB),
6615 GEN_HANDLER2(tlbli_6xx, "tlbli", 0x1F, 0x12, 0x1F, 0x03FF0001, PPC_6xx_TLB),
6616 GEN_HANDLER(mfapidi, 0x1F, 0x13, 0x08, 0x0000F801, PPC_MFAPIDI),
6617 GEN_HANDLER(tlbiva, 0x1F, 0x12, 0x18, 0x03FFF801, PPC_TLBIVA),
6618 GEN_HANDLER(mfdcr, 0x1F, 0x03, 0x0A, 0x00000001, PPC_DCR),
6619 GEN_HANDLER(mtdcr, 0x1F, 0x03, 0x0E, 0x00000001, PPC_DCR),
6620 GEN_HANDLER(mfdcrx, 0x1F, 0x03, 0x08, 0x00000000, PPC_DCRX),
6621 GEN_HANDLER(mtdcrx, 0x1F, 0x03, 0x0C, 0x00000000, PPC_DCRX),
6622 GEN_HANDLER(dccci, 0x1F, 0x06, 0x0E, 0x03E00001, PPC_4xx_COMMON),
6623 GEN_HANDLER(dcread, 0x1F, 0x06, 0x0F, 0x00000001, PPC_4xx_COMMON),
6624 GEN_HANDLER2(icbt_40x, "icbt", 0x1F, 0x06, 0x08, 0x03E00001, PPC_40x_ICBT),
6625 GEN_HANDLER(iccci, 0x1F, 0x06, 0x1E, 0x00000001, PPC_4xx_COMMON),
6626 GEN_HANDLER(icread, 0x1F, 0x06, 0x1F, 0x03E00001, PPC_4xx_COMMON),
6627 GEN_HANDLER2(rfci_40x, "rfci", 0x13, 0x13, 0x01, 0x03FF8001, PPC_40x_EXCP),
6628 GEN_HANDLER_E(rfci, 0x13, 0x13, 0x01, 0x03FF8001, PPC_BOOKE, PPC2_BOOKE206),
6629 GEN_HANDLER(rfdi, 0x13, 0x07, 0x01, 0x03FF8001, PPC_RFDI),
6630 GEN_HANDLER(rfmci, 0x13, 0x06, 0x01, 0x03FF8001, PPC_RFMCI),
6631 GEN_HANDLER2(tlbre_40x, "tlbre", 0x1F, 0x12, 0x1D, 0x00000001, PPC_40x_TLB),
6632 GEN_HANDLER2(tlbsx_40x, "tlbsx", 0x1F, 0x12, 0x1C, 0x00000000, PPC_40x_TLB),
6633 GEN_HANDLER2(tlbwe_40x, "tlbwe", 0x1F, 0x12, 0x1E, 0x00000001, PPC_40x_TLB),
6634 GEN_HANDLER2(tlbre_440, "tlbre", 0x1F, 0x12, 0x1D, 0x00000001, PPC_BOOKE),
6635 GEN_HANDLER2(tlbsx_440, "tlbsx", 0x1F, 0x12, 0x1C, 0x00000000, PPC_BOOKE),
6636 GEN_HANDLER2(tlbwe_440, "tlbwe", 0x1F, 0x12, 0x1E, 0x00000001, PPC_BOOKE),
6637 GEN_HANDLER2_E(tlbre_booke206, "tlbre", 0x1F, 0x12, 0x1D, 0x00000001,
6638                PPC_NONE, PPC2_BOOKE206),
6639 GEN_HANDLER2_E(tlbsx_booke206, "tlbsx", 0x1F, 0x12, 0x1C, 0x00000000,
6640                PPC_NONE, PPC2_BOOKE206),
6641 GEN_HANDLER2_E(tlbwe_booke206, "tlbwe", 0x1F, 0x12, 0x1E, 0x00000001,
6642                PPC_NONE, PPC2_BOOKE206),
6643 GEN_HANDLER2_E(tlbivax_booke206, "tlbivax", 0x1F, 0x12, 0x18, 0x00000001,
6644                PPC_NONE, PPC2_BOOKE206),
6645 GEN_HANDLER2_E(tlbilx_booke206, "tlbilx", 0x1F, 0x12, 0x00, 0x03800001,
6646                PPC_NONE, PPC2_BOOKE206),
6647 GEN_HANDLER(wrtee, 0x1F, 0x03, 0x04, 0x000FFC01, PPC_WRTEE),
6648 GEN_HANDLER(wrteei, 0x1F, 0x03, 0x05, 0x000E7C01, PPC_WRTEE),
6649 GEN_HANDLER(dlmzb, 0x1F, 0x0E, 0x02, 0x00000000, PPC_440_SPEC),
6650 GEN_HANDLER_E(mbar, 0x1F, 0x16, 0x1a, 0x001FF801,
6651               PPC_BOOKE, PPC2_BOOKE206),
6652 GEN_HANDLER(msync_4xx, 0x1F, 0x16, 0x12, 0x039FF801, PPC_BOOKE),
6653 GEN_HANDLER2_E(icbt_440, "icbt", 0x1F, 0x16, 0x00, 0x03E00001,
6654                PPC_BOOKE, PPC2_BOOKE206),
6655 GEN_HANDLER2(icbt_440, "icbt", 0x1F, 0x06, 0x08, 0x03E00001,
6656              PPC_440_SPEC),
6657 GEN_HANDLER(lvsl, 0x1f, 0x06, 0x00, 0x00000001, PPC_ALTIVEC),
6658 GEN_HANDLER(lvsr, 0x1f, 0x06, 0x01, 0x00000001, PPC_ALTIVEC),
6659 GEN_HANDLER(mfvscr, 0x04, 0x2, 0x18, 0x001ff800, PPC_ALTIVEC),
6660 GEN_HANDLER(mtvscr, 0x04, 0x2, 0x19, 0x03ff0000, PPC_ALTIVEC),
6661 #if defined(TARGET_PPC64)
6662 GEN_HANDLER_E(maddhd_maddhdu, 0x04, 0x18, 0xFF, 0x00000000, PPC_NONE,
6663               PPC2_ISA300),
6664 GEN_HANDLER_E(maddld, 0x04, 0x19, 0xFF, 0x00000000, PPC_NONE, PPC2_ISA300),
6665 #endif
6666
6667 #undef GEN_INT_ARITH_ADD
6668 #undef GEN_INT_ARITH_ADD_CONST
6669 #define GEN_INT_ARITH_ADD(name, opc3, add_ca, compute_ca, compute_ov)         \
6670 GEN_HANDLER(name, 0x1F, 0x0A, opc3, 0x00000000, PPC_INTEGER),
6671 #define GEN_INT_ARITH_ADD_CONST(name, opc3, const_val,                        \
6672                                 add_ca, compute_ca, compute_ov)               \
6673 GEN_HANDLER(name, 0x1F, 0x0A, opc3, 0x0000F800, PPC_INTEGER),
6674 GEN_INT_ARITH_ADD(add, 0x08, 0, 0, 0)
6675 GEN_INT_ARITH_ADD(addo, 0x18, 0, 0, 1)
6676 GEN_INT_ARITH_ADD(addc, 0x00, 0, 1, 0)
6677 GEN_INT_ARITH_ADD(addco, 0x10, 0, 1, 1)
6678 GEN_INT_ARITH_ADD(adde, 0x04, 1, 1, 0)
6679 GEN_INT_ARITH_ADD(addeo, 0x14, 1, 1, 1)
6680 GEN_INT_ARITH_ADD_CONST(addme, 0x07, -1LL, 1, 1, 0)
6681 GEN_INT_ARITH_ADD_CONST(addmeo, 0x17, -1LL, 1, 1, 1)
6682 GEN_HANDLER_E(addex, 0x1F, 0x0A, 0x05, 0x00000000, PPC_NONE, PPC2_ISA300),
6683 GEN_INT_ARITH_ADD_CONST(addze, 0x06, 0, 1, 1, 0)
6684 GEN_INT_ARITH_ADD_CONST(addzeo, 0x16, 0, 1, 1, 1)
6685
6686 #undef GEN_INT_ARITH_DIVW
6687 #define GEN_INT_ARITH_DIVW(name, opc3, sign, compute_ov)                      \
6688 GEN_HANDLER(name, 0x1F, 0x0B, opc3, 0x00000000, PPC_INTEGER)
6689 GEN_INT_ARITH_DIVW(divwu, 0x0E, 0, 0),
6690 GEN_INT_ARITH_DIVW(divwuo, 0x1E, 0, 1),
6691 GEN_INT_ARITH_DIVW(divw, 0x0F, 1, 0),
6692 GEN_INT_ARITH_DIVW(divwo, 0x1F, 1, 1),
6693 GEN_HANDLER_E(divwe, 0x1F, 0x0B, 0x0D, 0, PPC_NONE, PPC2_DIVE_ISA206),
6694 GEN_HANDLER_E(divweo, 0x1F, 0x0B, 0x1D, 0, PPC_NONE, PPC2_DIVE_ISA206),
6695 GEN_HANDLER_E(divweu, 0x1F, 0x0B, 0x0C, 0, PPC_NONE, PPC2_DIVE_ISA206),
6696 GEN_HANDLER_E(divweuo, 0x1F, 0x0B, 0x1C, 0, PPC_NONE, PPC2_DIVE_ISA206),
6697 GEN_HANDLER_E(modsw, 0x1F, 0x0B, 0x18, 0x00000001, PPC_NONE, PPC2_ISA300),
6698 GEN_HANDLER_E(moduw, 0x1F, 0x0B, 0x08, 0x00000001, PPC_NONE, PPC2_ISA300),
6699
6700 #if defined(TARGET_PPC64)
6701 #undef GEN_INT_ARITH_DIVD
6702 #define GEN_INT_ARITH_DIVD(name, opc3, sign, compute_ov)                      \
6703 GEN_HANDLER(name, 0x1F, 0x09, opc3, 0x00000000, PPC_64B)
6704 GEN_INT_ARITH_DIVD(divdu, 0x0E, 0, 0),
6705 GEN_INT_ARITH_DIVD(divduo, 0x1E, 0, 1),
6706 GEN_INT_ARITH_DIVD(divd, 0x0F, 1, 0),
6707 GEN_INT_ARITH_DIVD(divdo, 0x1F, 1, 1),
6708
6709 GEN_HANDLER_E(divdeu, 0x1F, 0x09, 0x0C, 0, PPC_NONE, PPC2_DIVE_ISA206),
6710 GEN_HANDLER_E(divdeuo, 0x1F, 0x09, 0x1C, 0, PPC_NONE, PPC2_DIVE_ISA206),
6711 GEN_HANDLER_E(divde, 0x1F, 0x09, 0x0D, 0, PPC_NONE, PPC2_DIVE_ISA206),
6712 GEN_HANDLER_E(divdeo, 0x1F, 0x09, 0x1D, 0, PPC_NONE, PPC2_DIVE_ISA206),
6713 GEN_HANDLER_E(modsd, 0x1F, 0x09, 0x18, 0x00000001, PPC_NONE, PPC2_ISA300),
6714 GEN_HANDLER_E(modud, 0x1F, 0x09, 0x08, 0x00000001, PPC_NONE, PPC2_ISA300),
6715
6716 #undef GEN_INT_ARITH_MUL_HELPER
6717 #define GEN_INT_ARITH_MUL_HELPER(name, opc3)                                  \
6718 GEN_HANDLER(name, 0x1F, 0x09, opc3, 0x00000000, PPC_64B)
6719 GEN_INT_ARITH_MUL_HELPER(mulhdu, 0x00),
6720 GEN_INT_ARITH_MUL_HELPER(mulhd, 0x02),
6721 GEN_INT_ARITH_MUL_HELPER(mulldo, 0x17),
6722 #endif
6723
6724 #undef GEN_INT_ARITH_SUBF
6725 #undef GEN_INT_ARITH_SUBF_CONST
6726 #define GEN_INT_ARITH_SUBF(name, opc3, add_ca, compute_ca, compute_ov)        \
6727 GEN_HANDLER(name, 0x1F, 0x08, opc3, 0x00000000, PPC_INTEGER),
6728 #define GEN_INT_ARITH_SUBF_CONST(name, opc3, const_val,                       \
6729                                 add_ca, compute_ca, compute_ov)               \
6730 GEN_HANDLER(name, 0x1F, 0x08, opc3, 0x0000F800, PPC_INTEGER),
6731 GEN_INT_ARITH_SUBF(subf, 0x01, 0, 0, 0)
6732 GEN_INT_ARITH_SUBF(subfo, 0x11, 0, 0, 1)
6733 GEN_INT_ARITH_SUBF(subfc, 0x00, 0, 1, 0)
6734 GEN_INT_ARITH_SUBF(subfco, 0x10, 0, 1, 1)
6735 GEN_INT_ARITH_SUBF(subfe, 0x04, 1, 1, 0)
6736 GEN_INT_ARITH_SUBF(subfeo, 0x14, 1, 1, 1)
6737 GEN_INT_ARITH_SUBF_CONST(subfme, 0x07, -1LL, 1, 1, 0)
6738 GEN_INT_ARITH_SUBF_CONST(subfmeo, 0x17, -1LL, 1, 1, 1)
6739 GEN_INT_ARITH_SUBF_CONST(subfze, 0x06, 0, 1, 1, 0)
6740 GEN_INT_ARITH_SUBF_CONST(subfzeo, 0x16, 0, 1, 1, 1)
6741
6742 #undef GEN_LOGICAL1
6743 #undef GEN_LOGICAL2
6744 #define GEN_LOGICAL2(name, tcg_op, opc, type)                                 \
6745 GEN_HANDLER(name, 0x1F, 0x1C, opc, 0x00000000, type)
6746 #define GEN_LOGICAL1(name, tcg_op, opc, type)                                 \
6747 GEN_HANDLER(name, 0x1F, 0x1A, opc, 0x00000000, type)
6748 GEN_LOGICAL2(and, tcg_gen_and_tl, 0x00, PPC_INTEGER),
6749 GEN_LOGICAL2(andc, tcg_gen_andc_tl, 0x01, PPC_INTEGER),
6750 GEN_LOGICAL2(eqv, tcg_gen_eqv_tl, 0x08, PPC_INTEGER),
6751 GEN_LOGICAL1(extsb, tcg_gen_ext8s_tl, 0x1D, PPC_INTEGER),
6752 GEN_LOGICAL1(extsh, tcg_gen_ext16s_tl, 0x1C, PPC_INTEGER),
6753 GEN_LOGICAL2(nand, tcg_gen_nand_tl, 0x0E, PPC_INTEGER),
6754 GEN_LOGICAL2(nor, tcg_gen_nor_tl, 0x03, PPC_INTEGER),
6755 GEN_LOGICAL2(orc, tcg_gen_orc_tl, 0x0C, PPC_INTEGER),
6756 #if defined(TARGET_PPC64)
6757 GEN_LOGICAL1(extsw, tcg_gen_ext32s_tl, 0x1E, PPC_64B),
6758 #endif
6759
6760 #if defined(TARGET_PPC64)
6761 #undef GEN_PPC64_R2
6762 #undef GEN_PPC64_R4
6763 #define GEN_PPC64_R2(name, opc1, opc2)                                        \
6764 GEN_HANDLER2(name##0, stringify(name), opc1, opc2, 0xFF, 0x00000000, PPC_64B),\
6765 GEN_HANDLER2(name##1, stringify(name), opc1, opc2 | 0x10, 0xFF, 0x00000000,   \
6766              PPC_64B)
6767 #define GEN_PPC64_R4(name, opc1, opc2)                                        \
6768 GEN_HANDLER2(name##0, stringify(name), opc1, opc2, 0xFF, 0x00000000, PPC_64B),\
6769 GEN_HANDLER2(name##1, stringify(name), opc1, opc2 | 0x01, 0xFF, 0x00000000,   \
6770              PPC_64B),                                                        \
6771 GEN_HANDLER2(name##2, stringify(name), opc1, opc2 | 0x10, 0xFF, 0x00000000,   \
6772              PPC_64B),                                                        \
6773 GEN_HANDLER2(name##3, stringify(name), opc1, opc2 | 0x11, 0xFF, 0x00000000,   \
6774              PPC_64B)
6775 GEN_PPC64_R4(rldicl, 0x1E, 0x00),
6776 GEN_PPC64_R4(rldicr, 0x1E, 0x02),
6777 GEN_PPC64_R4(rldic, 0x1E, 0x04),
6778 GEN_PPC64_R2(rldcl, 0x1E, 0x08),
6779 GEN_PPC64_R2(rldcr, 0x1E, 0x09),
6780 GEN_PPC64_R4(rldimi, 0x1E, 0x06),
6781 #endif
6782
6783 #undef GEN_LDX_E
6784 #define GEN_LDX_E(name, ldop, opc2, opc3, type, type2, chk)                   \
6785 GEN_HANDLER_E(name##x, 0x1F, opc2, opc3, 0x00000001, type, type2),
6786
6787 #if defined(TARGET_PPC64)
6788 GEN_LDX_E(ldbr, ld64ur_i64, 0x14, 0x10, PPC_NONE, PPC2_DBRX, CHK_NONE)
6789
6790 /* HV/P7 and later only */
6791 GEN_LDX_HVRM(ldcix, ld64_i64, 0x15, 0x1b, PPC_CILDST)
6792 GEN_LDX_HVRM(lwzcix, ld32u, 0x15, 0x18, PPC_CILDST)
6793 GEN_LDX_HVRM(lhzcix, ld16u, 0x15, 0x19, PPC_CILDST)
6794 GEN_LDX_HVRM(lbzcix, ld8u, 0x15, 0x1a, PPC_CILDST)
6795 #endif
6796 GEN_LDX(lhbr, ld16ur, 0x16, 0x18, PPC_INTEGER)
6797 GEN_LDX(lwbr, ld32ur, 0x16, 0x10, PPC_INTEGER)
6798
6799 /* External PID based load */
6800 #undef GEN_LDEPX
6801 #define GEN_LDEPX(name, ldop, opc2, opc3)                                     \
6802 GEN_HANDLER_E(name##epx, 0x1F, opc2, opc3,                                    \
6803               0x00000001, PPC_NONE, PPC2_BOOKE206),
6804
6805 GEN_LDEPX(lb, DEF_MEMOP(MO_UB), 0x1F, 0x02)
6806 GEN_LDEPX(lh, DEF_MEMOP(MO_UW), 0x1F, 0x08)
6807 GEN_LDEPX(lw, DEF_MEMOP(MO_UL), 0x1F, 0x00)
6808 #if defined(TARGET_PPC64)
6809 GEN_LDEPX(ld, DEF_MEMOP(MO_UQ), 0x1D, 0x00)
6810 #endif
6811
6812 #undef GEN_STX_E
6813 #define GEN_STX_E(name, stop, opc2, opc3, type, type2, chk)                   \
6814 GEN_HANDLER_E(name##x, 0x1F, opc2, opc3, 0x00000000, type, type2),
6815
6816 #if defined(TARGET_PPC64)
6817 GEN_STX_E(stdbr, st64r_i64, 0x14, 0x14, PPC_NONE, PPC2_DBRX, CHK_NONE)
6818 GEN_STX_HVRM(stdcix, st64_i64, 0x15, 0x1f, PPC_CILDST)
6819 GEN_STX_HVRM(stwcix, st32, 0x15, 0x1c, PPC_CILDST)
6820 GEN_STX_HVRM(sthcix, st16, 0x15, 0x1d, PPC_CILDST)
6821 GEN_STX_HVRM(stbcix, st8, 0x15, 0x1e, PPC_CILDST)
6822 #endif
6823 GEN_STX(sthbr, st16r, 0x16, 0x1C, PPC_INTEGER)
6824 GEN_STX(stwbr, st32r, 0x16, 0x14, PPC_INTEGER)
6825
6826 #undef GEN_STEPX
6827 #define GEN_STEPX(name, ldop, opc2, opc3)                                     \
6828 GEN_HANDLER_E(name##epx, 0x1F, opc2, opc3,                                    \
6829               0x00000001, PPC_NONE, PPC2_BOOKE206),
6830
6831 GEN_STEPX(stb, DEF_MEMOP(MO_UB), 0x1F, 0x06)
6832 GEN_STEPX(sth, DEF_MEMOP(MO_UW), 0x1F, 0x0C)
6833 GEN_STEPX(stw, DEF_MEMOP(MO_UL), 0x1F, 0x04)
6834 #if defined(TARGET_PPC64)
6835 GEN_STEPX(std, DEF_MEMOP(MO_UQ), 0x1D, 0x04)
6836 #endif
6837
6838 #undef GEN_CRLOGIC
6839 #define GEN_CRLOGIC(name, tcg_op, opc)                                        \
6840 GEN_HANDLER(name, 0x13, 0x01, opc, 0x00000001, PPC_INTEGER)
6841 GEN_CRLOGIC(crand, tcg_gen_and_i32, 0x08),
6842 GEN_CRLOGIC(crandc, tcg_gen_andc_i32, 0x04),
6843 GEN_CRLOGIC(creqv, tcg_gen_eqv_i32, 0x09),
6844 GEN_CRLOGIC(crnand, tcg_gen_nand_i32, 0x07),
6845 GEN_CRLOGIC(crnor, tcg_gen_nor_i32, 0x01),
6846 GEN_CRLOGIC(cror, tcg_gen_or_i32, 0x0E),
6847 GEN_CRLOGIC(crorc, tcg_gen_orc_i32, 0x0D),
6848 GEN_CRLOGIC(crxor, tcg_gen_xor_i32, 0x06),
6849
6850 #undef GEN_MAC_HANDLER
6851 #define GEN_MAC_HANDLER(name, opc2, opc3)                                     \
6852 GEN_HANDLER(name, 0x04, opc2, opc3, 0x00000000, PPC_405_MAC)
6853 GEN_MAC_HANDLER(macchw, 0x0C, 0x05),
6854 GEN_MAC_HANDLER(macchwo, 0x0C, 0x15),
6855 GEN_MAC_HANDLER(macchws, 0x0C, 0x07),
6856 GEN_MAC_HANDLER(macchwso, 0x0C, 0x17),
6857 GEN_MAC_HANDLER(macchwsu, 0x0C, 0x06),
6858 GEN_MAC_HANDLER(macchwsuo, 0x0C, 0x16),
6859 GEN_MAC_HANDLER(macchwu, 0x0C, 0x04),
6860 GEN_MAC_HANDLER(macchwuo, 0x0C, 0x14),
6861 GEN_MAC_HANDLER(machhw, 0x0C, 0x01),
6862 GEN_MAC_HANDLER(machhwo, 0x0C, 0x11),
6863 GEN_MAC_HANDLER(machhws, 0x0C, 0x03),
6864 GEN_MAC_HANDLER(machhwso, 0x0C, 0x13),
6865 GEN_MAC_HANDLER(machhwsu, 0x0C, 0x02),
6866 GEN_MAC_HANDLER(machhwsuo, 0x0C, 0x12),
6867 GEN_MAC_HANDLER(machhwu, 0x0C, 0x00),
6868 GEN_MAC_HANDLER(machhwuo, 0x0C, 0x10),
6869 GEN_MAC_HANDLER(maclhw, 0x0C, 0x0D),
6870 GEN_MAC_HANDLER(maclhwo, 0x0C, 0x1D),
6871 GEN_MAC_HANDLER(maclhws, 0x0C, 0x0F),
6872 GEN_MAC_HANDLER(maclhwso, 0x0C, 0x1F),
6873 GEN_MAC_HANDLER(maclhwu, 0x0C, 0x0C),
6874 GEN_MAC_HANDLER(maclhwuo, 0x0C, 0x1C),
6875 GEN_MAC_HANDLER(maclhwsu, 0x0C, 0x0E),
6876 GEN_MAC_HANDLER(maclhwsuo, 0x0C, 0x1E),
6877 GEN_MAC_HANDLER(nmacchw, 0x0E, 0x05),
6878 GEN_MAC_HANDLER(nmacchwo, 0x0E, 0x15),
6879 GEN_MAC_HANDLER(nmacchws, 0x0E, 0x07),
6880 GEN_MAC_HANDLER(nmacchwso, 0x0E, 0x17),
6881 GEN_MAC_HANDLER(nmachhw, 0x0E, 0x01),
6882 GEN_MAC_HANDLER(nmachhwo, 0x0E, 0x11),
6883 GEN_MAC_HANDLER(nmachhws, 0x0E, 0x03),
6884 GEN_MAC_HANDLER(nmachhwso, 0x0E, 0x13),
6885 GEN_MAC_HANDLER(nmaclhw, 0x0E, 0x0D),
6886 GEN_MAC_HANDLER(nmaclhwo, 0x0E, 0x1D),
6887 GEN_MAC_HANDLER(nmaclhws, 0x0E, 0x0F),
6888 GEN_MAC_HANDLER(nmaclhwso, 0x0E, 0x1F),
6889 GEN_MAC_HANDLER(mulchw, 0x08, 0x05),
6890 GEN_MAC_HANDLER(mulchwu, 0x08, 0x04),
6891 GEN_MAC_HANDLER(mulhhw, 0x08, 0x01),
6892 GEN_MAC_HANDLER(mulhhwu, 0x08, 0x00),
6893 GEN_MAC_HANDLER(mullhw, 0x08, 0x0D),
6894 GEN_MAC_HANDLER(mullhwu, 0x08, 0x0C),
6895
6896 GEN_HANDLER2_E(tbegin, "tbegin", 0x1F, 0x0E, 0x14, 0x01DFF800, \
6897                PPC_NONE, PPC2_TM),
6898 GEN_HANDLER2_E(tend,   "tend",   0x1F, 0x0E, 0x15, 0x01FFF800, \
6899                PPC_NONE, PPC2_TM),
6900 GEN_HANDLER2_E(tabort, "tabort", 0x1F, 0x0E, 0x1C, 0x03E0F800, \
6901                PPC_NONE, PPC2_TM),
6902 GEN_HANDLER2_E(tabortwc, "tabortwc", 0x1F, 0x0E, 0x18, 0x00000000, \
6903                PPC_NONE, PPC2_TM),
6904 GEN_HANDLER2_E(tabortwci, "tabortwci", 0x1F, 0x0E, 0x1A, 0x00000000, \
6905                PPC_NONE, PPC2_TM),
6906 GEN_HANDLER2_E(tabortdc, "tabortdc", 0x1F, 0x0E, 0x19, 0x00000000, \
6907                PPC_NONE, PPC2_TM),
6908 GEN_HANDLER2_E(tabortdci, "tabortdci", 0x1F, 0x0E, 0x1B, 0x00000000, \
6909                PPC_NONE, PPC2_TM),
6910 GEN_HANDLER2_E(tsr, "tsr", 0x1F, 0x0E, 0x17, 0x03DFF800, \
6911                PPC_NONE, PPC2_TM),
6912 GEN_HANDLER2_E(tcheck, "tcheck", 0x1F, 0x0E, 0x16, 0x007FF800, \
6913                PPC_NONE, PPC2_TM),
6914 GEN_HANDLER2_E(treclaim, "treclaim", 0x1F, 0x0E, 0x1D, 0x03E0F800, \
6915                PPC_NONE, PPC2_TM),
6916 GEN_HANDLER2_E(trechkpt, "trechkpt", 0x1F, 0x0E, 0x1F, 0x03FFF800, \
6917                PPC_NONE, PPC2_TM),
6918
6919 #include "translate/fp-ops.c.inc"
6920
6921 #include "translate/vmx-ops.c.inc"
6922
6923 #include "translate/vsx-ops.c.inc"
6924
6925 #include "translate/spe-ops.c.inc"
6926 };
6927
6928 /*****************************************************************************/
6929 /* Opcode types */
6930 enum {
6931     PPC_DIRECT   = 0, /* Opcode routine        */
6932     PPC_INDIRECT = 1, /* Indirect opcode table */
6933 };
6934
6935 #define PPC_OPCODE_MASK 0x3
6936
6937 static inline int is_indirect_opcode(void *handler)
6938 {
6939     return ((uintptr_t)handler & PPC_OPCODE_MASK) == PPC_INDIRECT;
6940 }
6941
6942 static inline opc_handler_t **ind_table(void *handler)
6943 {
6944     return (opc_handler_t **)((uintptr_t)handler & ~PPC_OPCODE_MASK);
6945 }
6946
6947 /* Instruction table creation */
6948 /* Opcodes tables creation */
6949 static void fill_new_table(opc_handler_t **table, int len)
6950 {
6951     int i;
6952
6953     for (i = 0; i < len; i++) {
6954         table[i] = &invalid_handler;
6955     }
6956 }
6957
6958 static int create_new_table(opc_handler_t **table, unsigned char idx)
6959 {
6960     opc_handler_t **tmp;
6961
6962     tmp = g_new(opc_handler_t *, PPC_CPU_INDIRECT_OPCODES_LEN);
6963     fill_new_table(tmp, PPC_CPU_INDIRECT_OPCODES_LEN);
6964     table[idx] = (opc_handler_t *)((uintptr_t)tmp | PPC_INDIRECT);
6965
6966     return 0;
6967 }
6968
6969 static int insert_in_table(opc_handler_t **table, unsigned char idx,
6970                             opc_handler_t *handler)
6971 {
6972     if (table[idx] != &invalid_handler) {
6973         return -1;
6974     }
6975     table[idx] = handler;
6976
6977     return 0;
6978 }
6979
6980 static int register_direct_insn(opc_handler_t **ppc_opcodes,
6981                                 unsigned char idx, opc_handler_t *handler)
6982 {
6983     if (insert_in_table(ppc_opcodes, idx, handler) < 0) {
6984         printf("*** ERROR: opcode %02x already assigned in main "
6985                "opcode table\n", idx);
6986         return -1;
6987     }
6988
6989     return 0;
6990 }
6991
6992 static int register_ind_in_table(opc_handler_t **table,
6993                                  unsigned char idx1, unsigned char idx2,
6994                                  opc_handler_t *handler)
6995 {
6996     if (table[idx1] == &invalid_handler) {
6997         if (create_new_table(table, idx1) < 0) {
6998             printf("*** ERROR: unable to create indirect table "
6999                    "idx=%02x\n", idx1);
7000             return -1;
7001         }
7002     } else {
7003         if (!is_indirect_opcode(table[idx1])) {
7004             printf("*** ERROR: idx %02x already assigned to a direct "
7005                    "opcode\n", idx1);
7006             return -1;
7007         }
7008     }
7009     if (handler != NULL &&
7010         insert_in_table(ind_table(table[idx1]), idx2, handler) < 0) {
7011         printf("*** ERROR: opcode %02x already assigned in "
7012                "opcode table %02x\n", idx2, idx1);
7013         return -1;
7014     }
7015
7016     return 0;
7017 }
7018
7019 static int register_ind_insn(opc_handler_t **ppc_opcodes,
7020                              unsigned char idx1, unsigned char idx2,
7021                              opc_handler_t *handler)
7022 {
7023     return register_ind_in_table(ppc_opcodes, idx1, idx2, handler);
7024 }
7025
7026 static int register_dblind_insn(opc_handler_t **ppc_opcodes,
7027                                 unsigned char idx1, unsigned char idx2,
7028                                 unsigned char idx3, opc_handler_t *handler)
7029 {
7030     if (register_ind_in_table(ppc_opcodes, idx1, idx2, NULL) < 0) {
7031         printf("*** ERROR: unable to join indirect table idx "
7032                "[%02x-%02x]\n", idx1, idx2);
7033         return -1;
7034     }
7035     if (register_ind_in_table(ind_table(ppc_opcodes[idx1]), idx2, idx3,
7036                               handler) < 0) {
7037         printf("*** ERROR: unable to insert opcode "
7038                "[%02x-%02x-%02x]\n", idx1, idx2, idx3);
7039         return -1;
7040     }
7041
7042     return 0;
7043 }
7044
7045 static int register_trplind_insn(opc_handler_t **ppc_opcodes,
7046                                  unsigned char idx1, unsigned char idx2,
7047                                  unsigned char idx3, unsigned char idx4,
7048                                  opc_handler_t *handler)
7049 {
7050     opc_handler_t **table;
7051
7052     if (register_ind_in_table(ppc_opcodes, idx1, idx2, NULL) < 0) {
7053         printf("*** ERROR: unable to join indirect table idx "
7054                "[%02x-%02x]\n", idx1, idx2);
7055         return -1;
7056     }
7057     table = ind_table(ppc_opcodes[idx1]);
7058     if (register_ind_in_table(table, idx2, idx3, NULL) < 0) {
7059         printf("*** ERROR: unable to join 2nd-level indirect table idx "
7060                "[%02x-%02x-%02x]\n", idx1, idx2, idx3);
7061         return -1;
7062     }
7063     table = ind_table(table[idx2]);
7064     if (register_ind_in_table(table, idx3, idx4, handler) < 0) {
7065         printf("*** ERROR: unable to insert opcode "
7066                "[%02x-%02x-%02x-%02x]\n", idx1, idx2, idx3, idx4);
7067         return -1;
7068     }
7069     return 0;
7070 }
7071 static int register_insn(opc_handler_t **ppc_opcodes, opcode_t *insn)
7072 {
7073     if (insn->opc2 != 0xFF) {
7074         if (insn->opc3 != 0xFF) {
7075             if (insn->opc4 != 0xFF) {
7076                 if (register_trplind_insn(ppc_opcodes, insn->opc1, insn->opc2,
7077                                           insn->opc3, insn->opc4,
7078                                           &insn->handler) < 0) {
7079                     return -1;
7080                 }
7081             } else {
7082                 if (register_dblind_insn(ppc_opcodes, insn->opc1, insn->opc2,
7083                                          insn->opc3, &insn->handler) < 0) {
7084                     return -1;
7085                 }
7086             }
7087         } else {
7088             if (register_ind_insn(ppc_opcodes, insn->opc1,
7089                                   insn->opc2, &insn->handler) < 0) {
7090                 return -1;
7091             }
7092         }
7093     } else {
7094         if (register_direct_insn(ppc_opcodes, insn->opc1, &insn->handler) < 0) {
7095             return -1;
7096         }
7097     }
7098
7099     return 0;
7100 }
7101
7102 static int test_opcode_table(opc_handler_t **table, int len)
7103 {
7104     int i, count, tmp;
7105
7106     for (i = 0, count = 0; i < len; i++) {
7107         /* Consistency fixup */
7108         if (table[i] == NULL) {
7109             table[i] = &invalid_handler;
7110         }
7111         if (table[i] != &invalid_handler) {
7112             if (is_indirect_opcode(table[i])) {
7113                 tmp = test_opcode_table(ind_table(table[i]),
7114                     PPC_CPU_INDIRECT_OPCODES_LEN);
7115                 if (tmp == 0) {
7116                     free(table[i]);
7117                     table[i] = &invalid_handler;
7118                 } else {
7119                     count++;
7120                 }
7121             } else {
7122                 count++;
7123             }
7124         }
7125     }
7126
7127     return count;
7128 }
7129
7130 static void fix_opcode_tables(opc_handler_t **ppc_opcodes)
7131 {
7132     if (test_opcode_table(ppc_opcodes, PPC_CPU_OPCODES_LEN) == 0) {
7133         printf("*** WARNING: no opcode defined !\n");
7134     }
7135 }
7136
7137 /*****************************************************************************/
7138 void create_ppc_opcodes(PowerPCCPU *cpu, Error **errp)
7139 {
7140     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
7141     opcode_t *opc;
7142
7143     fill_new_table(cpu->opcodes, PPC_CPU_OPCODES_LEN);
7144     for (opc = opcodes; opc < &opcodes[ARRAY_SIZE(opcodes)]; opc++) {
7145         if (((opc->handler.type & pcc->insns_flags) != 0) ||
7146             ((opc->handler.type2 & pcc->insns_flags2) != 0)) {
7147             if (register_insn(cpu->opcodes, opc) < 0) {
7148                 error_setg(errp, "ERROR initializing PowerPC instruction "
7149                            "0x%02x 0x%02x 0x%02x", opc->opc1, opc->opc2,
7150                            opc->opc3);
7151                 return;
7152             }
7153         }
7154     }
7155     fix_opcode_tables(cpu->opcodes);
7156     fflush(stdout);
7157     fflush(stderr);
7158 }
7159
7160 void destroy_ppc_opcodes(PowerPCCPU *cpu)
7161 {
7162     opc_handler_t **table, **table_2;
7163     int i, j, k;
7164
7165     for (i = 0; i < PPC_CPU_OPCODES_LEN; i++) {
7166         if (cpu->opcodes[i] == &invalid_handler) {
7167             continue;
7168         }
7169         if (is_indirect_opcode(cpu->opcodes[i])) {
7170             table = ind_table(cpu->opcodes[i]);
7171             for (j = 0; j < PPC_CPU_INDIRECT_OPCODES_LEN; j++) {
7172                 if (table[j] == &invalid_handler) {
7173                     continue;
7174                 }
7175                 if (is_indirect_opcode(table[j])) {
7176                     table_2 = ind_table(table[j]);
7177                     for (k = 0; k < PPC_CPU_INDIRECT_OPCODES_LEN; k++) {
7178                         if (table_2[k] != &invalid_handler &&
7179                             is_indirect_opcode(table_2[k])) {
7180                             g_free((opc_handler_t *)((uintptr_t)table_2[k] &
7181                                                      ~PPC_INDIRECT));
7182                         }
7183                     }
7184                     g_free((opc_handler_t *)((uintptr_t)table[j] &
7185                                              ~PPC_INDIRECT));
7186                 }
7187             }
7188             g_free((opc_handler_t *)((uintptr_t)cpu->opcodes[i] &
7189                 ~PPC_INDIRECT));
7190         }
7191     }
7192 }
7193
7194 int ppc_fixup_cpu(PowerPCCPU *cpu)
7195 {
7196     CPUPPCState *env = &cpu->env;
7197
7198     /*
7199      * TCG doesn't (yet) emulate some groups of instructions that are
7200      * implemented on some otherwise supported CPUs (e.g. VSX and
7201      * decimal floating point instructions on POWER7).  We remove
7202      * unsupported instruction groups from the cpu state's instruction
7203      * masks and hope the guest can cope.  For at least the pseries
7204      * machine, the unavailability of these instructions can be
7205      * advertised to the guest via the device tree.
7206      */
7207     if ((env->insns_flags & ~PPC_TCG_INSNS)
7208         || (env->insns_flags2 & ~PPC_TCG_INSNS2)) {
7209         warn_report("Disabling some instructions which are not "
7210                     "emulated by TCG (0x%" PRIx64 ", 0x%" PRIx64 ")",
7211                     env->insns_flags & ~PPC_TCG_INSNS,
7212                     env->insns_flags2 & ~PPC_TCG_INSNS2);
7213     }
7214     env->insns_flags &= PPC_TCG_INSNS;
7215     env->insns_flags2 &= PPC_TCG_INSNS2;
7216     return 0;
7217 }
7218
7219 static bool decode_legacy(PowerPCCPU *cpu, DisasContext *ctx, uint32_t insn)
7220 {
7221     opc_handler_t **table, *handler;
7222     uint32_t inval;
7223
7224     ctx->opcode = insn;
7225
7226     LOG_DISAS("translate opcode %08x (%02x %02x %02x %02x) (%s)\n",
7227               insn, opc1(insn), opc2(insn), opc3(insn), opc4(insn),
7228               ctx->le_mode ? "little" : "big");
7229
7230     table = cpu->opcodes;
7231     handler = table[opc1(insn)];
7232     if (is_indirect_opcode(handler)) {
7233         table = ind_table(handler);
7234         handler = table[opc2(insn)];
7235         if (is_indirect_opcode(handler)) {
7236             table = ind_table(handler);
7237             handler = table[opc3(insn)];
7238             if (is_indirect_opcode(handler)) {
7239                 table = ind_table(handler);
7240                 handler = table[opc4(insn)];
7241             }
7242         }
7243     }
7244
7245     /* Is opcode *REALLY* valid ? */
7246     if (unlikely(handler->handler == &gen_invalid)) {
7247         qemu_log_mask(LOG_GUEST_ERROR, "invalid/unsupported opcode: "
7248                       "%02x - %02x - %02x - %02x (%08x) "
7249                       TARGET_FMT_lx "\n",
7250                       opc1(insn), opc2(insn), opc3(insn), opc4(insn),
7251                       insn, ctx->cia);
7252         return false;
7253     }
7254
7255     if (unlikely(handler->type & (PPC_SPE | PPC_SPE_SINGLE | PPC_SPE_DOUBLE)
7256                  && Rc(insn))) {
7257         inval = handler->inval2;
7258     } else {
7259         inval = handler->inval1;
7260     }
7261
7262     if (unlikely((insn & inval) != 0)) {
7263         qemu_log_mask(LOG_GUEST_ERROR, "invalid bits: %08x for opcode: "
7264                       "%02x - %02x - %02x - %02x (%08x) "
7265                       TARGET_FMT_lx "\n", insn & inval,
7266                       opc1(insn), opc2(insn), opc3(insn), opc4(insn),
7267                       insn, ctx->cia);
7268         return false;
7269     }
7270
7271     handler->handler(ctx);
7272     return true;
7273 }
7274
7275 static void ppc_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
7276 {
7277     DisasContext *ctx = container_of(dcbase, DisasContext, base);
7278     CPUPPCState *env = cs->env_ptr;
7279     uint32_t hflags = ctx->base.tb->flags;
7280
7281     ctx->spr_cb = env->spr_cb;
7282     ctx->pr = (hflags >> HFLAGS_PR) & 1;
7283     ctx->mem_idx = (hflags >> HFLAGS_DMMU_IDX) & 7;
7284     ctx->dr = (hflags >> HFLAGS_DR) & 1;
7285     ctx->hv = (hflags >> HFLAGS_HV) & 1;
7286     ctx->insns_flags = env->insns_flags;
7287     ctx->insns_flags2 = env->insns_flags2;
7288     ctx->access_type = -1;
7289     ctx->need_access_type = !mmu_is_64bit(env->mmu_model);
7290     ctx->le_mode = (hflags >> HFLAGS_LE) & 1;
7291     ctx->default_tcg_memop_mask = ctx->le_mode ? MO_LE : MO_BE;
7292     ctx->flags = env->flags;
7293 #if defined(TARGET_PPC64)
7294     ctx->sf_mode = (hflags >> HFLAGS_64) & 1;
7295     ctx->has_cfar = !!(env->flags & POWERPC_FLAG_CFAR);
7296 #endif
7297     ctx->lazy_tlb_flush = env->mmu_model == POWERPC_MMU_32B
7298         || env->mmu_model & POWERPC_MMU_64;
7299
7300     ctx->fpu_enabled = (hflags >> HFLAGS_FP) & 1;
7301     ctx->spe_enabled = (hflags >> HFLAGS_SPE) & 1;
7302     ctx->altivec_enabled = (hflags >> HFLAGS_VR) & 1;
7303     ctx->vsx_enabled = (hflags >> HFLAGS_VSX) & 1;
7304     ctx->tm_enabled = (hflags >> HFLAGS_TM) & 1;
7305     ctx->gtse = (hflags >> HFLAGS_GTSE) & 1;
7306     ctx->hr = (hflags >> HFLAGS_HR) & 1;
7307     ctx->mmcr0_pmcc0 = (hflags >> HFLAGS_PMCC0) & 1;
7308     ctx->mmcr0_pmcc1 = (hflags >> HFLAGS_PMCC1) & 1;
7309     ctx->mmcr0_pmcjce = (hflags >> HFLAGS_PMCJCE) & 1;
7310     ctx->pmc_other = (hflags >> HFLAGS_PMC_OTHER) & 1;
7311     ctx->pmu_insn_cnt = (hflags >> HFLAGS_INSN_CNT) & 1;
7312
7313     ctx->singlestep_enabled = 0;
7314     if ((hflags >> HFLAGS_SE) & 1) {
7315         ctx->singlestep_enabled |= CPU_SINGLE_STEP;
7316         ctx->base.max_insns = 1;
7317     }
7318     if ((hflags >> HFLAGS_BE) & 1) {
7319         ctx->singlestep_enabled |= CPU_BRANCH_STEP;
7320     }
7321 }
7322
7323 static void ppc_tr_tb_start(DisasContextBase *db, CPUState *cs)
7324 {
7325 }
7326
7327 static void ppc_tr_insn_start(DisasContextBase *dcbase, CPUState *cs)
7328 {
7329     tcg_gen_insn_start(dcbase->pc_next);
7330 }
7331
7332 static bool is_prefix_insn(DisasContext *ctx, uint32_t insn)
7333 {
7334     REQUIRE_INSNS_FLAGS2(ctx, ISA310);
7335     return opc1(insn) == 1;
7336 }
7337
7338 static void ppc_tr_translate_insn(DisasContextBase *dcbase, CPUState *cs)
7339 {
7340     DisasContext *ctx = container_of(dcbase, DisasContext, base);
7341     PowerPCCPU *cpu = POWERPC_CPU(cs);
7342     CPUPPCState *env = cs->env_ptr;
7343     target_ulong pc;
7344     uint32_t insn;
7345     bool ok;
7346
7347     LOG_DISAS("----------------\n");
7348     LOG_DISAS("nip=" TARGET_FMT_lx " super=%d ir=%d\n",
7349               ctx->base.pc_next, ctx->mem_idx, (int)msr_ir);
7350
7351     ctx->cia = pc = ctx->base.pc_next;
7352     insn = translator_ldl_swap(env, dcbase, pc, need_byteswap(ctx));
7353     ctx->base.pc_next = pc += 4;
7354
7355     if (!is_prefix_insn(ctx, insn)) {
7356         ok = (decode_insn32(ctx, insn) ||
7357               decode_legacy(cpu, ctx, insn));
7358     } else if ((pc & 63) == 0) {
7359         /*
7360          * Power v3.1, section 1.9 Exceptions:
7361          * attempt to execute a prefixed instruction that crosses a
7362          * 64-byte address boundary (system alignment error).
7363          */
7364         gen_exception_err(ctx, POWERPC_EXCP_ALIGN, POWERPC_EXCP_ALIGN_INSN);
7365         ok = true;
7366     } else {
7367         uint32_t insn2 = translator_ldl_swap(env, dcbase, pc,
7368                                              need_byteswap(ctx));
7369         ctx->base.pc_next = pc += 4;
7370         ok = decode_insn64(ctx, deposit64(insn2, 32, 32, insn));
7371     }
7372     if (!ok) {
7373         gen_invalid(ctx);
7374     }
7375
7376     /* End the TB when crossing a page boundary. */
7377     if (ctx->base.is_jmp == DISAS_NEXT && !(pc & ~TARGET_PAGE_MASK)) {
7378         ctx->base.is_jmp = DISAS_TOO_MANY;
7379     }
7380 }
7381
7382 static void ppc_tr_tb_stop(DisasContextBase *dcbase, CPUState *cs)
7383 {
7384     DisasContext *ctx = container_of(dcbase, DisasContext, base);
7385     DisasJumpType is_jmp = ctx->base.is_jmp;
7386     target_ulong nip = ctx->base.pc_next;
7387
7388     if (is_jmp == DISAS_NORETURN) {
7389         /* We have already exited the TB. */
7390         return;
7391     }
7392
7393     /* Honor single stepping. */
7394     if (unlikely(ctx->singlestep_enabled & CPU_SINGLE_STEP)
7395         && (nip <= 0x100 || nip > 0xf00)) {
7396         switch (is_jmp) {
7397         case DISAS_TOO_MANY:
7398         case DISAS_EXIT_UPDATE:
7399         case DISAS_CHAIN_UPDATE:
7400             gen_update_nip(ctx, nip);
7401             break;
7402         case DISAS_EXIT:
7403         case DISAS_CHAIN:
7404             break;
7405         default:
7406             g_assert_not_reached();
7407         }
7408
7409         gen_debug_exception(ctx);
7410         return;
7411     }
7412
7413     switch (is_jmp) {
7414     case DISAS_TOO_MANY:
7415         if (use_goto_tb(ctx, nip)) {
7416             pmu_count_insns(ctx);
7417             tcg_gen_goto_tb(0);
7418             gen_update_nip(ctx, nip);
7419             tcg_gen_exit_tb(ctx->base.tb, 0);
7420             break;
7421         }
7422         /* fall through */
7423     case DISAS_CHAIN_UPDATE:
7424         gen_update_nip(ctx, nip);
7425         /* fall through */
7426     case DISAS_CHAIN:
7427         /*
7428          * tcg_gen_lookup_and_goto_ptr will exit the TB if
7429          * CF_NO_GOTO_PTR is set. Count insns now.
7430          */
7431         if (ctx->base.tb->flags & CF_NO_GOTO_PTR) {
7432             pmu_count_insns(ctx);
7433         }
7434
7435         tcg_gen_lookup_and_goto_ptr();
7436         break;
7437
7438     case DISAS_EXIT_UPDATE:
7439         gen_update_nip(ctx, nip);
7440         /* fall through */
7441     case DISAS_EXIT:
7442         pmu_count_insns(ctx);
7443         tcg_gen_exit_tb(NULL, 0);
7444         break;
7445
7446     default:
7447         g_assert_not_reached();
7448     }
7449 }
7450
7451 static void ppc_tr_disas_log(const DisasContextBase *dcbase,
7452                              CPUState *cs, FILE *logfile)
7453 {
7454     fprintf(logfile, "IN: %s\n", lookup_symbol(dcbase->pc_first));
7455     target_disas(logfile, cs, dcbase->pc_first, dcbase->tb->size);
7456 }
7457
7458 static const TranslatorOps ppc_tr_ops = {
7459     .init_disas_context = ppc_tr_init_disas_context,
7460     .tb_start           = ppc_tr_tb_start,
7461     .insn_start         = ppc_tr_insn_start,
7462     .translate_insn     = ppc_tr_translate_insn,
7463     .tb_stop            = ppc_tr_tb_stop,
7464     .disas_log          = ppc_tr_disas_log,
7465 };
7466
7467 void gen_intermediate_code(CPUState *cs, TranslationBlock *tb, int *max_insns,
7468                            target_ulong pc, void *host_pc)
7469 {
7470     DisasContext ctx;
7471
7472     translator_loop(cs, tb, max_insns, pc, host_pc, &ppc_tr_ops, &ctx.base);
7473 }