[mirror_qemu.git] / linux-user / sparc / 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-common.h"
#include "qemu.h"
#include "user-internals.h"
#include "cpu_loop-common.h"
#include "signal-common.h"

#define SPARC64_STACK_BIAS 2047

//#define DEBUG_WIN

/* WARNING: dealing with register windows _is_ complicated. More info
   can be found at http://www.sics.se/~psm/sparcstack.html */
static inline int get_reg_index(CPUSPARCState *env, int cwp, int index)
{
    index = (index + cwp * 16) % (16 * env->nwindows);
    /* wrap handling : if cwp is on the last window, then we use the
       registers 'after' the end */
    if (index < 8 && env->cwp == env->nwindows - 1)
        index += 16 * env->nwindows;
    return index;
}

/* save the register window 'cwp1' */
static inline void save_window_offset(CPUSPARCState *env, int cwp1)
{
    unsigned int i;
    abi_ulong sp_ptr;

    sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
#ifdef TARGET_SPARC64
    if (sp_ptr & 3)
        sp_ptr += SPARC64_STACK_BIAS;
#endif
#if defined(DEBUG_WIN)
    printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n",
           sp_ptr, cwp1);
#endif
    for(i = 0; i < 16; i++) {
        /* FIXME - what to do if put_user() fails? */
        put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
        sp_ptr += sizeof(abi_ulong);
    }
}

static void save_window(CPUSPARCState *env)
{
#ifndef TARGET_SPARC64
    unsigned int new_wim;
    new_wim = ((env->wim >> 1) | (env->wim << (env->nwindows - 1))) &
        ((1LL << env->nwindows) - 1);
    save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
    env->wim = new_wim;
#else
    /*
     * cansave is zero if the spill trap handler is triggered by `save` and
     * nonzero if triggered by a `flushw`
     */
    save_window_offset(env, cpu_cwp_dec(env, env->cwp - env->cansave - 2));
    env->cansave++;
    env->canrestore--;
#endif
}

static void restore_window(CPUSPARCState *env)
{
#ifndef TARGET_SPARC64
    unsigned int new_wim;
#endif
    unsigned int i, cwp1;
    abi_ulong sp_ptr;

#ifndef TARGET_SPARC64
    new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) &
        ((1LL << env->nwindows) - 1);
#endif

    /* restore the invalid window */
    cwp1 = cpu_cwp_inc(env, env->cwp + 1);
    sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
#ifdef TARGET_SPARC64
    if (sp_ptr & 3)
        sp_ptr += SPARC64_STACK_BIAS;
#endif
#if defined(DEBUG_WIN)
    printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n",
           sp_ptr, cwp1);
#endif
    for(i = 0; i < 16; i++) {
        /* FIXME - what to do if get_user() fails? */
        get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
        sp_ptr += sizeof(abi_ulong);
    }
#ifdef TARGET_SPARC64
    env->canrestore++;
    if (env->cleanwin < env->nwindows - 1)
        env->cleanwin++;
    env->cansave--;
#else
    env->wim = new_wim;
#endif
}

static void flush_windows(CPUSPARCState *env)
{
    int offset, cwp1;

    offset = 1;
    for(;;) {
        /* if restore would invoke restore_window(), then we can stop */
        cwp1 = cpu_cwp_inc(env, env->cwp + offset);
#ifndef TARGET_SPARC64
        if (env->wim & (1 << cwp1))
            break;
#else
        if (env->canrestore == 0)
            break;
        env->cansave++;
        env->canrestore--;
#endif
        save_window_offset(env, cwp1);
        offset++;
    }
    cwp1 = cpu_cwp_inc(env, env->cwp + 1);
#ifndef TARGET_SPARC64
    /* set wim so that restore will reload the registers */
    env->wim = 1 << cwp1;
#endif
#if defined(DEBUG_WIN)
    printf("flush_windows: nb=%d\n", offset - 1);
#endif
}

