target/ppc/excp_helper.c

   1 /*
   2  *  PowerPC exception emulation helpers for QEMU.
   3  *
   4  *  Copyright (c) 2003-2007 Jocelyn Mayer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include "qemu/osdep.h"
  20 #include "qemu/main-loop.h"
  21 #include "cpu.h"
  22 #include "exec/exec-all.h"
  23 #include "internal.h"
  24 #include "helper_regs.h"
  25
  26 #include "trace.h"
  27
  28 #ifdef CONFIG_TCG
  29 #include "exec/helper-proto.h"
  30 #include "exec/cpu_ldst.h"
  31 #endif
  32
  33 /*****************************************************************************/
  34 /* Exception processing */
  35 #if !defined(CONFIG_USER_ONLY)
  36
  37 static const char *powerpc_excp_name(int excp)
  38 {
  39     switch (excp) {
  40     case POWERPC_EXCP_CRITICAL: return "CRITICAL";
  41     case POWERPC_EXCP_MCHECK:   return "MCHECK";
  42     case POWERPC_EXCP_DSI:      return "DSI";
  43     case POWERPC_EXCP_ISI:      return "ISI";
  44     case POWERPC_EXCP_EXTERNAL: return "EXTERNAL";
  45     case POWERPC_EXCP_ALIGN:    return "ALIGN";
  46     case POWERPC_EXCP_PROGRAM:  return "PROGRAM";
  47     case POWERPC_EXCP_FPU:      return "FPU";
  48     case POWERPC_EXCP_SYSCALL:  return "SYSCALL";
  49     case POWERPC_EXCP_APU:      return "APU";
  50     case POWERPC_EXCP_DECR:     return "DECR";
  51     case POWERPC_EXCP_FIT:      return "FIT";
  52     case POWERPC_EXCP_WDT:      return "WDT";
  53     case POWERPC_EXCP_DTLB:     return "DTLB";
  54     case POWERPC_EXCP_ITLB:     return "ITLB";
  55     case POWERPC_EXCP_DEBUG:    return "DEBUG";
  56     case POWERPC_EXCP_SPEU:     return "SPEU";
  57     case POWERPC_EXCP_EFPDI:    return "EFPDI";
  58     case POWERPC_EXCP_EFPRI:    return "EFPRI";
  59     case POWERPC_EXCP_EPERFM:   return "EPERFM";
  60     case POWERPC_EXCP_DOORI:    return "DOORI";
  61     case POWERPC_EXCP_DOORCI:   return "DOORCI";
  62     case POWERPC_EXCP_GDOORI:   return "GDOORI";
  63     case POWERPC_EXCP_GDOORCI:  return "GDOORCI";
  64     case POWERPC_EXCP_HYPPRIV:  return "HYPPRIV";
  65     case POWERPC_EXCP_RESET:    return "RESET";
  66     case POWERPC_EXCP_DSEG:     return "DSEG";
  67     case POWERPC_EXCP_ISEG:     return "ISEG";
  68     case POWERPC_EXCP_HDECR:    return "HDECR";
  69     case POWERPC_EXCP_TRACE:    return "TRACE";
  70     case POWERPC_EXCP_HDSI:     return "HDSI";
  71     case POWERPC_EXCP_HISI:     return "HISI";
  72     case POWERPC_EXCP_HDSEG:    return "HDSEG";
  73     case POWERPC_EXCP_HISEG:    return "HISEG";
  74     case POWERPC_EXCP_VPU:      return "VPU";
  75     case POWERPC_EXCP_PIT:      return "PIT";
  76     case POWERPC_EXCP_IO:       return "IO";
  77     case POWERPC_EXCP_RUNM:     return "RUNM";
  78     case POWERPC_EXCP_EMUL:     return "EMUL";
  79     case POWERPC_EXCP_IFTLB:    return "IFTLB";
  80     case POWERPC_EXCP_DLTLB:    return "DLTLB";
  81     case POWERPC_EXCP_DSTLB:    return "DSTLB";
  82     case POWERPC_EXCP_FPA:      return "FPA";
  83     case POWERPC_EXCP_DABR:     return "DABR";
  84     case POWERPC_EXCP_IABR:     return "IABR";
  85     case POWERPC_EXCP_SMI:      return "SMI";
  86     case POWERPC_EXCP_PERFM:    return "PERFM";
  87     case POWERPC_EXCP_THERM:    return "THERM";
  88     case POWERPC_EXCP_VPUA:     return "VPUA";
  89     case POWERPC_EXCP_SOFTP:    return "SOFTP";
  90     case POWERPC_EXCP_MAINT:    return "MAINT";
  91     case POWERPC_EXCP_MEXTBR:   return "MEXTBR";
  92     case POWERPC_EXCP_NMEXTBR:  return "NMEXTBR";
  93     case POWERPC_EXCP_ITLBE:    return "ITLBE";
  94     case POWERPC_EXCP_DTLBE:    return "DTLBE";
  95     case POWERPC_EXCP_VSXU:     return "VSXU";
  96     case POWERPC_EXCP_FU:       return "FU";
  97     case POWERPC_EXCP_HV_EMU:   return "HV_EMU";
  98     case POWERPC_EXCP_HV_MAINT: return "HV_MAINT";
  99     case POWERPC_EXCP_HV_FU:    return "HV_FU";
 100     case POWERPC_EXCP_SDOOR:    return "SDOOR";
 101     case POWERPC_EXCP_SDOOR_HV: return "SDOOR_HV";
 102     case POWERPC_EXCP_HVIRT:    return "HVIRT";
 103     case POWERPC_EXCP_SYSCALL_VECTORED: return "SYSCALL_VECTORED";
 104     default:
 105         g_assert_not_reached();
 106     }
 107 }
 108
 109 static void dump_syscall(CPUPPCState *env)
 110 {
 111     qemu_log_mask(CPU_LOG_INT, "syscall r0=%016" PRIx64
 112                   " r3=%016" PRIx64 " r4=%016" PRIx64 " r5=%016" PRIx64
 113                   " r6=%016" PRIx64 " r7=%016" PRIx64 " r8=%016" PRIx64
 114                   " nip=" TARGET_FMT_lx "\n",
 115                   ppc_dump_gpr(env, 0), ppc_dump_gpr(env, 3),
 116                   ppc_dump_gpr(env, 4), ppc_dump_gpr(env, 5),
 117                   ppc_dump_gpr(env, 6), ppc_dump_gpr(env, 7),
 118                   ppc_dump_gpr(env, 8), env->nip);
 119 }
 120
 121 static void dump_hcall(CPUPPCState *env)
 122 {
 123     qemu_log_mask(CPU_LOG_INT, "hypercall r3=%016" PRIx64
 124                   " r4=%016" PRIx64 " r5=%016" PRIx64 " r6=%016" PRIx64
 125                   " r7=%016" PRIx64 " r8=%016" PRIx64 " r9=%016" PRIx64
 126                   " r10=%016" PRIx64 " r11=%016" PRIx64 " r12=%016" PRIx64
 127                   " nip=" TARGET_FMT_lx "\n",
 128                   ppc_dump_gpr(env, 3), ppc_dump_gpr(env, 4),
 129                   ppc_dump_gpr(env, 5), ppc_dump_gpr(env, 6),
 130                   ppc_dump_gpr(env, 7), ppc_dump_gpr(env, 8),
 131                   ppc_dump_gpr(env, 9), ppc_dump_gpr(env, 10),
 132                   ppc_dump_gpr(env, 11), ppc_dump_gpr(env, 12),
 133                   env->nip);
 134 }
 135
 136 static void ppc_excp_debug_sw_tlb(CPUPPCState *env, int excp)
 137 {
 138     const char *es;
 139     target_ulong *miss, *cmp;
 140     int en;
 141
 142     if (!qemu_loglevel_mask(CPU_LOG_MMU)) {
 143         return;
 144     }
 145
 146     if (excp == POWERPC_EXCP_IFTLB) {
 147         es = "I";
 148         en = 'I';
 149         miss = &env->spr[SPR_IMISS];
 150         cmp = &env->spr[SPR_ICMP];
 151     } else {
 152         if (excp == POWERPC_EXCP_DLTLB) {
 153             es = "DL";
 154         } else {
 155             es = "DS";
 156         }
 157         en = 'D';
 158         miss = &env->spr[SPR_DMISS];
 159         cmp = &env->spr[SPR_DCMP];
 160     }
 161     qemu_log("6xx %sTLB miss: %cM " TARGET_FMT_lx " %cC "
 162              TARGET_FMT_lx " H1 " TARGET_FMT_lx " H2 "
 163              TARGET_FMT_lx " %08x\n", es, en, *miss, en, *cmp,
 164              env->spr[SPR_HASH1], env->spr[SPR_HASH2],
 165              env->error_code);
 166 }
 167
 168
 169 static int powerpc_reset_wakeup(CPUState *cs, CPUPPCState *env, int excp,
 170                                 target_ulong *msr)
 171 {
 172     /* We no longer are in a PM state */
 173     env->resume_as_sreset = false;
 174
 175     /* Pretend to be returning from doze always as we don't lose state */
 176     *msr |= SRR1_WS_NOLOSS;
 177
 178     /* Machine checks are sent normally */
 179     if (excp == POWERPC_EXCP_MCHECK) {
 180         return excp;
 181     }
 182     switch (excp) {
 183     case POWERPC_EXCP_RESET:
 184         *msr |= SRR1_WAKERESET;
 185         break;
 186     case POWERPC_EXCP_EXTERNAL:
 187         *msr |= SRR1_WAKEEE;
 188         break;
 189     case POWERPC_EXCP_DECR:
 190         *msr |= SRR1_WAKEDEC;
 191         break;
 192     case POWERPC_EXCP_SDOOR:
 193         *msr |= SRR1_WAKEDBELL;
 194         break;
 195     case POWERPC_EXCP_SDOOR_HV:
 196         *msr |= SRR1_WAKEHDBELL;
 197         break;
 198     case POWERPC_EXCP_HV_MAINT:
 199         *msr |= SRR1_WAKEHMI;
 200         break;
 201     case POWERPC_EXCP_HVIRT:
 202         *msr |= SRR1_WAKEHVI;
 203         break;
 204     default:
 205         cpu_abort(cs, "Unsupported exception %d in Power Save mode\n",
 206                   excp);
 207     }
 208     return POWERPC_EXCP_RESET;
 209 }
 210
 211 /*
 212  * AIL - Alternate Interrupt Location, a mode that allows interrupts to be
 213  * taken with the MMU on, and which uses an alternate location (e.g., so the
 214  * kernel/hv can map the vectors there with an effective address).
 215  *
 216  * An interrupt is considered to be taken "with AIL" or "AIL applies" if they
 217  * are delivered in this way. AIL requires the LPCR to be set to enable this
 218  * mode, and then a number of conditions have to be true for AIL to apply.
 219  *
 220  * First of all, SRESET, MCE, and HMI are always delivered without AIL, because
 221  * they specifically want to be in real mode (e.g., the MCE might be signaling
 222  * a SLB multi-hit which requires SLB flush before the MMU can be enabled).
 223  *
 224  * After that, behaviour depends on the current MSR[IR], MSR[DR], MSR[HV],
 225  * whether or not the interrupt changes MSR[HV] from 0 to 1, and the current
 226  * radix mode (LPCR[HR]).
 227  *
 228  * POWER8, POWER9 with LPCR[HR]=0
 229  * | LPCR[AIL] | MSR[IR||DR] | MSR[HV] | new MSR[HV] | AIL |
 230  * +-----------+-------------+---------+-------------+-----+
 231  * | a         | 00/01/10    | x       | x           | 0   |
 232  * | a         | 11          | 0       | 1           | 0   |
 233  * | a         | 11          | 1       | 1           | a   |
 234  * | a         | 11          | 0       | 0           | a   |
 235  * +-------------------------------------------------------+
 236  *
 237  * POWER9 with LPCR[HR]=1
 238  * | LPCR[AIL] | MSR[IR||DR] | MSR[HV] | new MSR[HV] | AIL |
 239  * +-----------+-------------+---------+-------------+-----+
 240  * | a         | 00/01/10    | x       | x           | 0   |
 241  * | a         | 11          | x       | x           | a   |
 242  * +-------------------------------------------------------+
 243  *
 244  * The difference with POWER9 being that MSR[HV] 0->1 interrupts can be sent to
 245  * the hypervisor in AIL mode if the guest is radix. This is good for
 246  * performance but allows the guest to influence the AIL of hypervisor
 247  * interrupts using its MSR, and also the hypervisor must disallow guest
 248  * interrupts (MSR[HV] 0->0) from using AIL if the hypervisor does not want to
 249  * use AIL for its MSR[HV] 0->1 interrupts.
 250  *
 251  * POWER10 addresses those issues with a new LPCR[HAIL] bit that is applied to
 252  * interrupts that begin execution with MSR[HV]=1 (so both MSR[HV] 0->1 and
 253  * MSR[HV] 1->1).
 254  *
 255  * HAIL=1 is equivalent to AIL=3, for interrupts delivered with MSR[HV]=1.
 256  *
 257  * POWER10 behaviour is
 258  * | LPCR[AIL] | LPCR[HAIL] | MSR[IR||DR] | MSR[HV] | new MSR[HV] | AIL |
 259  * +-----------+------------+-------------+---------+-------------+-----+
 260  * | a         | h          | 00/01/10    | 0       | 0           | 0   |
 261  * | a         | h          | 11          | 0       | 0           | a   |
 262  * | a         | h          | x           | 0       | 1           | h   |
 263  * | a         | h          | 00/01/10    | 1       | 1           | 0   |
 264  * | a         | h          | 11          | 1       | 1           | h   |
 265  * +--------------------------------------------------------------------+
 266  */
 267 static void ppc_excp_apply_ail(PowerPCCPU *cpu, int excp_model, int excp,
 268                                       target_ulong msr,
 269                                       target_ulong *new_msr,
 270                                       target_ulong *vector)
 271 {
 272 #if defined(TARGET_PPC64)
 273     CPUPPCState *env = &cpu->env;
 274     bool mmu_all_on = ((msr >> MSR_IR) & 1) && ((msr >> MSR_DR) & 1);
 275     bool hv_escalation = !(msr & MSR_HVB) && (*new_msr & MSR_HVB);
 276     int ail = 0;
 277
 278     if (excp == POWERPC_EXCP_MCHECK ||
 279         excp == POWERPC_EXCP_RESET ||
 280         excp == POWERPC_EXCP_HV_MAINT) {
 281         /* SRESET, MCE, HMI never apply AIL */
 282         return;
 283     }
 284
 285     if (excp_model == POWERPC_EXCP_POWER8 ||
 286         excp_model == POWERPC_EXCP_POWER9) {
 287         if (!mmu_all_on) {
 288             /* AIL only works if MSR[IR] and MSR[DR] are both enabled. */
 289             return;
 290         }
 291         if (hv_escalation && !(env->spr[SPR_LPCR] & LPCR_HR)) {
 292             /*
 293              * AIL does not work if there is a MSR[HV] 0->1 transition and the
 294              * partition is in HPT mode. For radix guests, such interrupts are
 295              * allowed to be delivered to the hypervisor in ail mode.
 296              */
 297             return;
 298         }
 299
 300         ail = (env->spr[SPR_LPCR] & LPCR_AIL) >> LPCR_AIL_SHIFT;
 301         if (ail == 0) {
 302             return;
 303         }
 304         if (ail == 1) {
 305             /* AIL=1 is reserved, treat it like AIL=0 */
 306             return;
 307         }
 308
 309     } else if (excp_model == POWERPC_EXCP_POWER10) {
 310         if (!mmu_all_on && !hv_escalation) {
 311             /*
 312              * AIL works for HV interrupts even with guest MSR[IR/DR] disabled.
 313              * Guest->guest and HV->HV interrupts do require MMU on.
 314              */
 315             return;
 316         }
 317
 318         if (*new_msr & MSR_HVB) {
 319             if (!(env->spr[SPR_LPCR] & LPCR_HAIL)) {
 320                 /* HV interrupts depend on LPCR[HAIL] */
 321                 return;
 322             }
 323             ail = 3; /* HAIL=1 gives AIL=3 behaviour for HV interrupts */
 324         } else {
 325             ail = (env->spr[SPR_LPCR] & LPCR_AIL) >> LPCR_AIL_SHIFT;
 326         }
 327         if (ail == 0) {
 328             return;
 329         }
 330         if (ail == 1 || ail == 2) {
 331             /* AIL=1 and AIL=2 are reserved, treat them like AIL=0 */
 332             return;
 333         }
 334     } else {
 335         /* Other processors do not support AIL */
 336         return;
 337     }
 338
 339     /*
 340      * AIL applies, so the new MSR gets IR and DR set, and an offset applied
 341      * to the new IP.
 342      */
 343     *new_msr |= (1 << MSR_IR) | (1 << MSR_DR);
 344
 345     if (excp != POWERPC_EXCP_SYSCALL_VECTORED) {
 346         if (ail == 2) {
 347             *vector |= 0x0000000000018000ull;
 348         } else if (ail == 3) {
 349             *vector |= 0xc000000000004000ull;
 350         }
 351     } else {
 352         /*
 353          * scv AIL is a little different. AIL=2 does not change the address,
 354          * only the MSR. AIL=3 replaces the 0x17000 base with 0xc...3000.
 355          */
 356         if (ail == 3) {
 357             *vector &= ~0x0000000000017000ull; /* Un-apply the base offset */
 358             *vector |= 0xc000000000003000ull; /* Apply scv's AIL=3 offset */
 359         }
 360     }
 361 #endif
 362 }
 363
 364 static void powerpc_set_excp_state(PowerPCCPU *cpu,
 365                                           target_ulong vector, target_ulong msr)
 366 {
 367     CPUState *cs = CPU(cpu);
 368     CPUPPCState *env = &cpu->env;
 369
 370     /*
 371      * We don't use hreg_store_msr here as already have treated any
 372      * special case that could occur. Just store MSR and update hflags
 373      *
 374      * Note: We *MUST* not use hreg_store_msr() as-is anyway because it
 375      * will prevent setting of the HV bit which some exceptions might need
 376      * to do.
 377      */
 378     env->msr = msr & env->msr_mask;
 379     hreg_compute_hflags(env);
 380     env->nip = vector;
 381     /* Reset exception state */
 382     cs->exception_index = POWERPC_EXCP_NONE;
 383     env->error_code = 0;
 384
 385     /* Reset the reservation */
 386     env->reserve_addr = -1;
 387
 388     /*
 389      * Any interrupt is context synchronizing, check if TCG TLB needs
 390      * a delayed flush on ppc64
 391      */
 392     check_tlb_flush(env, false);
 393 }
 394
 395 /*
 396  * Note that this function should be greatly optimized when called
 397  * with a constant excp, from ppc_hw_interrupt
 398  */
 399 static void powerpc_excp(PowerPCCPU *cpu, int excp)
 400 {
 401     CPUState *cs = CPU(cpu);
 402     CPUPPCState *env = &cpu->env;
 403     int excp_model = env->excp_model;
 404     target_ulong msr, new_msr, vector;
 405     int srr0, srr1, lev = -1;
 406
 407     if (excp <= POWERPC_EXCP_NONE || excp >= POWERPC_EXCP_NB) {
 408         cpu_abort(cs, "Invalid PowerPC exception %d. Aborting\n", excp);
 409     }
 410
 411     qemu_log_mask(CPU_LOG_INT, "Raise exception at " TARGET_FMT_lx
 412                   " => %s (%d) error=%02x\n", env->nip, powerpc_excp_name(excp),
 413                   excp, env->error_code);
 414
 415     /* new srr1 value excluding must-be-zero bits */
 416     if (excp_model == POWERPC_EXCP_BOOKE) {
 417         msr = env->msr;
 418     } else {
 419         msr = env->msr & ~0x783f0000ULL;
 420     }
 421
 422     /*
 423      * new interrupt handler msr preserves existing HV and ME unless
 424      * explicitly overriden
 425      */
 426     new_msr = env->msr & (((target_ulong)1 << MSR_ME) | MSR_HVB);
 427
 428     /* target registers */
 429     srr0 = SPR_SRR0;
 430     srr1 = SPR_SRR1;
 431
 432     /*
 433      * check for special resume at 0x100 from doze/nap/sleep/winkle on
 434      * P7/P8/P9
 435      */
 436     if (env->resume_as_sreset) {
 437         excp = powerpc_reset_wakeup(cs, env, excp, &msr);
 438     }
 439
 440     /*
 441      * Hypervisor emulation assistance interrupt only exists on server
 442      * arch 2.05 server or later. We also don't want to generate it if
 443      * we don't have HVB in msr_mask (PAPR mode).
 444      */
 445     if (excp == POWERPC_EXCP_HV_EMU
 446 #if defined(TARGET_PPC64)
 447         && !(mmu_is_64bit(env->mmu_model) && (env->msr_mask & MSR_HVB))
 448 #endif /* defined(TARGET_PPC64) */
 449
 450     ) {
 451         excp = POWERPC_EXCP_PROGRAM;
 452     }
 453
 454 #ifdef TARGET_PPC64
 455     /*
 456      * SPEU and VPU share the same IVOR but they exist in different
 457      * processors. SPEU is e500v1/2 only and VPU is e6500 only.
 458      */
 459     if (excp_model == POWERPC_EXCP_BOOKE && excp == POWERPC_EXCP_VPU) {
 460         excp = POWERPC_EXCP_SPEU;
 461     }
 462 #endif
 463
 464     vector = env->excp_vectors[excp];
 465     if (vector == (target_ulong)-1ULL) {
 466         cpu_abort(cs, "Raised an exception without defined vector %d\n",
 467                   excp);
 468     }
 469
 470     vector |= env->excp_prefix;
 471
 472     switch (excp) {
 473     case POWERPC_EXCP_CRITICAL:    /* Critical input                         */
 474         switch (excp_model) {
 475         case POWERPC_EXCP_40x:
 476             srr0 = SPR_40x_SRR2;
 477             srr1 = SPR_40x_SRR3;
 478             break;
 479         case POWERPC_EXCP_BOOKE:
 480             srr0 = SPR_BOOKE_CSRR0;
 481             srr1 = SPR_BOOKE_CSRR1;
 482             break;
 483         case POWERPC_EXCP_G2:
 484             break;
 485         default:
 486             goto excp_invalid;
 487         }
 488         break;
 489     case POWERPC_EXCP_MCHECK:    /* Machine check exception                  */
 490         if (msr_me == 0) {
 491             /*
 492              * Machine check exception is not enabled.  Enter
 493              * checkstop state.
 494              */
 495             fprintf(stderr, "Machine check while not allowed. "
 496                     "Entering checkstop state\n");
 497             if (qemu_log_separate()) {
 498                 qemu_log("Machine check while not allowed. "
 499                         "Entering checkstop state\n");
 500             }
 501             cs->halted = 1;
 502             cpu_interrupt_exittb(cs);
 503         }
 504         if (env->msr_mask & MSR_HVB) {
 505             /*
 506              * ISA specifies HV, but can be delivered to guest with HV
 507              * clear (e.g., see FWNMI in PAPR).
 508              */
 509             new_msr |= (target_ulong)MSR_HVB;
 510         }
 511
 512         /* machine check exceptions don't have ME set */
 513         new_msr &= ~((target_ulong)1 << MSR_ME);
 514
 515         /* XXX: should also have something loaded in DAR / DSISR */
 516         switch (excp_model) {
 517         case POWERPC_EXCP_40x:
 518             srr0 = SPR_40x_SRR2;
 519             srr1 = SPR_40x_SRR3;
 520             break;
 521         case POWERPC_EXCP_BOOKE:
 522             /* FIXME: choose one or the other based on CPU type */
 523             srr0 = SPR_BOOKE_MCSRR0;
 524             srr1 = SPR_BOOKE_MCSRR1;
 525
 526             env->spr[SPR_BOOKE_CSRR0] = env->nip;
 527             env->spr[SPR_BOOKE_CSRR1] = msr;
 528             break;
 529         default:
 530             break;
 531         }
 532         break;
 533     case POWERPC_EXCP_DSI:       /* Data storage exception                   */
 534         trace_ppc_excp_dsi(env->spr[SPR_DSISR], env->spr[SPR_DAR]);
 535         break;
 536     case POWERPC_EXCP_ISI:       /* Instruction storage exception            */
 537         trace_ppc_excp_isi(msr, env->nip);
 538         msr |= env->error_code;
 539         break;
 540     case POWERPC_EXCP_EXTERNAL:  /* External input                           */
 541     {
 542         bool lpes0;
 543
 544         cs = CPU(cpu);
 545
 546         /*
 547          * Exception targeting modifiers
 548          *
 549          * LPES0 is supported on POWER7/8/9
 550          * LPES1 is not supported (old iSeries mode)
 551          *
 552          * On anything else, we behave as if LPES0 is 1
 553          * (externals don't alter MSR:HV)
 554          */
 555 #if defined(TARGET_PPC64)
 556         if (excp_model == POWERPC_EXCP_POWER7 ||
 557             excp_model == POWERPC_EXCP_POWER8 ||
 558             excp_model == POWERPC_EXCP_POWER9 ||
 559             excp_model == POWERPC_EXCP_POWER10) {
 560             lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
 561         } else
 562 #endif /* defined(TARGET_PPC64) */
 563         {
 564             lpes0 = true;
 565         }
 566
 567         if (!lpes0) {
 568             new_msr |= (target_ulong)MSR_HVB;
 569             new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
 570             srr0 = SPR_HSRR0;
 571             srr1 = SPR_HSRR1;
 572         }
 573         if (env->mpic_proxy) {
 574             /* IACK the IRQ on delivery */
 575             env->spr[SPR_BOOKE_EPR] = ldl_phys(cs->as, env->mpic_iack);
 576         }
 577         break;
 578     }
 579     case POWERPC_EXCP_ALIGN:     /* Alignment exception                      */
 580         /* Get rS/rD and rA from faulting opcode */
 581         /*
 582          * Note: the opcode fields will not be set properly for a
 583          * direct store load/store, but nobody cares as nobody
 584          * actually uses direct store segments.
 585          */
 586         env->spr[SPR_DSISR] |= (env->error_code & 0x03FF0000) >> 16;
 587         break;
 588     case POWERPC_EXCP_PROGRAM:   /* Program exception                        */
 589         switch (env->error_code & ~0xF) {
 590         case POWERPC_EXCP_FP:
 591             if ((msr_fe0 == 0 && msr_fe1 == 0) || msr_fp == 0) {
 592                 trace_ppc_excp_fp_ignore();
 593                 cs->exception_index = POWERPC_EXCP_NONE;
 594                 env->error_code = 0;
 595                 return;
 596             }
 597
 598             /*
 599              * FP exceptions always have NIP pointing to the faulting
 600              * instruction, so always use store_next and claim we are
 601              * precise in the MSR.
 602              */
 603             msr |= 0x00100000;
 604             env->spr[SPR_BOOKE_ESR] = ESR_FP;
 605             break;
 606         case POWERPC_EXCP_INVAL:
 607             trace_ppc_excp_inval(env->nip);
 608             msr |= 0x00080000;
 609             env->spr[SPR_BOOKE_ESR] = ESR_PIL;
 610             break;
 611         case POWERPC_EXCP_PRIV:
 612             msr |= 0x00040000;
 613             env->spr[SPR_BOOKE_ESR] = ESR_PPR;
 614             break;
 615         case POWERPC_EXCP_TRAP:
 616             msr |= 0x00020000;
 617             env->spr[SPR_BOOKE_ESR] = ESR_PTR;
 618             break;
 619         default:
 620             /* Should never occur */
 621             cpu_abort(cs, "Invalid program exception %d. Aborting\n",
 622                       env->error_code);
 623             break;
 624         }
 625         break;
 626     case POWERPC_EXCP_SYSCALL:   /* System call exception                    */
 627         lev = env->error_code;
 628
 629         if ((lev == 1) && cpu->vhyp) {
 630             dump_hcall(env);
 631         } else {
 632             dump_syscall(env);
 633         }
 634
 635         /*
 636          * We need to correct the NIP which in this case is supposed
 637          * to point to the next instruction
 638          */
 639         env->nip += 4;
 640
 641         /* "PAPR mode" built-in hypercall emulation */
 642         if ((lev == 1) && cpu->vhyp) {
 643             PPCVirtualHypervisorClass *vhc =
 644                 PPC_VIRTUAL_HYPERVISOR_GET_CLASS(cpu->vhyp);
 645             vhc->hypercall(cpu->vhyp, cpu);
 646             return;
 647         }
 648         if (lev == 1) {
 649             new_msr |= (target_ulong)MSR_HVB;
 650         }
 651         break;
 652     case POWERPC_EXCP_SYSCALL_VECTORED: /* scv exception                     */
 653         lev = env->error_code;
 654         dump_syscall(env);
 655         env->nip += 4;
 656         new_msr |= env->msr & ((target_ulong)1 << MSR_EE);
 657         new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
 658
 659         vector += lev * 0x20;
 660
 661         env->lr = env->nip;
 662         env->ctr = msr;
 663         break;
 664     case POWERPC_EXCP_FPU:       /* Floating-point unavailable exception     */
 665     case POWERPC_EXCP_APU:       /* Auxiliary processor unavailable          */
 666     case POWERPC_EXCP_DECR:      /* Decrementer exception                    */
 667         break;
 668     case POWERPC_EXCP_FIT:       /* Fixed-interval timer interrupt           */
 669         /* FIT on 4xx */
 670         trace_ppc_excp_print("FIT");
 671         break;
 672     case POWERPC_EXCP_WDT:       /* Watchdog timer interrupt                 */
 673         trace_ppc_excp_print("WDT");
 674         switch (excp_model) {
 675         case POWERPC_EXCP_BOOKE:
 676             srr0 = SPR_BOOKE_CSRR0;
 677             srr1 = SPR_BOOKE_CSRR1;
 678             break;
 679         default:
 680             break;
 681         }
 682         break;
 683     case POWERPC_EXCP_DTLB:      /* Data TLB error                           */
 684     case POWERPC_EXCP_ITLB:      /* Instruction TLB error                    */
 685         break;
 686     case POWERPC_EXCP_DEBUG:     /* Debug interrupt                          */
 687         if (env->flags & POWERPC_FLAG_DE) {
 688             /* FIXME: choose one or the other based on CPU type */
 689             srr0 = SPR_BOOKE_DSRR0;
 690             srr1 = SPR_BOOKE_DSRR1;
 691
 692             env->spr[SPR_BOOKE_CSRR0] = env->nip;
 693             env->spr[SPR_BOOKE_CSRR1] = msr;
 694
 695             /* DBSR already modified by caller */
 696         } else {
 697             cpu_abort(cs, "Debug exception triggered on unsupported model\n");
 698         }
 699         break;
 700     case POWERPC_EXCP_SPEU:   /* SPE/embedded floating-point unavailable/VPU  */
 701         env->spr[SPR_BOOKE_ESR] = ESR_SPV;
 702         break;
 703     case POWERPC_EXCP_DOORI:     /* Embedded doorbell interrupt              */
 704         break;
 705     case POWERPC_EXCP_DOORCI:    /* Embedded doorbell critical interrupt     */
 706         srr0 = SPR_BOOKE_CSRR0;
 707         srr1 = SPR_BOOKE_CSRR1;
 708         break;
 709     case POWERPC_EXCP_RESET:     /* System reset exception                   */
 710         /* A power-saving exception sets ME, otherwise it is unchanged */
 711         if (msr_pow) {
 712             /* indicate that we resumed from power save mode */
 713             msr |= 0x10000;
 714             new_msr |= ((target_ulong)1 << MSR_ME);
 715         }
 716         if (env->msr_mask & MSR_HVB) {
 717             /*
 718              * ISA specifies HV, but can be delivered to guest with HV
 719              * clear (e.g., see FWNMI in PAPR, NMI injection in QEMU).
 720              */
 721             new_msr |= (target_ulong)MSR_HVB;
 722         } else {
 723             if (msr_pow) {
 724                 cpu_abort(cs, "Trying to deliver power-saving system reset "
 725                           "exception %d with no HV support\n", excp);
 726             }
 727         }
 728         break;
 729     case POWERPC_EXCP_DSEG:      /* Data segment exception                   */
 730     case POWERPC_EXCP_ISEG:      /* Instruction segment exception            */
 731     case POWERPC_EXCP_TRACE:     /* Trace exception                          */
 732         break;
 733     case POWERPC_EXCP_HISI:      /* Hypervisor instruction storage exception */
 734         msr |= env->error_code;
 735         /* fall through */
 736     case POWERPC_EXCP_HDECR:     /* Hypervisor decrementer exception         */
 737     case POWERPC_EXCP_HDSI:      /* Hypervisor data storage exception        */
 738     case POWERPC_EXCP_HDSEG:     /* Hypervisor data segment exception        */
 739     case POWERPC_EXCP_HISEG:     /* Hypervisor instruction segment exception */
 740     case POWERPC_EXCP_SDOOR_HV:  /* Hypervisor Doorbell interrupt            */
 741     case POWERPC_EXCP_HV_EMU:
 742     case POWERPC_EXCP_HVIRT:     /* Hypervisor virtualization                */
 743         srr0 = SPR_HSRR0;
 744         srr1 = SPR_HSRR1;
 745         new_msr |= (target_ulong)MSR_HVB;
 746         new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
 747         break;
 748     case POWERPC_EXCP_VPU:       /* Vector unavailable exception             */
 749     case POWERPC_EXCP_VSXU:       /* VSX unavailable exception               */
 750     case POWERPC_EXCP_FU:         /* Facility unavailable exception          */
 751 #ifdef TARGET_PPC64
 752         env->spr[SPR_FSCR] |= ((target_ulong)env->error_code << 56);
 753 #endif
 754         break;
 755     case POWERPC_EXCP_HV_FU:     /* Hypervisor Facility Unavailable Exception */
 756 #ifdef TARGET_PPC64
 757         env->spr[SPR_HFSCR] |= ((target_ulong)env->error_code << FSCR_IC_POS);
 758         srr0 = SPR_HSRR0;
 759         srr1 = SPR_HSRR1;
 760         new_msr |= (target_ulong)MSR_HVB;
 761         new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
 762 #endif
 763         break;
 764     case POWERPC_EXCP_PIT:       /* Programmable interval timer interrupt    */
 765         trace_ppc_excp_print("PIT");
 766         break;
 767     case POWERPC_EXCP_IFTLB:     /* Instruction fetch TLB error              */
 768     case POWERPC_EXCP_DLTLB:     /* Data load TLB miss                       */
 769     case POWERPC_EXCP_DSTLB:     /* Data store TLB miss                      */
 770         switch (excp_model) {
 771         case POWERPC_EXCP_602:
 772         case POWERPC_EXCP_603:
 773         case POWERPC_EXCP_G2:
 774             /* Swap temporary saved registers with GPRs */
 775             if (!(new_msr & ((target_ulong)1 << MSR_TGPR))) {
 776                 new_msr |= (target_ulong)1 << MSR_TGPR;
 777                 hreg_swap_gpr_tgpr(env);
 778             }
 779             /* fall through */
 780         case POWERPC_EXCP_7x5:
 781             ppc_excp_debug_sw_tlb(env, excp);
 782
 783             msr |= env->crf[0] << 28;
 784             msr |= env->error_code; /* key, D/I, S/L bits */
 785             /* Set way using a LRU mechanism */
 786             msr |= ((env->last_way + 1) & (env->nb_ways - 1)) << 17;
 787             break;
 788         default:
 789             cpu_abort(cs, "Invalid TLB miss exception\n");
 790             break;
 791         }
 792         break;
 793     case POWERPC_EXCP_EFPDI:     /* Embedded floating-point data interrupt   */
 794     case POWERPC_EXCP_EFPRI:     /* Embedded floating-point round interrupt  */
 795     case POWERPC_EXCP_EPERFM:    /* Embedded performance monitor interrupt   */
 796     case POWERPC_EXCP_IO:        /* IO error exception                       */
 797     case POWERPC_EXCP_RUNM:      /* Run mode exception                       */
 798     case POWERPC_EXCP_EMUL:      /* Emulation trap exception                 */
 799     case POWERPC_EXCP_FPA:       /* Floating-point assist exception          */
 800     case POWERPC_EXCP_DABR:      /* Data address breakpoint                  */
 801     case POWERPC_EXCP_IABR:      /* Instruction address breakpoint           */
 802     case POWERPC_EXCP_SMI:       /* System management interrupt              */
 803     case POWERPC_EXCP_THERM:     /* Thermal interrupt                        */
 804     case POWERPC_EXCP_PERFM:     /* Embedded performance monitor interrupt   */
 805     case POWERPC_EXCP_VPUA:      /* Vector assist exception                  */
 806     case POWERPC_EXCP_SOFTP:     /* Soft patch exception                     */
 807     case POWERPC_EXCP_MAINT:     /* Maintenance exception                    */
 808     case POWERPC_EXCP_MEXTBR:    /* Maskable external breakpoint             */
 809     case POWERPC_EXCP_NMEXTBR:   /* Non maskable external breakpoint         */
 810         cpu_abort(cs, "%s exception not implemented\n",
 811                   powerpc_excp_name(excp));
 812         break;
 813     default:
 814     excp_invalid:
 815         cpu_abort(cs, "Invalid PowerPC exception %d. Aborting\n", excp);
 816         break;
 817     }
 818
 819     /* Sanity check */
 820     if (!(env->msr_mask & MSR_HVB)) {
 821         if (new_msr & MSR_HVB) {
 822             cpu_abort(cs, "Trying to deliver HV exception (MSR) %d with "
 823                       "no HV support\n", excp);
 824         }
 825         if (srr0 == SPR_HSRR0) {
 826             cpu_abort(cs, "Trying to deliver HV exception (HSRR) %d with "
 827                       "no HV support\n", excp);
 828         }
 829     }
 830
 831     /*
 832      * Sort out endianness of interrupt, this differs depending on the
 833      * CPU, the HV mode, etc...
 834      */
 835 #ifdef TARGET_PPC64
 836     if (excp_model == POWERPC_EXCP_POWER7) {
 837         if (!(new_msr & MSR_HVB) && (env->spr[SPR_LPCR] & LPCR_ILE)) {
 838             new_msr |= (target_ulong)1 << MSR_LE;
 839         }
 840     } else if (excp_model == POWERPC_EXCP_POWER8) {
 841         if (new_msr & MSR_HVB) {
 842             if (env->spr[SPR_HID0] & HID0_HILE) {
 843                 new_msr |= (target_ulong)1 << MSR_LE;
 844             }
 845         } else if (env->spr[SPR_LPCR] & LPCR_ILE) {
 846             new_msr |= (target_ulong)1 << MSR_LE;
 847         }
 848     } else if (excp_model == POWERPC_EXCP_POWER9 ||
 849                excp_model == POWERPC_EXCP_POWER10) {
 850         if (new_msr & MSR_HVB) {
 851             if (env->spr[SPR_HID0] & HID0_POWER9_HILE) {
 852                 new_msr |= (target_ulong)1 << MSR_LE;
 853             }
 854         } else if (env->spr[SPR_LPCR] & LPCR_ILE) {
 855             new_msr |= (target_ulong)1 << MSR_LE;
 856         }
 857     } else if (msr_ile) {
 858         new_msr |= (target_ulong)1 << MSR_LE;
 859     }
 860 #else
 861     if (msr_ile) {
 862         new_msr |= (target_ulong)1 << MSR_LE;
 863     }
 864 #endif
 865
 866 #if defined(TARGET_PPC64)
 867     if (excp_model == POWERPC_EXCP_BOOKE) {
 868         if (env->spr[SPR_BOOKE_EPCR] & EPCR_ICM) {
 869             /* Cat.64-bit: EPCR.ICM is copied to MSR.CM */
 870             new_msr |= (target_ulong)1 << MSR_CM;
 871         } else {
 872             vector = (uint32_t)vector;
 873         }
 874     } else {
 875         if (!msr_isf && !mmu_is_64bit(env->mmu_model)) {
 876             vector = (uint32_t)vector;
 877         } else {
 878             new_msr |= (target_ulong)1 << MSR_SF;
 879         }
 880     }
 881 #endif
 882
 883     if (excp != POWERPC_EXCP_SYSCALL_VECTORED) {
 884         /* Save PC */
 885         env->spr[srr0] = env->nip;
 886
 887         /* Save MSR */
 888         env->spr[srr1] = msr;
 889     }
 890
 891     /* This can update new_msr and vector if AIL applies */
 892     ppc_excp_apply_ail(cpu, excp_model, excp, msr, &new_msr, &vector);
 893
 894     powerpc_set_excp_state(cpu, vector, new_msr);
 895 }
 896
 897 void ppc_cpu_do_interrupt(CPUState *cs)
 898 {
 899     PowerPCCPU *cpu = POWERPC_CPU(cs);
 900
 901     powerpc_excp(cpu, cs->exception_index);
 902 }
 903
 904 static void ppc_hw_interrupt(CPUPPCState *env)
 905 {
 906     PowerPCCPU *cpu = env_archcpu(env);
 907     bool async_deliver;
 908
 909     /* External reset */
 910     if (env->pending_interrupts & (1 << PPC_INTERRUPT_RESET)) {
 911         env->pending_interrupts &= ~(1 << PPC_INTERRUPT_RESET);
 912         powerpc_excp(cpu, POWERPC_EXCP_RESET);
 913         return;
 914     }
 915     /* Machine check exception */
 916     if (env->pending_interrupts & (1 << PPC_INTERRUPT_MCK)) {
 917         env->pending_interrupts &= ~(1 << PPC_INTERRUPT_MCK);
 918         powerpc_excp(cpu, POWERPC_EXCP_MCHECK);
 919         return;
 920     }
 921 #if 0 /* TODO */
 922     /* External debug exception */
 923     if (env->pending_interrupts & (1 << PPC_INTERRUPT_DEBUG)) {
 924         env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DEBUG);
 925         powerpc_excp(cpu, POWERPC_EXCP_DEBUG);
 926         return;
 927     }
 928 #endif
 929
 930     /*
 931      * For interrupts that gate on MSR:EE, we need to do something a
 932      * bit more subtle, as we need to let them through even when EE is
 933      * clear when coming out of some power management states (in order
 934      * for them to become a 0x100).
 935      */
 936     async_deliver = (msr_ee != 0) || env->resume_as_sreset;
 937
 938     /* Hypervisor decrementer exception */
 939     if (env->pending_interrupts & (1 << PPC_INTERRUPT_HDECR)) {
 940         /* LPCR will be clear when not supported so this will work */
 941         bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
 942         if ((async_deliver || msr_hv == 0) && hdice) {
 943             /* HDEC clears on delivery */
 944             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_HDECR);
 945             powerpc_excp(cpu, POWERPC_EXCP_HDECR);
 946             return;
 947         }
 948     }
 949
 950     /* Hypervisor virtualization interrupt */
 951     if (env->pending_interrupts & (1 << PPC_INTERRUPT_HVIRT)) {
 952         /* LPCR will be clear when not supported so this will work */
 953         bool hvice = !!(env->spr[SPR_LPCR] & LPCR_HVICE);
 954         if ((async_deliver || msr_hv == 0) && hvice) {
 955             powerpc_excp(cpu, POWERPC_EXCP_HVIRT);
 956             return;
 957         }
 958     }
 959
 960     /* External interrupt can ignore MSR:EE under some circumstances */
 961     if (env->pending_interrupts & (1 << PPC_INTERRUPT_EXT)) {
 962         bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
 963         bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
 964         /* HEIC blocks delivery to the hypervisor */
 965         if ((async_deliver && !(heic && msr_hv && !msr_pr)) ||
 966             (env->has_hv_mode && msr_hv == 0 && !lpes0)) {
 967             powerpc_excp(cpu, POWERPC_EXCP_EXTERNAL);
 968             return;
 969         }
 970     }
 971     if (msr_ce != 0) {
 972         /* External critical interrupt */
 973         if (env->pending_interrupts & (1 << PPC_INTERRUPT_CEXT)) {
 974             powerpc_excp(cpu, POWERPC_EXCP_CRITICAL);
 975             return;
 976         }
 977     }
 978     if (async_deliver != 0) {
 979         /* Watchdog timer on embedded PowerPC */
 980         if (env->pending_interrupts & (1 << PPC_INTERRUPT_WDT)) {
 981             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_WDT);
 982             powerpc_excp(cpu, POWERPC_EXCP_WDT);
 983             return;
 984         }
 985         if (env->pending_interrupts & (1 << PPC_INTERRUPT_CDOORBELL)) {
 986             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_CDOORBELL);
 987             powerpc_excp(cpu, POWERPC_EXCP_DOORCI);
 988             return;
 989         }
 990         /* Fixed interval timer on embedded PowerPC */
 991         if (env->pending_interrupts & (1 << PPC_INTERRUPT_FIT)) {
 992             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_FIT);
 993             powerpc_excp(cpu, POWERPC_EXCP_FIT);
 994             return;
 995         }
 996         /* Programmable interval timer on embedded PowerPC */
 997         if (env->pending_interrupts & (1 << PPC_INTERRUPT_PIT)) {
 998             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_PIT);
 999             powerpc_excp(cpu, POWERPC_EXCP_PIT);
