[mirror_qemu.git] / linux-user / ppc / cpu_loop.c

/*
 *  qemu user cpu loop
 *
 *  Copyright (c) 2003-2008 Fabrice Bellard
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include "qemu/osdep.h"
#include "qemu.h"
#include "qemu/timer.h"
#include "user-internals.h"
#include "cpu_loop-common.h"
#include "signal-common.h"

static inline uint64_t cpu_ppc_get_tb(CPUPPCState *env)
{
    return cpu_get_host_ticks();
}

uint64_t cpu_ppc_load_tbl(CPUPPCState *env)
{
    return cpu_ppc_get_tb(env);
}

uint32_t cpu_ppc_load_tbu(CPUPPCState *env)
{
    return cpu_ppc_get_tb(env) >> 32;
}

uint64_t cpu_ppc_load_atbl(CPUPPCState *env)
{
    return cpu_ppc_get_tb(env);
}

uint32_t cpu_ppc_load_atbu(CPUPPCState *env)
{
    return cpu_ppc_get_tb(env) >> 32;
}

uint64_t cpu_ppc_load_vtb(CPUPPCState *env)
{
    return cpu_ppc_get_tb(env);
}

/* XXX: to be fixed */
int ppc_dcr_read (ppc_dcr_t *dcr_env, int dcrn, uint32_t *valp)
{
    return -1;
}

int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, uint32_t val)
{
    return -1;
}