void cpu_loop (CPUSPARCState *env)
{
    CPUState *cs = env_cpu(env);
    int trapnr;
    abi_long ret;
    target_siginfo_t info;

    while (1) {
        cpu_exec_start(cs);
        trapnr = cpu_exec(cs);
        cpu_exec_end(cs);
        process_queued_cpu_work(cs);

        /* Compute PSR before exposing state.  */
        if (env->cc_op != CC_OP_FLAGS) {
            cpu_get_psr(env);
        }

        switch (trapnr) {
#ifndef TARGET_SPARC64
        case 0x88:
        case 0x90:
#else
        case 0x110:
        case 0x16d:
#endif
            ret = do_syscall (env, env->gregs[1],
                              env->regwptr[0], env->regwptr[1],
                              env->regwptr[2], env->regwptr[3],
                              env->regwptr[4], env->regwptr[5],
                              0, 0);
            if (ret == -TARGET_ERESTARTSYS || ret == -TARGET_QEMU_ESIGRETURN) {
                break;
            }
            if ((abi_ulong)ret >= (abi_ulong)(-515)) {
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
                env->xcc |= PSR_CARRY;
#else
                env->psr |= PSR_CARRY;
#endif
                ret = -ret;
            } else {
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
                env->xcc &= ~PSR_CARRY;
#else
                env->psr &= ~PSR_CARRY;
#endif
            }
            env->regwptr[0] = ret;
            /* next instruction */
            env->pc = env->npc;
            env->npc = env->npc + 4;
            break;
        case 0x83: /* flush windows */
#ifdef TARGET_ABI32
        case 0x103:
#endif
            flush_windows(env);
            /* next instruction */
            env->pc = env->npc;
            env->npc = env->npc + 4;
            break;
#ifndef TARGET_SPARC64
        case TT_WIN_OVF: /* window overflow */
            save_window(env);
            break;
        case TT_WIN_UNF: /* window underflow */
            restore_window(env);
            break;
        case TT_TFAULT:
        case TT_DFAULT:
            {
                info.si_signo = TARGET_SIGSEGV;
                info.si_errno = 0;
                /* XXX: check env->error_code */
                info.si_code = TARGET_SEGV_MAPERR;
                info._sifields._sigfault._addr = env->mmuregs[4];
                queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
            }
            break;
#else
        case TT_SPILL: /* window overflow */
            save_window(env);
            break;
        case TT_FILL: /* window underflow */
            restore_window(env);
            break;
        case TT_TFAULT:
        case TT_DFAULT:
            {
                info.si_signo = TARGET_SIGSEGV;
                info.si_errno = 0;
                /* XXX: check env->error_code */
                info.si_code = TARGET_SEGV_MAPERR;
                if (trapnr == TT_DFAULT)
                    info._sifields._sigfault._addr = env->dmmu.mmuregs[4];
                else
                    info._sifields._sigfault._addr = cpu_tsptr(env)->tpc;
                queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
            }
            break;
#ifndef TARGET_ABI32
        case 0x16e:
            flush_windows(env);
            sparc64_get_context(env);
            break;
        case 0x16f:
            flush_windows(env);
            sparc64_set_context(env);
            break;
#endif
#endif
        case EXCP_INTERRUPT:
            /* just indicate that signals should be handled asap */
            break;
        case TT_ILL_INSN:
            {
                info.si_signo = TARGET_SIGILL;
                info.si_errno = 0;
                info.si_code = TARGET_ILL_ILLOPC;
                info._sifields._sigfault._addr = env->pc;
                queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
            }
            break;
        case EXCP_DEBUG:
            info.si_signo = TARGET_SIGTRAP;
            info.si_errno = 0;
            info.si_code = TARGET_TRAP_BRKPT;
            queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
            break;
        case EXCP_ATOMIC:
            cpu_exec_step_atomic(cs);
            break;
        default:
            fprintf(stderr, "Unhandled trap: 0x%x\n", trapnr);
            cpu_dump_state(cs, stderr, 0);
            exit(EXIT_FAILURE);
        }
        process_pending_signals (env);
    }
}