1000             return;
1001         }
1002         /* Decrementer exception */
1003         if (env->pending_interrupts & (1 << PPC_INTERRUPT_DECR)) {
1004             if (ppc_decr_clear_on_delivery(env)) {
1005                 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DECR);
1006             }
1007             powerpc_excp(cpu, POWERPC_EXCP_DECR);
1008             return;
1009         }
1010         if (env->pending_interrupts & (1 << PPC_INTERRUPT_DOORBELL)) {
1011             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DOORBELL);
1012             if (is_book3s_arch2x(env)) {
1013                 powerpc_excp(cpu, POWERPC_EXCP_SDOOR);
1014             } else {
1015                 powerpc_excp(cpu, POWERPC_EXCP_DOORI);
1016             }
1017             return;
1018         }
1019         if (env->pending_interrupts & (1 << PPC_INTERRUPT_HDOORBELL)) {
1020             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_HDOORBELL);
1021             powerpc_excp(cpu, POWERPC_EXCP_SDOOR_HV);
1022             return;
1023         }
1024         if (env->pending_interrupts & (1 << PPC_INTERRUPT_PERFM)) {
1025             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_PERFM);
1026             powerpc_excp(cpu, POWERPC_EXCP_PERFM);
1027             return;
1028         }
1029         /* Thermal interrupt */
1030         if (env->pending_interrupts & (1 << PPC_INTERRUPT_THERM)) {
1031             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_THERM);
1032             powerpc_excp(cpu, POWERPC_EXCP_THERM);
1033             return;
1034         }
1035     }
1036
1037     if (env->resume_as_sreset) {
1038         /*
1039          * This is a bug ! It means that has_work took us out of halt without
1040          * anything to deliver while in a PM state that requires getting
1041          * out via a 0x100
1042          *
1043          * This means we will incorrectly execute past the power management
1044          * instruction instead of triggering a reset.
1045          *
1046          * It generally means a discrepancy between the wakeup conditions in the
1047          * processor has_work implementation and the logic in this function.
1048          */
1049         cpu_abort(env_cpu(env),
1050                   "Wakeup from PM state but interrupt Undelivered");
1051     }
1052 }
1053
1054 void ppc_cpu_do_system_reset(CPUState *cs)
1055 {
1056     PowerPCCPU *cpu = POWERPC_CPU(cs);
1057
1058     powerpc_excp(cpu, POWERPC_EXCP_RESET);
1059 }
1060
1061 void ppc_cpu_do_fwnmi_machine_check(CPUState *cs, target_ulong vector)
1062 {
1063     PowerPCCPU *cpu = POWERPC_CPU(cs);
1064     CPUPPCState *env = &cpu->env;
1065     target_ulong msr = 0;
1066
1067     /*
1068      * Set MSR and NIP for the handler, SRR0/1, DAR and DSISR have already
1069      * been set by KVM.
1070      */
1071     msr = (1ULL << MSR_ME);
1072     msr |= env->msr & (1ULL << MSR_SF);
1073     if (ppc_interrupts_little_endian(cpu, false)) {
1074         msr |= (1ULL << MSR_LE);
1075     }
1076
1077     powerpc_set_excp_state(cpu, vector, msr);
1078 }
1079
1080 bool ppc_cpu_exec_interrupt(CPUState *cs, int interrupt_request)
1081 {
1082     PowerPCCPU *cpu = POWERPC_CPU(cs);
1083     CPUPPCState *env = &cpu->env;
1084
1085     if (interrupt_request & CPU_INTERRUPT_HARD) {
1086         ppc_hw_interrupt(env);
1087         if (env->pending_interrupts == 0) {
1088             cs->interrupt_request &= ~CPU_INTERRUPT_HARD;
1089         }
1090         return true;
1091     }
1092     return false;
1093 }
1094
1095 #endif /* !CONFIG_USER_ONLY */
1096
1097 /*****************************************************************************/
1098 /* Exceptions processing helpers */
1099
1100 void raise_exception_err_ra(CPUPPCState *env, uint32_t exception,
1101                             uint32_t error_code, uintptr_t raddr)
1102 {
1103     CPUState *cs = env_cpu(env);
1104
1105     cs->exception_index = exception;
1106     env->error_code = error_code;
1107     cpu_loop_exit_restore(cs, raddr);
1108 }
1109
1110 void raise_exception_err(CPUPPCState *env, uint32_t exception,
1111                          uint32_t error_code)
1112 {
1113     raise_exception_err_ra(env, exception, error_code, 0);
1114 }
1115
1116 void raise_exception(CPUPPCState *env, uint32_t exception)
1117 {
1118     raise_exception_err_ra(env, exception, 0, 0);
1119 }
1120
1121 void raise_exception_ra(CPUPPCState *env, uint32_t exception,
1122                         uintptr_t raddr)
1123 {
1124     raise_exception_err_ra(env, exception, 0, raddr);
1125 }
1126
1127 #ifdef CONFIG_TCG
1128 void helper_raise_exception_err(CPUPPCState *env, uint32_t exception,
1129                                 uint32_t error_code)
1130 {
1131     raise_exception_err_ra(env, exception, error_code, 0);
1132 }
1133
1134 void helper_raise_exception(CPUPPCState *env, uint32_t exception)
1135 {
1136     raise_exception_err_ra(env, exception, 0, 0);
1137 }
1138 #endif
1139
1140 #if !defined(CONFIG_USER_ONLY)
1141 #ifdef CONFIG_TCG
1142 void helper_store_msr(CPUPPCState *env, target_ulong val)
1143 {
1144     uint32_t excp = hreg_store_msr(env, val, 0);
1145
1146     if (excp != 0) {
1147         CPUState *cs = env_cpu(env);
1148         cpu_interrupt_exittb(cs);
1149         raise_exception(env, excp);
1150     }
1151 }
1152
1153 #if defined(TARGET_PPC64)
1154 void helper_scv(CPUPPCState *env, uint32_t lev)
1155 {
1156     if (env->spr[SPR_FSCR] & (1ull << FSCR_SCV)) {
1157         raise_exception_err(env, POWERPC_EXCP_SYSCALL_VECTORED, lev);
1158     } else {
1159         raise_exception_err(env, POWERPC_EXCP_FU, FSCR_IC_SCV);
1160     }
1161 }
1162
1163 void helper_pminsn(CPUPPCState *env, powerpc_pm_insn_t insn)
1164 {
1165     CPUState *cs;
1166
1167     cs = env_cpu(env);
1168     cs->halted = 1;
1169
1170     /* Condition for waking up at 0x100 */
1171     env->resume_as_sreset = (insn != PPC_PM_STOP) ||
1172         (env->spr[SPR_PSSCR] & PSSCR_EC);
1173 }
1174 #endif /* defined(TARGET_PPC64) */
1175 #endif /* CONFIG_TCG */
1176
1177 static void do_rfi(CPUPPCState *env, target_ulong nip, target_ulong msr)
1178 {
1179     CPUState *cs = env_cpu(env);
1180
1181     /* MSR:POW cannot be set by any form of rfi */
1182     msr &= ~(1ULL << MSR_POW);
1183
1184 #if defined(TARGET_PPC64)
1185     /* Switching to 32-bit ? Crop the nip */
1186     if (!msr_is_64bit(env, msr)) {
1187         nip = (uint32_t)nip;
1188     }
1189 #else
1190     nip = (uint32_t)nip;
1191 #endif
1192     /* XXX: beware: this is false if VLE is supported */
1193     env->nip = nip & ~((target_ulong)0x00000003);
1194     hreg_store_msr(env, msr, 1);
1195     trace_ppc_excp_rfi(env->nip, env->msr);
1196     /*
1197      * No need to raise an exception here, as rfi is always the last
1198      * insn of a TB
1199      */
1200     cpu_interrupt_exittb(cs);
1201     /* Reset the reservation */
1202     env->reserve_addr = -1;
1203
1204     /* Context synchronizing: check if TCG TLB needs flush */
1205     check_tlb_flush(env, false);
1206 }
1207
1208 #ifdef CONFIG_TCG
1209 void helper_rfi(CPUPPCState *env)
1210 {
1211     do_rfi(env, env->spr[SPR_SRR0], env->spr[SPR_SRR1] & 0xfffffffful);
1212 }
1213
1214 #define MSR_BOOK3S_MASK
1215 #if defined(TARGET_PPC64)
1216 void helper_rfid(CPUPPCState *env)
1217 {
1218     /*
1219      * The architecture defines a number of rules for which bits can
1220      * change but in practice, we handle this in hreg_store_msr()
1221      * which will be called by do_rfi(), so there is no need to filter
1222      * here
1223      */
1224     do_rfi(env, env->spr[SPR_SRR0], env->spr[SPR_SRR1]);
1225 }
1226
1227 void helper_rfscv(CPUPPCState *env)
1228 {
1229     do_rfi(env, env->lr, env->ctr);
1230 }
1231
1232 void helper_hrfid(CPUPPCState *env)
1233 {
1234     do_rfi(env, env->spr[SPR_HSRR0], env->spr[SPR_HSRR1]);
1235 }
1236 #endif
1237
1238 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
1239 void helper_rfebb(CPUPPCState *env, target_ulong s)
1240 {
1241     target_ulong msr = env->msr;
1242
1243     /*
1244      * Handling of BESCR bits 32:33 according to PowerISA v3.1:
1245      *
1246      * "If BESCR 32:33 != 0b00 the instruction is treated as if
1247      *  the instruction form were invalid."
1248      */
1249     if (env->spr[SPR_BESCR] & BESCR_INVALID) {
1250         raise_exception_err(env, POWERPC_EXCP_PROGRAM,
1251                             POWERPC_EXCP_INVAL | POWERPC_EXCP_INVAL_INVAL);
1252     }
1253
1254     env->nip = env->spr[SPR_EBBRR];
1255
1256     /* Switching to 32-bit ? Crop the nip */
1257     if (!msr_is_64bit(env, msr)) {
1258         env->nip = (uint32_t)env->spr[SPR_EBBRR];
1259     }
1260
1261     if (s) {
1262         env->spr[SPR_BESCR] |= BESCR_GE;
1263     } else {
1264         env->spr[SPR_BESCR] &= ~BESCR_GE;
1265     }
1266 }
1267 #endif
1268
1269 /*****************************************************************************/
1270 /* Embedded PowerPC specific helpers */
1271 void helper_40x_rfci(CPUPPCState *env)
1272 {
1273     do_rfi(env, env->spr[SPR_40x_SRR2], env->spr[SPR_40x_SRR3]);
1274 }
1275
1276 void helper_rfci(CPUPPCState *env)
1277 {
1278     do_rfi(env, env->spr[SPR_BOOKE_CSRR0], env->spr[SPR_BOOKE_CSRR1]);
1279 }
1280
1281 void helper_rfdi(CPUPPCState *env)
1282 {
1283     /* FIXME: choose CSRR1 or DSRR1 based on cpu type */
1284     do_rfi(env, env->spr[SPR_BOOKE_DSRR0], env->spr[SPR_BOOKE_DSRR1]);
1285 }
1286
1287 void helper_rfmci(CPUPPCState *env)
1288 {
1289     /* FIXME: choose CSRR1 or MCSRR1 based on cpu type */
1290     do_rfi(env, env->spr[SPR_BOOKE_MCSRR0], env->spr[SPR_BOOKE_MCSRR1]);
1291 }
1292 #endif /* CONFIG_TCG */
1293 #endif /* !defined(CONFIG_USER_ONLY) */
1294
1295 #ifdef CONFIG_TCG
1296 void helper_tw(CPUPPCState *env, target_ulong arg1, target_ulong arg2,
1297                uint32_t flags)
1298 {
1299     if (!likely(!(((int32_t)arg1 < (int32_t)arg2 && (flags & 0x10)) ||
1300                   ((int32_t)arg1 > (int32_t)arg2 && (flags & 0x08)) ||
1301                   ((int32_t)arg1 == (int32_t)arg2 && (flags & 0x04)) ||
1302                   ((uint32_t)arg1 < (uint32_t)arg2 && (flags & 0x02)) ||
1303                   ((uint32_t)arg1 > (uint32_t)arg2 && (flags & 0x01))))) {
1304         raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
1305                                POWERPC_EXCP_TRAP, GETPC());
1306     }
1307 }
1308
1309 #if defined(TARGET_PPC64)
1310 void helper_td(CPUPPCState *env, target_ulong arg1, target_ulong arg2,
1311                uint32_t flags)
1312 {
1313     if (!likely(!(((int64_t)arg1 < (int64_t)arg2 && (flags & 0x10)) ||
1314                   ((int64_t)arg1 > (int64_t)arg2 && (flags & 0x08)) ||
1315                   ((int64_t)arg1 == (int64_t)arg2 && (flags & 0x04)) ||
1316                   ((uint64_t)arg1 < (uint64_t)arg2 && (flags & 0x02)) ||
1317                   ((uint64_t)arg1 > (uint64_t)arg2 && (flags & 0x01))))) {
1318         raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
1319                                POWERPC_EXCP_TRAP, GETPC());
1320     }
1321 }
1322 #endif
1323 #endif
1324
1325 #if !defined(CONFIG_USER_ONLY)
1326 /*****************************************************************************/
1327 /* PowerPC 601 specific instructions (POWER bridge) */
1328
1329 #ifdef CONFIG_TCG
1330 void helper_rfsvc(CPUPPCState *env)
1331 {
1332     do_rfi(env, env->lr, env->ctr & 0x0000FFFF);
1333 }
1334
1335 /* Embedded.Processor Control */
1336 static int dbell2irq(target_ulong rb)
1337 {
1338     int msg = rb & DBELL_TYPE_MASK;
1339     int irq = -1;
1340
1341     switch (msg) {
1342     case DBELL_TYPE_DBELL:
1343         irq = PPC_INTERRUPT_DOORBELL;
1344         break;
1345     case DBELL_TYPE_DBELL_CRIT:
1346         irq = PPC_INTERRUPT_CDOORBELL;
1347         break;
1348     case DBELL_TYPE_G_DBELL:
1349     case DBELL_TYPE_G_DBELL_CRIT:
1350     case DBELL_TYPE_G_DBELL_MC:
1351         /* XXX implement */
1352     default:
1353         break;
1354     }
1355
1356     return irq;
1357 }
1358
1359 void helper_msgclr(CPUPPCState *env, target_ulong rb)
1360 {
1361     int irq = dbell2irq(rb);
1362
1363     if (irq < 0) {
1364         return;
1365     }
1366
1367     env->pending_interrupts &= ~(1 << irq);
1368 }
1369
1370 void helper_msgsnd(target_ulong rb)
1371 {
1372     int irq = dbell2irq(rb);
1373     int pir = rb & DBELL_PIRTAG_MASK;
1374     CPUState *cs;
1375
1376     if (irq < 0) {
1377         return;
1378     }
1379
1380     qemu_mutex_lock_iothread();
1381     CPU_FOREACH(cs) {
1382         PowerPCCPU *cpu = POWERPC_CPU(cs);
1383         CPUPPCState *cenv = &cpu->env;
1384
1385         if ((rb & DBELL_BRDCAST) || (cenv->spr[SPR_BOOKE_PIR] == pir)) {
1386             cenv->pending_interrupts |= 1 << irq;
1387             cpu_interrupt(cs, CPU_INTERRUPT_HARD);
1388         }
1389     }
1390     qemu_mutex_unlock_iothread();
1391 }
1392
1393 /* Server Processor Control */
1394
1395 static bool dbell_type_server(target_ulong rb)
1396 {
1397     /*
1398      * A Directed Hypervisor Doorbell message is sent only if the
1399      * message type is 5. All other types are reserved and the
1400      * instruction is a no-op
1401      */
1402     return (rb & DBELL_TYPE_MASK) == DBELL_TYPE_DBELL_SERVER;
1403 }
1404
1405 void helper_book3s_msgclr(CPUPPCState *env, target_ulong rb)
1406 {
1407     if (!dbell_type_server(rb)) {
1408         return;
1409     }
1410
1411     env->pending_interrupts &= ~(1 << PPC_INTERRUPT_HDOORBELL);
1412 }
1413
1414 static void book3s_msgsnd_common(int pir, int irq)
1415 {
1416     CPUState *cs;
1417
1418     qemu_mutex_lock_iothread();
1419     CPU_FOREACH(cs) {
1420         PowerPCCPU *cpu = POWERPC_CPU(cs);
1421         CPUPPCState *cenv = &cpu->env;
1422
1423         /* TODO: broadcast message to all threads of the same  processor */
1424         if (cenv->spr_cb[SPR_PIR].default_value == pir) {
1425             cenv->pending_interrupts |= 1 << irq;
1426             cpu_interrupt(cs, CPU_INTERRUPT_HARD);
1427         }
1428     }
1429     qemu_mutex_unlock_iothread();
1430 }
1431
1432 void helper_book3s_msgsnd(target_ulong rb)
1433 {
1434     int pir = rb & DBELL_PROCIDTAG_MASK;
1435
1436     if (!dbell_type_server(rb)) {
1437         return;
1438     }
1439
1440     book3s_msgsnd_common(pir, PPC_INTERRUPT_HDOORBELL);
1441 }
1442
1443 #if defined(TARGET_PPC64)
1444 void helper_book3s_msgclrp(CPUPPCState *env, target_ulong rb)
1445 {
1446     helper_hfscr_facility_check(env, HFSCR_MSGP, "msgclrp", HFSCR_IC_MSGP);
1447
1448     if (!dbell_type_server(rb)) {
1449         return;
1450     }
1451
1452     env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DOORBELL);
1453 }
1454
1455 /*
1456  * sends a message to other threads that are on the same
1457  * multi-threaded processor
1458  */
1459 void helper_book3s_msgsndp(CPUPPCState *env, target_ulong rb)
1460 {
1461     int pir = env->spr_cb[SPR_PIR].default_value;
1462
1463     helper_hfscr_facility_check(env, HFSCR_MSGP, "msgsndp", HFSCR_IC_MSGP);
1464
1465     if (!dbell_type_server(rb)) {
1466         return;
1467     }
1468
1469     /* TODO: TCG supports only one thread */
1470
1471     book3s_msgsnd_common(pir, PPC_INTERRUPT_DOORBELL);
1472 }
1473 #endif /* TARGET_PPC64 */
1474
1475 void ppc_cpu_do_unaligned_access(CPUState *cs, vaddr vaddr,
1476                                  MMUAccessType access_type,
1477                                  int mmu_idx, uintptr_t retaddr)
1478 {
1479     CPUPPCState *env = cs->env_ptr;
1480     uint32_t insn;
1481
1482     /* Restore state and reload the insn we executed, for filling in DSISR.  */
1483     cpu_restore_state(cs, retaddr, true);
1484     insn = cpu_ldl_code(env, env->nip);
1485
1486     switch (env->mmu_model) {
1487     case POWERPC_MMU_SOFT_4xx:
1488         env->spr[SPR_40x_DEAR] = vaddr;
1489         break;
1490     case POWERPC_MMU_BOOKE:
1491     case POWERPC_MMU_BOOKE206:
1492         env->spr[SPR_BOOKE_DEAR] = vaddr;
1493         break;
1494     default:
1495         env->spr[SPR_DAR] = vaddr;
1496         break;
1497     }
1498
1499     cs->exception_index = POWERPC_EXCP_ALIGN;
1500     env->error_code = insn & 0x03FF0000;
1501     cpu_loop_exit(cs);
1502 }
1503 #endif /* CONFIG_TCG */
1504 #endif /* !CONFIG_USER_ONLY */