void cpu_loop(CPUPPCState *env)
{
    CPUState *cs = env_cpu(env);
    int trapnr, si_signo, si_code;
    target_ulong ret;

    for(;;) {
        bool arch_interrupt;

        cpu_exec_start(cs);
        trapnr = cpu_exec(cs);
        cpu_exec_end(cs);
        process_queued_cpu_work(cs);

        arch_interrupt = true;
        switch (trapnr) {
        case POWERPC_EXCP_NONE:
            /* Just go on */
            break;
        case POWERPC_EXCP_CRITICAL: /* Critical input                        */
            cpu_abort(cs, "Critical interrupt while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_MCHECK:   /* Machine check exception               */
            cpu_abort(cs, "Machine check exception while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_DSI:      /* Data storage exception                */
        case POWERPC_EXCP_ISI:      /* Instruction storage exception         */
            /* FIXME: handle maperr in ppc_cpu_record_sigsegv. */
            force_sig_fault(TARGET_SIGSEGV, TARGET_SEGV_MAPERR,
                            env->spr[SPR_DAR]);
            break;
        case POWERPC_EXCP_EXTERNAL: /* External input                        */
            cpu_abort(cs, "External interrupt while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_PROGRAM:  /* Program exception                     */
        case POWERPC_EXCP_HV_EMU:   /* HV emulation                          */
            /* XXX: check this */
            switch (env->error_code & ~0xF) {
            case POWERPC_EXCP_FP:
                si_signo = TARGET_SIGFPE;
                switch (env->error_code & 0xF) {
                case POWERPC_EXCP_FP_OX:
                    si_code = TARGET_FPE_FLTOVF;
                    break;
                case POWERPC_EXCP_FP_UX:
                    si_code = TARGET_FPE_FLTUND;
                    break;
                case POWERPC_EXCP_FP_ZX:
                case POWERPC_EXCP_FP_VXZDZ:
                    si_code = TARGET_FPE_FLTDIV;
                    break;
                case POWERPC_EXCP_FP_XX:
                    si_code = TARGET_FPE_FLTRES;
                    break;
                case POWERPC_EXCP_FP_VXSOFT:
                    si_code = TARGET_FPE_FLTINV;
                    break;
                case POWERPC_EXCP_FP_VXSNAN:
                case POWERPC_EXCP_FP_VXISI:
                case POWERPC_EXCP_FP_VXIDI:
                case POWERPC_EXCP_FP_VXIMZ:
                case POWERPC_EXCP_FP_VXVC:
                case POWERPC_EXCP_FP_VXSQRT:
                case POWERPC_EXCP_FP_VXCVI:
                    si_code = TARGET_FPE_FLTSUB;
                    break;
                default:
                    EXCP_DUMP(env, "Unknown floating point exception (%02x)\n",
                              env->error_code);
                    si_code = 0;
                    break;
                }
                break;
            case POWERPC_EXCP_INVAL:
                si_signo = TARGET_SIGILL;
                switch (env->error_code & 0xF) {
                case POWERPC_EXCP_INVAL_INVAL:
                    si_code = TARGET_ILL_ILLOPC;
                    break;
                case POWERPC_EXCP_INVAL_LSWX:
                    si_code = TARGET_ILL_ILLOPN;
                    break;
                case POWERPC_EXCP_INVAL_SPR:
                    si_code = TARGET_ILL_PRVREG;
                    break;
                case POWERPC_EXCP_INVAL_FP:
                    si_code = TARGET_ILL_COPROC;
                    break;
                default:
                    EXCP_DUMP(env, "Unknown invalid operation (%02x)\n",
                              env->error_code & 0xF);
                    si_code = TARGET_ILL_ILLADR;
                    break;
                }
                break;
            case POWERPC_EXCP_PRIV:
                si_signo = TARGET_SIGILL;
                switch (env->error_code & 0xF) {
                case POWERPC_EXCP_PRIV_OPC:
                    si_code = TARGET_ILL_PRVOPC;
                    break;
                case POWERPC_EXCP_PRIV_REG:
                    si_code = TARGET_ILL_PRVREG;
                    break;
                default:
                    EXCP_DUMP(env, "Unknown privilege violation (%02x)\n",
                              env->error_code & 0xF);
                    si_code = TARGET_ILL_PRVOPC;
                    break;
                }
                break;
            case POWERPC_EXCP_TRAP:
                si_signo = TARGET_SIGTRAP;
                si_code = TARGET_TRAP_BRKPT;
                break;
            default:
                /* Should not happen ! */
                cpu_abort(cs, "Unknown program exception (%02x)\n",
                          env->error_code);
                break;
            }
            force_sig_fault(si_signo, si_code, env->nip);
            break;
        case POWERPC_EXCP_FPU:      /* Floating-point unavailable exception  */
        case POWERPC_EXCP_APU:      /* Auxiliary processor unavailable       */
        case POWERPC_EXCP_SPEU:     /* SPE/embedded floating-point unavail.  */
        case POWERPC_EXCP_VPU:      /* Vector unavailable exception          */
            force_sig_fault(TARGET_SIGILL, TARGET_ILL_COPROC, env->nip);
            break;
        case POWERPC_EXCP_SYSCALL:  /* System call exception                 */
        case POWERPC_EXCP_SYSCALL_VECTORED:
            cpu_abort(cs, "Syscall exception while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_DECR:     /* Decrementer exception                 */
            cpu_abort(cs, "Decrementer interrupt while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_FIT:      /* Fixed-interval timer interrupt        */
            cpu_abort(cs, "Fix interval timer interrupt while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_WDT:      /* Watchdog timer interrupt              */
            cpu_abort(cs, "Watchdog timer interrupt while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_DTLB:     /* Data TLB error                        */
            cpu_abort(cs, "Data TLB exception while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_ITLB:     /* Instruction TLB error                 */
            cpu_abort(cs, "Instruction TLB exception while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_EFPDI:    /* Embedded floating-point data IRQ      */
            cpu_abort(cs, "Embedded floating-point data IRQ not handled\n");
            break;
        case POWERPC_EXCP_EFPRI:    /* Embedded floating-point round IRQ     */
            cpu_abort(cs, "Embedded floating-point round IRQ not handled\n");
            break;
        case POWERPC_EXCP_EPERFM:   /* Embedded performance monitor IRQ      */
            cpu_abort(cs, "Performance monitor exception not handled\n");
            break;
        case POWERPC_EXCP_DOORI:    /* Embedded doorbell interrupt           */
            cpu_abort(cs, "Doorbell interrupt while in user mode. "
                       "Aborting\n");
            break;
        case POWERPC_EXCP_DOORCI:   /* Embedded doorbell critical interrupt  */
            cpu_abort(cs, "Doorbell critical interrupt while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_RESET:    /* System reset exception                */
            cpu_abort(cs, "Reset interrupt while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_DSEG:     /* Data segment exception                */
            cpu_abort(cs, "Data segment exception while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_ISEG:     /* Instruction segment exception         */
            cpu_abort(cs, "Instruction segment exception "
                      "while in user mode. Aborting\n");
            break;
        /* PowerPC 64 with hypervisor mode support */
        case POWERPC_EXCP_HDECR:    /* Hypervisor decrementer exception      */
            cpu_abort(cs, "Hypervisor decrementer interrupt "
                      "while in user mode. Aborting\n");
            break;
        case POWERPC_EXCP_TRACE:    /* Trace exception                       */
            /* Nothing to do:
             * we use this exception to emulate step-by-step execution mode.
             */
            break;
        /* PowerPC 64 with hypervisor mode support */
        case POWERPC_EXCP_HDSI:     /* Hypervisor data storage exception     */
            cpu_abort(cs, "Hypervisor data storage exception "
                      "while in user mode. Aborting\n");
            break;
        case POWERPC_EXCP_HISI:     /* Hypervisor instruction storage excp   */
            cpu_abort(cs, "Hypervisor instruction storage exception "
                      "while in user mode. Aborting\n");
            break;
        case POWERPC_EXCP_HDSEG:    /* Hypervisor data segment exception     */
            cpu_abort(cs, "Hypervisor data segment exception "
                      "while in user mode. Aborting\n");
            break;
        case POWERPC_EXCP_HISEG:    /* Hypervisor instruction segment excp   */
            cpu_abort(cs, "Hypervisor instruction segment exception "
                      "while in user mode. Aborting\n");
            break;
        case POWERPC_EXCP_PIT:      /* Programmable interval timer IRQ       */
            cpu_abort(cs, "Programmable interval timer interrupt "
                      "while in user mode. Aborting\n");
            break;
        case POWERPC_EXCP_EMUL:     /* Emulation trap exception              */
            cpu_abort(cs, "Emulation trap exception not handled\n");
            break;
        case POWERPC_EXCP_IFTLB:    /* Instruction fetch TLB error           */
            cpu_abort(cs, "Instruction fetch TLB exception "
                      "while in user-mode. Aborting");
            break;
        case POWERPC_EXCP_DLTLB:    /* Data load TLB miss                    */
            cpu_abort(cs, "Data load TLB exception while in user-mode. "
                      "Aborting");
            break;
        case POWERPC_EXCP_DSTLB:    /* Data store TLB miss                   */
            cpu_abort(cs, "Data store TLB exception while in user-mode. "
                      "Aborting");
            break;
        case POWERPC_EXCP_FPA:      /* Floating-point assist exception       */
            cpu_abort(cs, "Floating-point assist exception not handled\n");
            break;
        case POWERPC_EXCP_IABR:     /* Instruction address breakpoint        */
            cpu_abort(cs, "Instruction address breakpoint exception "
                      "not handled\n");
            break;
        case POWERPC_EXCP_SMI:      /* System management interrupt           */
            cpu_abort(cs, "System management interrupt while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_THERM:    /* Thermal interrupt                     */
            cpu_abort(cs, "Thermal interrupt interrupt while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_PERFM:   /* Embedded performance monitor IRQ      */
            cpu_abort(cs, "Performance monitor exception not handled\n");
            break;
        case POWERPC_EXCP_VPUA:     /* Vector assist exception               */
            cpu_abort(cs, "Vector assist exception not handled\n");
            break;
        case POWERPC_EXCP_SOFTP:    /* Soft patch exception                  */
            cpu_abort(cs, "Soft patch exception not handled\n");
            break;
        case POWERPC_EXCP_MAINT:    /* Maintenance exception                 */
            cpu_abort(cs, "Maintenance exception while in user mode. "
                      "Aborting\n");
            break;
        case POWERPC_EXCP_SYSCALL_USER:
            /* system call in user-mode emulation */
            /* WARNING:
             * PPC ABI uses overflow flag in cr0 to signal an error
             * in syscalls.
             */
            env->crf[0] &= ~0x1;
            env->nip += 4;
            ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
                             env->gpr[5], env->gpr[6], env->gpr[7],
                             env->gpr[8], 0, 0);
            if (ret == -QEMU_ERESTARTSYS) {
                env->nip -= 4;
                break;
            }
            if (ret == (target_ulong)(-QEMU_ESIGRETURN)) {
                /* Returning from a successful sigreturn syscall.
                   Avoid corrupting register state.  */
                break;
            }
            if (ret > (target_ulong)(-515)) {
                env->crf[0] |= 0x1;
                ret = -ret;
            }
            env->gpr[3] = ret;
            break;
        case EXCP_DEBUG:
            force_sig_fault(TARGET_SIGTRAP, TARGET_TRAP_BRKPT, env->nip);
            break;
        case EXCP_INTERRUPT:
            /* just indicate that signals should be handled asap */
            break;
        case EXCP_ATOMIC:
            cpu_exec_step_atomic(cs);
            arch_interrupt = false;
            break;
        default:
            cpu_abort(cs, "Unknown exception 0x%x. Aborting\n", trapnr);
            break;
        }
        process_pending_signals(env);

        /* Most of the traps imply a transition through kernel mode,
         * which implies an REI instruction has been executed.  Which
         * means that RX and LOCK_ADDR should be cleared.  But there
         * are a few exceptions for traps internal to QEMU.
         */
        if (arch_interrupt) {
            env->reserve_addr = -1;
        }
    }
}

void target_cpu_copy_regs(CPUArchState *env, struct target_pt_regs *regs)
{
    int i;

#if defined(TARGET_PPC64)
    int flag = (env->insns_flags2 & PPC2_BOOKE206) ? MSR_CM : MSR_SF;
#if defined(TARGET_ABI32)
    ppc_store_msr(env, env->msr & ~((target_ulong)1 << flag));
#else
    ppc_store_msr(env, env->msr | (target_ulong)1 << flag);
#endif
#endif

    env->nip = regs->nip;
    for(i = 0; i < 32; i++) {
        env->gpr[i] = regs->gpr[i];
    }
}
Commit	Line	Data
cd71c089 LV	1	/*
	2	* qemu user cpu loop
	3	*
	4	* Copyright (c) 2003-2008 Fabrice Bellard
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program 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
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include "qemu/osdep.h"
	21	#include "qemu.h"
cdf06ce5	22	#include "qemu/timer.h"
3b249d26	23	#include "user-internals.h"
cd71c089	24	#include "cpu_loop-common.h"
2113aed6	25	#include "signal-common.h"
cd71c089	26
11400516 LV	27	static inline uint64_t cpu_ppc_get_tb(CPUPPCState *env)
	28	{
	29	return cpu_get_host_ticks();
	30	}
	31
	32	uint64_t cpu_ppc_load_tbl(CPUPPCState *env)
	33	{
	34	return cpu_ppc_get_tb(env);
	35	}
	36
	37	uint32_t cpu_ppc_load_tbu(CPUPPCState *env)
	38	{
	39	return cpu_ppc_get_tb(env) >> 32;
	40	}
	41
	42	uint64_t cpu_ppc_load_atbl(CPUPPCState *env)
	43	{
	44	return cpu_ppc_get_tb(env);
	45	}
	46
	47	uint32_t cpu_ppc_load_atbu(CPUPPCState *env)
	48	{
	49	return cpu_ppc_get_tb(env) >> 32;
	50	}
	51
5d62725b SJS	52	uint64_t cpu_ppc_load_vtb(CPUPPCState *env)
	53	{
	54	return cpu_ppc_get_tb(env);
	55	}
	56
11400516 LV	57	/* XXX: to be fixed */
	58	int ppc_dcr_read (ppc_dcr_t dcr_env, int dcrn, uint32_t valp)
	59	{
	60	return -1;
	61	}
	62
	63	int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, uint32_t val)
	64	{
	65	return -1;
	66	}
	67
11400516 LV	68	void cpu_loop(CPUPPCState *env)
11400516 LV	69	{
db70b311	70	CPUState *cs = env_cpu(env);
d30e60e7	71	int trapnr, si_signo, si_code;
11400516 LV	72	target_ulong ret;
	73
	74	for(;;) {
14db1899 RH	75	bool arch_interrupt;
14db1899 RH	76
11400516 LV	77	cpu_exec_start(cs);
	78	trapnr = cpu_exec(cs);
	79	cpu_exec_end(cs);
	80	process_queued_cpu_work(cs);
	81
14db1899 RH	82	arch_interrupt = true;
14db1899 RH	83	switch (trapnr) {
11400516 LV	84	case POWERPC_EXCP_NONE:
	85	/* Just go on */
	86	break;
	87	case POWERPC_EXCP_CRITICAL: /* Critical input */
	88	cpu_abort(cs, "Critical interrupt while in user mode. "
	89	"Aborting\n");
	90	break;
	91	case POWERPC_EXCP_MCHECK: /* Machine check exception */
	92	cpu_abort(cs, "Machine check exception while in user mode. "
	93	"Aborting\n");
	94	break;
	95	case POWERPC_EXCP_DSI: /* Data storage exception */
11400516	96	case POWERPC_EXCP_ISI: /* Instruction storage exception */
d30e60e7 RH	97	/* FIXME: handle maperr in ppc_cpu_record_sigsegv. */
	98	force_sig_fault(TARGET_SIGSEGV, TARGET_SEGV_MAPERR,
	99	env->spr[SPR_DAR]);
11400516 LV	100	break;
	101	case POWERPC_EXCP_EXTERNAL: /* External input */
	102	cpu_abort(cs, "External interrupt while in user mode. "
	103	"Aborting\n");
	104	break;
11400516 LV	105	case POWERPC_EXCP_PROGRAM: /* Program exception */
	106	case POWERPC_EXCP_HV_EMU: /* HV emulation */
	107	/* XXX: check this */
	108	switch (env->error_code & ~0xF) {
	109	case POWERPC_EXCP_FP:
d30e60e7	110	si_signo = TARGET_SIGFPE;
11400516 LV	111	switch (env->error_code & 0xF) {
11400516 LV	112	case POWERPC_EXCP_FP_OX:
d30e60e7	113	si_code = TARGET_FPE_FLTOVF;
11400516 LV	114	break;
11400516 LV	115	case POWERPC_EXCP_FP_UX:
d30e60e7	116	si_code = TARGET_FPE_FLTUND;
11400516 LV	117	break;
	118	case POWERPC_EXCP_FP_ZX:
	119	case POWERPC_EXCP_FP_VXZDZ:
d30e60e7	120	si_code = TARGET_FPE_FLTDIV;
11400516 LV	121	break;
11400516 LV	122	case POWERPC_EXCP_FP_XX:
d30e60e7	123	si_code = TARGET_FPE_FLTRES;
11400516 LV	124	break;
11400516 LV	125	case POWERPC_EXCP_FP_VXSOFT:
d30e60e7	126	si_code = TARGET_FPE_FLTINV;
11400516 LV	127	break;
	128	case POWERPC_EXCP_FP_VXSNAN:
	129	case POWERPC_EXCP_FP_VXISI:
	130	case POWERPC_EXCP_FP_VXIDI:
	131	case POWERPC_EXCP_FP_VXIMZ:
	132	case POWERPC_EXCP_FP_VXVC:
	133	case POWERPC_EXCP_FP_VXSQRT:
	134	case POWERPC_EXCP_FP_VXCVI:
d30e60e7	135	si_code = TARGET_FPE_FLTSUB;
11400516 LV	136	break;
	137	default:
	138	EXCP_DUMP(env, "Unknown floating point exception (%02x)\n",
	139	env->error_code);
d30e60e7	140	si_code = 0;
11400516 LV	141	break;
	142	}
	143	break;
	144	case POWERPC_EXCP_INVAL:
d30e60e7	145	si_signo = TARGET_SIGILL;
11400516 LV	146	switch (env->error_code & 0xF) {
11400516 LV	147	case POWERPC_EXCP_INVAL_INVAL:
d30e60e7	148	si_code = TARGET_ILL_ILLOPC;
11400516 LV	149	break;
11400516 LV	150	case POWERPC_EXCP_INVAL_LSWX:
d30e60e7	151	si_code = TARGET_ILL_ILLOPN;
11400516 LV	152	break;
11400516 LV	153	case POWERPC_EXCP_INVAL_SPR:
d30e60e7	154	si_code = TARGET_ILL_PRVREG;
11400516 LV	155	break;
11400516 LV	156	case POWERPC_EXCP_INVAL_FP:
d30e60e7	157	si_code = TARGET_ILL_COPROC;
11400516 LV	158	break;
	159	default:
	160	EXCP_DUMP(env, "Unknown invalid operation (%02x)\n",
	161	env->error_code & 0xF);
d30e60e7	162	si_code = TARGET_ILL_ILLADR;
11400516 LV	163	break;
	164	}
	165	break;
	166	case POWERPC_EXCP_PRIV:
d30e60e7	167	si_signo = TARGET_SIGILL;
11400516 LV	168	switch (env->error_code & 0xF) {
11400516 LV	169	case POWERPC_EXCP_PRIV_OPC:
d30e60e7	170	si_code = TARGET_ILL_PRVOPC;
11400516 LV	171	break;
11400516 LV	172	case POWERPC_EXCP_PRIV_REG:
d30e60e7	173	si_code = TARGET_ILL_PRVREG;
11400516 LV	174	break;
	175	default:
	176	EXCP_DUMP(env, "Unknown privilege violation (%02x)\n",
	177	env->error_code & 0xF);
d30e60e7	178	si_code = TARGET_ILL_PRVOPC;
11400516 LV	179	break;
	180	}
	181	break;
	182	case POWERPC_EXCP_TRAP:
083fe9a1 MF	183	si_signo = TARGET_SIGTRAP;
083fe9a1 MF	184	si_code = TARGET_TRAP_BRKPT;
11400516 LV	185	break;
	186	default:
	187	/* Should not happen ! */
	188	cpu_abort(cs, "Unknown program exception (%02x)\n",
	189	env->error_code);
	190	break;
	191	}
d30e60e7	192	force_sig_fault(si_signo, si_code, env->nip);
11400516 LV	193	break;
11400516 LV	194	case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */
d30e60e7 RH	195	case POWERPC_EXCP_APU: /* Auxiliary processor unavailable */
	196	case POWERPC_EXCP_SPEU: /* SPE/embedded floating-point unavail. */
	197	case POWERPC_EXCP_VPU: /* Vector unavailable exception */
	198	force_sig_fault(TARGET_SIGILL, TARGET_ILL_COPROC, env->nip);
11400516 LV	199	break;
11400516 LV	200	case POWERPC_EXCP_SYSCALL: /* System call exception */
3c89b8d6	201	case POWERPC_EXCP_SYSCALL_VECTORED:
11400516 LV	202	cpu_abort(cs, "Syscall exception while in user mode. "
	203	"Aborting\n");
	204	break;
11400516 LV	205	case POWERPC_EXCP_DECR: /* Decrementer exception */
	206	cpu_abort(cs, "Decrementer interrupt while in user mode. "
	207	"Aborting\n");
	208	break;
	209	case POWERPC_EXCP_FIT: /* Fixed-interval timer interrupt */
	210	cpu_abort(cs, "Fix interval timer interrupt while in user mode. "
	211	"Aborting\n");
	212	break;
	213	case POWERPC_EXCP_WDT: /* Watchdog timer interrupt */
	214	cpu_abort(cs, "Watchdog timer interrupt while in user mode. "
	215	"Aborting\n");
	216	break;
	217	case POWERPC_EXCP_DTLB: /* Data TLB error */
	218	cpu_abort(cs, "Data TLB exception while in user mode. "
	219	"Aborting\n");
	220	break;
	221	case POWERPC_EXCP_ITLB: /* Instruction TLB error */
	222	cpu_abort(cs, "Instruction TLB exception while in user mode. "
	223	"Aborting\n");
	224	break;
11400516 LV	225	case POWERPC_EXCP_EFPDI: /* Embedded floating-point data IRQ */
	226	cpu_abort(cs, "Embedded floating-point data IRQ not handled\n");
	227	break;
	228	case POWERPC_EXCP_EFPRI: /* Embedded floating-point round IRQ */
	229	cpu_abort(cs, "Embedded floating-point round IRQ not handled\n");
	230	break;
	231	case POWERPC_EXCP_EPERFM: /* Embedded performance monitor IRQ */
	232	cpu_abort(cs, "Performance monitor exception not handled\n");
	233	break;
	234	case POWERPC_EXCP_DOORI: /* Embedded doorbell interrupt */
	235	cpu_abort(cs, "Doorbell interrupt while in user mode. "
	236	"Aborting\n");
	237	break;
	238	case POWERPC_EXCP_DOORCI: /* Embedded doorbell critical interrupt */
	239	cpu_abort(cs, "Doorbell critical interrupt while in user mode. "
	240	"Aborting\n");
	241	break;
	242	case POWERPC_EXCP_RESET: /* System reset exception */
	243	cpu_abort(cs, "Reset interrupt while in user mode. "
	244	"Aborting\n");
	245	break;
	246	case POWERPC_EXCP_DSEG: /* Data segment exception */
	247	cpu_abort(cs, "Data segment exception while in user mode. "
	248	"Aborting\n");
	249	break;
	250	case POWERPC_EXCP_ISEG: /* Instruction segment exception */
	251	cpu_abort(cs, "Instruction segment exception "
	252	"while in user mode. Aborting\n");
	253	break;
	254	/* PowerPC 64 with hypervisor mode support */
	255	case POWERPC_EXCP_HDECR: /* Hypervisor decrementer exception */
	256	cpu_abort(cs, "Hypervisor decrementer interrupt "
	257	"while in user mode. Aborting\n");
	258	break;
	259	case POWERPC_EXCP_TRACE: /* Trace exception */
	260	/* Nothing to do:
	261	* we use this exception to emulate step-by-step execution mode.
	262	*/
	263	break;
	264	/* PowerPC 64 with hypervisor mode support */
	265	case POWERPC_EXCP_HDSI: /* Hypervisor data storage exception */
	266	cpu_abort(cs, "Hypervisor data storage exception "
	267	"while in user mode. Aborting\n");
	268	break;
	269	case POWERPC_EXCP_HISI: /* Hypervisor instruction storage excp */
	270	cpu_abort(cs, "Hypervisor instruction storage exception "
	271	"while in user mode. Aborting\n");
	272	break;
	273	case POWERPC_EXCP_HDSEG: /* Hypervisor data segment exception */
	274	cpu_abort(cs, "Hypervisor data segment exception "
	275	"while in user mode. Aborting\n");
	276	break;
	277	case POWERPC_EXCP_HISEG: /* Hypervisor instruction segment excp */
	278	cpu_abort(cs, "Hypervisor instruction segment exception "
	279	"while in user mode. Aborting\n");
	280	break;
11400516 LV	281	case POWERPC_EXCP_PIT: /* Programmable interval timer IRQ */
	282	cpu_abort(cs, "Programmable interval timer interrupt "
	283	"while in user mode. Aborting\n");
	284	break;
11400516 LV	285	case POWERPC_EXCP_EMUL: /* Emulation trap exception */
	286	cpu_abort(cs, "Emulation trap exception not handled\n");
	287	break;
	288	case POWERPC_EXCP_IFTLB: /* Instruction fetch TLB error */
	289	cpu_abort(cs, "Instruction fetch TLB exception "
	290	"while in user-mode. Aborting");
	291	break;
	292	case POWERPC_EXCP_DLTLB: /* Data load TLB miss */
	293	cpu_abort(cs, "Data load TLB exception while in user-mode. "
	294	"Aborting");
	295	break;
	296	case POWERPC_EXCP_DSTLB: /* Data store TLB miss */
	297	cpu_abort(cs, "Data store TLB exception while in user-mode. "
	298	"Aborting");
	299	break;
	300	case POWERPC_EXCP_FPA: /* Floating-point assist exception */
	301	cpu_abort(cs, "Floating-point assist exception not handled\n");
	302	break;
	303	case POWERPC_EXCP_IABR: /* Instruction address breakpoint */
	304	cpu_abort(cs, "Instruction address breakpoint exception "
	305	"not handled\n");
	306	break;
	307	case POWERPC_EXCP_SMI: /* System management interrupt */
	308	cpu_abort(cs, "System management interrupt while in user mode. "
	309	"Aborting\n");
	310	break;
	311	case POWERPC_EXCP_THERM: /* Thermal interrupt */
	312	cpu_abort(cs, "Thermal interrupt interrupt while in user mode. "
	313	"Aborting\n");
	314	break;
	315	case POWERPC_EXCP_PERFM: /* Embedded performance monitor IRQ */
	316	cpu_abort(cs, "Performance monitor exception not handled\n");
	317	break;
	318	case POWERPC_EXCP_VPUA: /* Vector assist exception */
	319	cpu_abort(cs, "Vector assist exception not handled\n");
	320	break;
	321	case POWERPC_EXCP_SOFTP: /* Soft patch exception */
	322	cpu_abort(cs, "Soft patch exception not handled\n");
	323	break;
	324	case POWERPC_EXCP_MAINT: /* Maintenance exception */
	325	cpu_abort(cs, "Maintenance exception while in user mode. "
	326	"Aborting\n");
	327	break;
11400516 LV	328	case POWERPC_EXCP_SYSCALL_USER:
	329	/* system call in user-mode emulation */
	330	/* WARNING:
	331	* PPC ABI uses overflow flag in cr0 to signal an error
	332	* in syscalls.
	333	*/
	334	env->crf[0] &= ~0x1;
	335	env->nip += 4;
	336	ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
	337	env->gpr[5], env->gpr[6], env->gpr[7],
	338	env->gpr[8], 0, 0);
af254a27	339	if (ret == -QEMU_ERESTARTSYS) {
11400516 LV	340	env->nip -= 4;
	341	break;
	342	}
57a0c938	343	if (ret == (target_ulong)(-QEMU_ESIGRETURN)) {
11400516 LV	344	/* Returning from a successful sigreturn syscall.
	345	Avoid corrupting register state. */
	346	break;
	347	}
	348	if (ret > (target_ulong)(-515)) {
	349	env->crf[0] \|= 0x1;
	350	ret = -ret;
	351	}
	352	env->gpr[3] = ret;
	353	break;
14db1899	354	case EXCP_DEBUG:
d30e60e7	355	force_sig_fault(TARGET_SIGTRAP, TARGET_TRAP_BRKPT, env->nip);
11400516 LV	356	break;
	357	case EXCP_INTERRUPT:
	358	/* just indicate that signals should be handled asap */
	359	break;
	360	case EXCP_ATOMIC:
	361	cpu_exec_step_atomic(cs);
14db1899	362	arch_interrupt = false;
11400516 LV	363	break;
	364	default:
	365	cpu_abort(cs, "Unknown exception 0x%x. Aborting\n", trapnr);
	366	break;
	367	}
	368	process_pending_signals(env);
14db1899 RH	369
	370	/* Most of the traps imply a transition through kernel mode,
	371	* which implies an REI instruction has been executed. Which
	372	* means that RX and LOCK_ADDR should be cleared. But there
	373	* are a few exceptions for traps internal to QEMU.
	374	*/
	375	if (arch_interrupt) {
	376	env->reserve_addr = -1;
	377	}
11400516 LV	378	}
	379	}
	380
cd71c089 LV	381	void target_cpu_copy_regs(CPUArchState env, struct target_pt_regs regs)
cd71c089 LV	382	{
11400516 LV	383	int i;
	384
	385	#if defined(TARGET_PPC64)
	386	int flag = (env->insns_flags2 & PPC2_BOOKE206) ? MSR_CM : MSR_SF;
	387	#if defined(TARGET_ABI32)
75da4997	388	ppc_store_msr(env, env->msr & ~((target_ulong)1 << flag));
11400516	389	#else
75da4997	390	ppc_store_msr(env, env->msr \| (target_ulong)1 << flag);
11400516 LV	391	#endif
11400516 LV	392	#endif
75da4997	393
11400516 LV	394	env->nip = regs->nip;
	395	for(i = 0; i < 32; i++) {
	396	env->gpr[i] = regs->gpr[i];
	397	}
cd71c089	398	}