void target_cpu_copy_regs(CPUArchState *env, struct target_pt_regs *regs)
{
    int i;
    env->pc = regs->pc;
    env->npc = regs->npc;
    env->y = regs->y;
    for(i = 0; i < 8; i++)
        env->gregs[i] = regs->u_regs[i];
    for(i = 0; i < 8; i++)
        env->regwptr[i] = regs->u_regs[i + 8];
}
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"
a8d25326	21	#include "qemu-common.h"
cd71c089	22	#include "qemu.h"
3b249d26	23	#include "user-internals.h"
cd71c089	24	#include "cpu_loop-common.h"
2113aed6	25	#include "signal-common.h"
cd71c089	26
d0a28415 LV	27	#define SPARC64_STACK_BIAS 2047
	28
	29	//#define DEBUG_WIN
	30
	31	/* WARNING: dealing with register windows _is_ complicated. More info
	32	can be found at http://www.sics.se/~psm/sparcstack.html */
	33	static inline int get_reg_index(CPUSPARCState *env, int cwp, int index)
	34	{
	35	index = (index + cwp * 16) % (16 * env->nwindows);
	36	/* wrap handling : if cwp is on the last window, then we use the
	37	registers 'after' the end */
	38	if (index < 8 && env->cwp == env->nwindows - 1)
	39	index += 16 * env->nwindows;
	40	return index;
	41	}
	42
	43	/* save the register window 'cwp1' */
	44	static inline void save_window_offset(CPUSPARCState *env, int cwp1)
	45	{
	46	unsigned int i;
	47	abi_ulong sp_ptr;
	48
	49	sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
	50	#ifdef TARGET_SPARC64
	51	if (sp_ptr & 3)
	52	sp_ptr += SPARC64_STACK_BIAS;
	53	#endif
	54	#if defined(DEBUG_WIN)
	55	printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n",
	56	sp_ptr, cwp1);
	57	#endif
	58	for(i = 0; i < 16; i++) {
	59	/* FIXME - what to do if put_user() fails? */
	60	put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
	61	sp_ptr += sizeof(abi_ulong);
	62	}
	63	}
	64
	65	static void save_window(CPUSPARCState *env)
	66	{
	67	#ifndef TARGET_SPARC64
	68	unsigned int new_wim;
	69	new_wim = ((env->wim >> 1) \| (env->wim << (env->nwindows - 1))) &
	70	((1LL << env->nwindows) - 1);
	71	save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
	72	env->wim = new_wim;
	73	#else
d43624c4 GM	74	/*
	75	* cansave is zero if the spill trap handler is triggered by `save` and
	76	* nonzero if triggered by a `flushw`
	77	*/
	78	save_window_offset(env, cpu_cwp_dec(env, env->cwp - env->cansave - 2));
d0a28415 LV	79	env->cansave++;
	80	env->canrestore--;
	81	#endif
	82	}
	83
	84	static void restore_window(CPUSPARCState *env)
	85	{
	86	#ifndef TARGET_SPARC64
	87	unsigned int new_wim;
	88	#endif
	89	unsigned int i, cwp1;
	90	abi_ulong sp_ptr;
	91
	92	#ifndef TARGET_SPARC64
	93	new_wim = ((env->wim << 1) \| (env->wim >> (env->nwindows - 1))) &
	94	((1LL << env->nwindows) - 1);
	95	#endif
	96
	97	/* restore the invalid window */
	98	cwp1 = cpu_cwp_inc(env, env->cwp + 1);
	99	sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
	100	#ifdef TARGET_SPARC64
	101	if (sp_ptr & 3)
	102	sp_ptr += SPARC64_STACK_BIAS;
	103	#endif
	104	#if defined(DEBUG_WIN)
	105	printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n",
	106	sp_ptr, cwp1);
	107	#endif
	108	for(i = 0; i < 16; i++) {
	109	/* FIXME - what to do if get_user() fails? */
	110	get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
	111	sp_ptr += sizeof(abi_ulong);
	112	}
	113	#ifdef TARGET_SPARC64
	114	env->canrestore++;
	115	if (env->cleanwin < env->nwindows - 1)
	116	env->cleanwin++;
	117	env->cansave--;
	118	#else
	119	env->wim = new_wim;
	120	#endif
	121	}
	122
	123	static void flush_windows(CPUSPARCState *env)
	124	{
	125	int offset, cwp1;
	126
	127	offset = 1;
	128	for(;;) {
	129	/* if restore would invoke restore_window(), then we can stop */
	130	cwp1 = cpu_cwp_inc(env, env->cwp + offset);
	131	#ifndef TARGET_SPARC64
	132	if (env->wim & (1 << cwp1))
	133	break;
	134	#else
	135	if (env->canrestore == 0)
	136	break;
	137	env->cansave++;
	138	env->canrestore--;
	139	#endif
	140	save_window_offset(env, cwp1);
	141	offset++;
	142	}
143	cwp1 = cpu_cwp_inc(env, env->cwp + 1);
144	#ifndef TARGET_SPARC64
145	/* set wim so that restore will reload the registers */
146	env->wim = 1 << cwp1;
147	#endif
148	#if defined(DEBUG_WIN)
149	printf("flush_windows: nb=%d\n", offset - 1);
150	#endif
151	}
152
153	void cpu_loop (CPUSPARCState *env)
154	{
5a59fbce	155	CPUState *cs = env_cpu(env);
d0a28415 LV	156	int trapnr;
	157	abi_long ret;
	158	target_siginfo_t info;
	159
	160	while (1) {
	161	cpu_exec_start(cs);
	162	trapnr = cpu_exec(cs);
	163	cpu_exec_end(cs);
	164	process_queued_cpu_work(cs);
	165
	166	/* Compute PSR before exposing state. */
	167	if (env->cc_op != CC_OP_FLAGS) {
	168	cpu_get_psr(env);
	169	}
	170
	171	switch (trapnr) {
	172	#ifndef TARGET_SPARC64
	173	case 0x88:
	174	case 0x90:
	175	#else
	176	case 0x110:
	177	case 0x16d:
	178	#endif
	179	ret = do_syscall (env, env->gregs[1],
	180	env->regwptr[0], env->regwptr[1],
	181	env->regwptr[2], env->regwptr[3],
	182	env->regwptr[4], env->regwptr[5],
	183	0, 0);
	184	if (ret == -TARGET_ERESTARTSYS \|\| ret == -TARGET_QEMU_ESIGRETURN) {
	185	break;
	186	}
	187	if ((abi_ulong)ret >= (abi_ulong)(-515)) {
	188	#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
	189	env->xcc \|= PSR_CARRY;
	190	#else
	191	env->psr \|= PSR_CARRY;
	192	#endif
	193	ret = -ret;
	194	} else {
	195	#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
	196	env->xcc &= ~PSR_CARRY;
	197	#else
	198	env->psr &= ~PSR_CARRY;
	199	#endif
	200	}
	201	env->regwptr[0] = ret;
	202	/* next instruction */
	203	env->pc = env->npc;
	204	env->npc = env->npc + 4;
	205	break;
	206	case 0x83: /* flush windows */
	207	#ifdef TARGET_ABI32
	208	case 0x103:
	209	#endif
	210	flush_windows(env);
	211	/* next instruction */
	212	env->pc = env->npc;
	213	env->npc = env->npc + 4;
	214	break;
	215	#ifndef TARGET_SPARC64
	216	case TT_WIN_OVF: /* window overflow */
	217	save_window(env);
	218	break;
	219	case TT_WIN_UNF: /* window underflow */
220	restore_window(env);
221	break;
222	case TT_TFAULT:
223	case TT_DFAULT:
224	{
225	info.si_signo = TARGET_SIGSEGV;
226	info.si_errno = 0;
227	/* XXX: check env->error_code */
228	info.si_code = TARGET_SEGV_MAPERR;
229	info._sifields._sigfault._addr = env->mmuregs[4];
230	queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
231	}
232	break;
233	#else
234	case TT_SPILL: /* window overflow */
235	save_window(env);
236	break;
237	case TT_FILL: /* window underflow */
238	restore_window(env);
239	break;
240	case TT_TFAULT:
241	case TT_DFAULT:
242	{
243	info.si_signo = TARGET_SIGSEGV;
244	info.si_errno = 0;
245	/* XXX: check env->error_code */
246	info.si_code = TARGET_SEGV_MAPERR;
247	if (trapnr == TT_DFAULT)
248	info._sifields._sigfault._addr = env->dmmu.mmuregs[4];
249	else
250	info._sifields._sigfault._addr = cpu_tsptr(env)->tpc;
251	queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
252	}
253	break;
254	#ifndef TARGET_ABI32
255	case 0x16e:
256	flush_windows(env);
257	sparc64_get_context(env);
258	break;
259	case 0x16f:
260	flush_windows(env);
261	sparc64_set_context(env);
262	break;
263	#endif
264	#endif
265	case EXCP_INTERRUPT:
266	/* just indicate that signals should be handled asap */
267	break;
268	case TT_ILL_INSN:
269	{
270	info.si_signo = TARGET_SIGILL;
271	info.si_errno = 0;
272	info.si_code = TARGET_ILL_ILLOPC;
273	info._sifields._sigfault._addr = env->pc;
274	queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
275	}
276	break;
277	case EXCP_DEBUG:
b10089a1 PM	278	info.si_signo = TARGET_SIGTRAP;
	279	info.si_errno = 0;
	280	info.si_code = TARGET_TRAP_BRKPT;
	281	queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
d0a28415 LV	282	break;
	283	case EXCP_ATOMIC:
	284	cpu_exec_step_atomic(cs);
	285	break;
	286	default:
84ca4fa9	287	fprintf(stderr, "Unhandled trap: 0x%x\n", trapnr);
90c84c56	288	cpu_dump_state(cs, stderr, 0);
d0a28415 LV	289	exit(EXIT_FAILURE);
	290	}
	291	process_pending_signals (env);
	292	}
	293	}
	294
cd71c089 LV	295	void target_cpu_copy_regs(CPUArchState env, struct target_pt_regs regs)
cd71c089 LV	296	{
d0a28415 LV	297	int i;
	298	env->pc = regs->pc;
	299	env->npc = regs->npc;
	300	env->y = regs->y;
	301	for(i = 0; i < 8; i++)
	302	env->gregs[i] = regs->u_regs[i];
	303	for(i = 0; i < 8; i++)
	304	env->regwptr[i] = regs->u_regs[i + 8];
cd71c089	305	}