2003-02-18 23:55:36 +01:00
|
|
|
/*
|
2003-09-30 22:57:29 +02:00
|
|
|
* qemu user main
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2008-01-06 18:21:48 +01:00
|
|
|
* Copyright (c) 2003-2008 Fabrice Bellard
|
2003-02-18 23:55:36 +01:00
|
|
|
*
|
|
|
|
* 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
|
2009-07-16 22:47:01 +02:00
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
2003-02-18 23:55:36 +01:00
|
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdarg.h>
|
2003-03-20 23:33:23 +01:00
|
|
|
#include <string.h>
|
2003-02-18 23:55:36 +01:00
|
|
|
#include <errno.h>
|
2003-03-03 15:32:43 +01:00
|
|
|
#include <unistd.h>
|
2008-11-10 03:55:33 +01:00
|
|
|
#include <sys/mman.h>
|
2009-04-07 08:57:11 +02:00
|
|
|
#include <sys/syscall.h>
|
2010-03-19 22:21:13 +01:00
|
|
|
#include <sys/resource.h>
|
2003-02-18 23:55:36 +01:00
|
|
|
|
2003-03-23 21:17:16 +01:00
|
|
|
#include "qemu.h"
|
2008-04-11 23:35:42 +02:00
|
|
|
#include "qemu-common.h"
|
2008-12-10 20:18:40 +01:00
|
|
|
#include "cache-utils.h"
|
2011-06-19 22:38:22 +02:00
|
|
|
#include "cpu.h"
|
2010-05-06 17:50:41 +02:00
|
|
|
#include "tcg.h"
|
2010-03-29 21:24:00 +02:00
|
|
|
#include "qemu-timer.h"
|
2009-01-30 20:59:17 +01:00
|
|
|
#include "envlist.h"
|
|
|
|
|
2003-03-23 21:17:16 +01:00
|
|
|
#define DEBUG_LOGFILE "/tmp/qemu.log"
|
2003-03-03 16:02:29 +01:00
|
|
|
|
2009-01-30 21:09:01 +01:00
|
|
|
char *exec_path;
|
|
|
|
|
2009-04-05 22:08:59 +02:00
|
|
|
int singlestep;
|
2009-07-17 13:48:08 +02:00
|
|
|
unsigned long mmap_min_addr;
|
2010-03-11 00:39:07 +01:00
|
|
|
#if defined(CONFIG_USE_GUEST_BASE)
|
2009-07-17 13:48:08 +02:00
|
|
|
unsigned long guest_base;
|
|
|
|
int have_guest_base;
|
2010-05-29 03:27:35 +02:00
|
|
|
unsigned long reserved_va;
|
2009-07-17 13:48:08 +02:00
|
|
|
#endif
|
2009-04-05 22:08:59 +02:00
|
|
|
|
2010-05-26 16:08:22 +02:00
|
|
|
static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX;
|
2006-05-14 13:30:38 +02:00
|
|
|
const char *qemu_uname_release = CONFIG_UNAME_RELEASE;
|
2003-03-03 16:02:29 +01:00
|
|
|
|
2003-03-23 17:49:39 +01:00
|
|
|
/* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
|
|
|
|
we allocate a bigger stack. Need a better solution, for example
|
|
|
|
by remapping the process stack directly at the right place */
|
2010-03-19 22:21:13 +01:00
|
|
|
unsigned long guest_stack_size = 8 * 1024 * 1024UL;
|
2003-02-18 23:55:36 +01:00
|
|
|
|
|
|
|
void gemu_log(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2008-08-17 22:26:25 +02:00
|
|
|
#if defined(TARGET_I386)
|
2004-04-12 22:39:29 +02:00
|
|
|
int cpu_get_pic_interrupt(CPUState *env)
|
2003-06-24 15:30:31 +02:00
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
2008-08-17 22:26:25 +02:00
|
|
|
#endif
|
2003-06-24 15:30:31 +02:00
|
|
|
|
2004-05-20 16:02:14 +02:00
|
|
|
/* timers for rdtsc */
|
|
|
|
|
2006-07-14 01:20:22 +02:00
|
|
|
#if 0
|
2004-05-20 16:02:14 +02:00
|
|
|
|
|
|
|
static uint64_t emu_time;
|
|
|
|
|
|
|
|
int64_t cpu_get_real_ticks(void)
|
|
|
|
{
|
|
|
|
return emu_time++;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2009-07-27 16:13:24 +02:00
|
|
|
#if defined(CONFIG_USE_NPTL)
|
2008-06-07 22:50:51 +02:00
|
|
|
/***********************************************************/
|
|
|
|
/* Helper routines for implementing atomic operations. */
|
|
|
|
|
|
|
|
/* To implement exclusive operations we force all cpus to syncronise.
|
|
|
|
We don't require a full sync, only that no cpus are executing guest code.
|
|
|
|
The alternative is to map target atomic ops onto host equivalents,
|
|
|
|
which requires quite a lot of per host/target work. */
|
2009-03-07 16:24:59 +01:00
|
|
|
static pthread_mutex_t cpu_list_mutex = PTHREAD_MUTEX_INITIALIZER;
|
2008-06-07 22:50:51 +02:00
|
|
|
static pthread_mutex_t exclusive_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
static pthread_cond_t exclusive_cond = PTHREAD_COND_INITIALIZER;
|
|
|
|
static pthread_cond_t exclusive_resume = PTHREAD_COND_INITIALIZER;
|
|
|
|
static int pending_cpus;
|
|
|
|
|
|
|
|
/* Make sure everything is in a consistent state for calling fork(). */
|
|
|
|
void fork_start(void)
|
|
|
|
{
|
|
|
|
pthread_mutex_lock(&tb_lock);
|
|
|
|
pthread_mutex_lock(&exclusive_lock);
|
2009-12-04 14:16:31 +01:00
|
|
|
mmap_fork_start();
|
2008-06-07 22:50:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void fork_end(int child)
|
|
|
|
{
|
2009-12-04 14:16:31 +01:00
|
|
|
mmap_fork_end(child);
|
2008-06-07 22:50:51 +02:00
|
|
|
if (child) {
|
|
|
|
/* Child processes created by fork() only have a single thread.
|
|
|
|
Discard information about the parent threads. */
|
|
|
|
first_cpu = thread_env;
|
|
|
|
thread_env->next_cpu = NULL;
|
|
|
|
pending_cpus = 0;
|
|
|
|
pthread_mutex_init(&exclusive_lock, NULL);
|
2009-03-07 16:24:59 +01:00
|
|
|
pthread_mutex_init(&cpu_list_mutex, NULL);
|
2008-06-07 22:50:51 +02:00
|
|
|
pthread_cond_init(&exclusive_cond, NULL);
|
|
|
|
pthread_cond_init(&exclusive_resume, NULL);
|
|
|
|
pthread_mutex_init(&tb_lock, NULL);
|
2008-12-18 23:44:04 +01:00
|
|
|
gdbserver_fork(thread_env);
|
2008-06-07 22:50:51 +02:00
|
|
|
} else {
|
|
|
|
pthread_mutex_unlock(&exclusive_lock);
|
|
|
|
pthread_mutex_unlock(&tb_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Wait for pending exclusive operations to complete. The exclusive lock
|
|
|
|
must be held. */
|
|
|
|
static inline void exclusive_idle(void)
|
|
|
|
{
|
|
|
|
while (pending_cpus) {
|
|
|
|
pthread_cond_wait(&exclusive_resume, &exclusive_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Start an exclusive operation.
|
|
|
|
Must only be called from outside cpu_arm_exec. */
|
|
|
|
static inline void start_exclusive(void)
|
|
|
|
{
|
|
|
|
CPUState *other;
|
|
|
|
pthread_mutex_lock(&exclusive_lock);
|
|
|
|
exclusive_idle();
|
|
|
|
|
|
|
|
pending_cpus = 1;
|
|
|
|
/* Make all other cpus stop executing. */
|
|
|
|
for (other = first_cpu; other; other = other->next_cpu) {
|
|
|
|
if (other->running) {
|
|
|
|
pending_cpus++;
|
2009-03-07 22:28:24 +01:00
|
|
|
cpu_exit(other);
|
2008-06-07 22:50:51 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pending_cpus > 1) {
|
|
|
|
pthread_cond_wait(&exclusive_cond, &exclusive_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Finish an exclusive operation. */
|
|
|
|
static inline void end_exclusive(void)
|
|
|
|
{
|
|
|
|
pending_cpus = 0;
|
|
|
|
pthread_cond_broadcast(&exclusive_resume);
|
|
|
|
pthread_mutex_unlock(&exclusive_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Wait for exclusive ops to finish, and begin cpu execution. */
|
|
|
|
static inline void cpu_exec_start(CPUState *env)
|
|
|
|
{
|
|
|
|
pthread_mutex_lock(&exclusive_lock);
|
|
|
|
exclusive_idle();
|
|
|
|
env->running = 1;
|
|
|
|
pthread_mutex_unlock(&exclusive_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark cpu as not executing, and release pending exclusive ops. */
|
|
|
|
static inline void cpu_exec_end(CPUState *env)
|
|
|
|
{
|
|
|
|
pthread_mutex_lock(&exclusive_lock);
|
|
|
|
env->running = 0;
|
|
|
|
if (pending_cpus > 1) {
|
|
|
|
pending_cpus--;
|
|
|
|
if (pending_cpus == 1) {
|
|
|
|
pthread_cond_signal(&exclusive_cond);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
exclusive_idle();
|
|
|
|
pthread_mutex_unlock(&exclusive_lock);
|
|
|
|
}
|
2009-03-07 16:24:59 +01:00
|
|
|
|
|
|
|
void cpu_list_lock(void)
|
|
|
|
{
|
|
|
|
pthread_mutex_lock(&cpu_list_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cpu_list_unlock(void)
|
|
|
|
{
|
|
|
|
pthread_mutex_unlock(&cpu_list_mutex);
|
|
|
|
}
|
2009-07-27 16:13:24 +02:00
|
|
|
#else /* if !CONFIG_USE_NPTL */
|
2008-06-07 22:50:51 +02:00
|
|
|
/* These are no-ops because we are not threadsafe. */
|
|
|
|
static inline void cpu_exec_start(CPUState *env)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void cpu_exec_end(CPUState *env)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void start_exclusive(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void end_exclusive(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void fork_start(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void fork_end(int child)
|
|
|
|
{
|
2008-12-18 23:44:04 +01:00
|
|
|
if (child) {
|
|
|
|
gdbserver_fork(thread_env);
|
|
|
|
}
|
2008-06-07 22:50:51 +02:00
|
|
|
}
|
2009-03-07 16:24:59 +01:00
|
|
|
|
|
|
|
void cpu_list_lock(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void cpu_list_unlock(void)
|
|
|
|
{
|
|
|
|
}
|
2008-06-07 22:50:51 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2004-04-12 22:39:29 +02:00
|
|
|
#ifdef TARGET_I386
|
|
|
|
/***********************************************************/
|
|
|
|
/* CPUX86 core interface */
|
|
|
|
|
2006-09-24 20:48:23 +02:00
|
|
|
void cpu_smm_update(CPUState *env)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2004-05-20 16:02:14 +02:00
|
|
|
uint64_t cpu_get_tsc(CPUX86State *env)
|
|
|
|
{
|
|
|
|
return cpu_get_real_ticks();
|
|
|
|
}
|
|
|
|
|
2007-09-16 23:08:06 +02:00
|
|
|
static void write_dt(void *ptr, unsigned long addr, unsigned long limit,
|
2003-05-28 01:28:08 +02:00
|
|
|
int flags)
|
2003-03-16 19:05:05 +01:00
|
|
|
{
|
2003-05-28 01:28:08 +02:00
|
|
|
unsigned int e1, e2;
|
2006-03-25 20:31:22 +01:00
|
|
|
uint32_t *p;
|
2003-03-16 19:05:05 +01:00
|
|
|
e1 = (addr << 16) | (limit & 0xffff);
|
|
|
|
e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
|
2003-05-28 01:28:08 +02:00
|
|
|
e2 |= flags;
|
2006-03-25 20:31:22 +01:00
|
|
|
p = ptr;
|
2008-08-21 00:39:26 +02:00
|
|
|
p[0] = tswap32(e1);
|
|
|
|
p[1] = tswap32(e2);
|
2003-05-28 01:28:08 +02:00
|
|
|
}
|
|
|
|
|
2008-11-10 03:55:33 +01:00
|
|
|
static uint64_t *idt_table;
|
2008-09-06 19:47:39 +02:00
|
|
|
#ifdef TARGET_X86_64
|
2007-11-14 19:08:56 +01:00
|
|
|
static void set_gate64(void *ptr, unsigned int type, unsigned int dpl,
|
|
|
|
uint64_t addr, unsigned int sel)
|
2003-05-28 01:28:08 +02:00
|
|
|
{
|
2007-11-15 16:27:03 +01:00
|
|
|
uint32_t *p, e1, e2;
|
2003-05-28 01:28:08 +02:00
|
|
|
e1 = (addr & 0xffff) | (sel << 16);
|
|
|
|
e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
|
2006-03-25 20:31:22 +01:00
|
|
|
p = ptr;
|
2007-11-15 16:27:03 +01:00
|
|
|
p[0] = tswap32(e1);
|
|
|
|
p[1] = tswap32(e2);
|
|
|
|
p[2] = tswap32(addr >> 32);
|
|
|
|
p[3] = 0;
|
2003-03-16 19:05:05 +01:00
|
|
|
}
|
2007-11-14 19:08:56 +01:00
|
|
|
/* only dpl matters as we do only user space emulation */
|
|
|
|
static void set_idt(int n, unsigned int dpl)
|
|
|
|
{
|
|
|
|
set_gate64(idt_table + n * 2, 0, dpl, 0, 0);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void set_gate(void *ptr, unsigned int type, unsigned int dpl,
|
|
|
|
uint32_t addr, unsigned int sel)
|
|
|
|
{
|
2007-11-15 16:27:03 +01:00
|
|
|
uint32_t *p, e1, e2;
|
2007-11-14 19:08:56 +01:00
|
|
|
e1 = (addr & 0xffff) | (sel << 16);
|
|
|
|
e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
|
|
|
|
p = ptr;
|
2007-11-15 16:27:03 +01:00
|
|
|
p[0] = tswap32(e1);
|
|
|
|
p[1] = tswap32(e2);
|
2007-11-14 19:08:56 +01:00
|
|
|
}
|
|
|
|
|
2003-05-28 01:28:08 +02:00
|
|
|
/* only dpl matters as we do only user space emulation */
|
|
|
|
static void set_idt(int n, unsigned int dpl)
|
|
|
|
{
|
|
|
|
set_gate(idt_table + n, 0, dpl, 0, 0);
|
|
|
|
}
|
2007-11-14 19:08:56 +01:00
|
|
|
#endif
|
2003-02-18 23:55:36 +01:00
|
|
|
|
2003-05-10 14:33:15 +02:00
|
|
|
void cpu_loop(CPUX86State *env)
|
2003-03-22 18:31:38 +01:00
|
|
|
{
|
2003-03-30 23:02:40 +02:00
|
|
|
int trapnr;
|
2007-10-14 18:27:31 +02:00
|
|
|
abi_ulong pc;
|
2009-10-01 23:12:16 +02:00
|
|
|
target_siginfo_t info;
|
2003-03-29 17:53:14 +01:00
|
|
|
|
2003-03-22 18:31:38 +01:00
|
|
|
for(;;) {
|
2003-03-30 23:02:40 +02:00
|
|
|
trapnr = cpu_x86_exec(env);
|
|
|
|
switch(trapnr) {
|
2003-05-28 01:28:08 +02:00
|
|
|
case 0x80:
|
2007-11-14 19:08:56 +01:00
|
|
|
/* linux syscall from int $0x80 */
|
2007-09-16 23:08:06 +02:00
|
|
|
env->regs[R_EAX] = do_syscall(env,
|
|
|
|
env->regs[R_EAX],
|
2003-05-28 01:28:08 +02:00
|
|
|
env->regs[R_EBX],
|
|
|
|
env->regs[R_ECX],
|
|
|
|
env->regs[R_EDX],
|
|
|
|
env->regs[R_ESI],
|
|
|
|
env->regs[R_EDI],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->regs[R_EBP],
|
|
|
|
0, 0);
|
2003-05-28 01:28:08 +02:00
|
|
|
break;
|
2007-11-14 19:08:56 +01:00
|
|
|
#ifndef TARGET_ABI32
|
|
|
|
case EXCP_SYSCALL:
|
2011-05-07 22:20:03 +02:00
|
|
|
/* linux syscall from syscall instruction */
|
2007-11-14 19:08:56 +01:00
|
|
|
env->regs[R_EAX] = do_syscall(env,
|
|
|
|
env->regs[R_EAX],
|
|
|
|
env->regs[R_EDI],
|
|
|
|
env->regs[R_ESI],
|
|
|
|
env->regs[R_EDX],
|
|
|
|
env->regs[10],
|
|
|
|
env->regs[8],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->regs[9],
|
|
|
|
0, 0);
|
2007-11-14 19:08:56 +01:00
|
|
|
env->eip = env->exception_next_eip;
|
|
|
|
break;
|
|
|
|
#endif
|
2003-05-28 01:28:08 +02:00
|
|
|
case EXCP0B_NOSEG:
|
|
|
|
case EXCP0C_STACK:
|
|
|
|
info.si_signo = SIGBUS;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SI_KERNEL;
|
|
|
|
info._sifields._sigfault._addr = 0;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-05-28 01:28:08 +02:00
|
|
|
break;
|
2003-03-22 18:31:38 +01:00
|
|
|
case EXCP0D_GPF:
|
2007-11-14 19:08:56 +01:00
|
|
|
/* XXX: potential problem if ABI32 */
|
2007-04-06 10:56:50 +02:00
|
|
|
#ifndef TARGET_X86_64
|
2003-03-29 17:53:14 +01:00
|
|
|
if (env->eflags & VM_MASK) {
|
2003-05-10 14:33:15 +02:00
|
|
|
handle_vm86_fault(env);
|
2007-04-06 10:56:50 +02:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2003-05-28 01:28:08 +02:00
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SI_KERNEL;
|
|
|
|
info._sifields._sigfault._addr = 0;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-03-22 18:31:38 +01:00
|
|
|
}
|
|
|
|
break;
|
2003-05-08 17:33:33 +02:00
|
|
|
case EXCP0E_PAGE:
|
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
if (!(env->error_code & 1))
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
else
|
|
|
|
info.si_code = TARGET_SEGV_ACCERR;
|
2003-06-21 15:13:25 +02:00
|
|
|
info._sifields._sigfault._addr = env->cr[2];
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-05-08 17:33:33 +02:00
|
|
|
break;
|
2003-03-23 17:49:39 +01:00
|
|
|
case EXCP00_DIVZ:
|
2007-04-06 10:56:50 +02:00
|
|
|
#ifndef TARGET_X86_64
|
2003-03-30 23:02:40 +02:00
|
|
|
if (env->eflags & VM_MASK) {
|
2003-05-10 17:10:36 +02:00
|
|
|
handle_vm86_trap(env, trapnr);
|
2007-04-06 10:56:50 +02:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2003-03-30 23:02:40 +02:00
|
|
|
/* division by zero */
|
|
|
|
info.si_signo = SIGFPE;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_FPE_INTDIV;
|
|
|
|
info._sifields._sigfault._addr = env->eip;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-03-30 23:02:40 +02:00
|
|
|
}
|
2003-03-23 17:49:39 +01:00
|
|
|
break;
|
2008-11-18 22:08:15 +01:00
|
|
|
case EXCP01_DB:
|
2003-05-10 17:10:36 +02:00
|
|
|
case EXCP03_INT3:
|
2007-04-06 10:56:50 +02:00
|
|
|
#ifndef TARGET_X86_64
|
2003-05-10 17:10:36 +02:00
|
|
|
if (env->eflags & VM_MASK) {
|
|
|
|
handle_vm86_trap(env, trapnr);
|
2007-04-06 10:56:50 +02:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2003-05-10 17:10:36 +02:00
|
|
|
info.si_signo = SIGTRAP;
|
|
|
|
info.si_errno = 0;
|
2008-11-18 22:08:15 +01:00
|
|
|
if (trapnr == EXCP01_DB) {
|
2003-05-10 17:10:36 +02:00
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
|
|
|
info._sifields._sigfault._addr = env->eip;
|
|
|
|
} else {
|
|
|
|
info.si_code = TARGET_SI_KERNEL;
|
|
|
|
info._sifields._sigfault._addr = 0;
|
|
|
|
}
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-05-10 17:10:36 +02:00
|
|
|
}
|
|
|
|
break;
|
2003-03-23 17:49:39 +01:00
|
|
|
case EXCP04_INTO:
|
|
|
|
case EXCP05_BOUND:
|
2007-04-06 10:56:50 +02:00
|
|
|
#ifndef TARGET_X86_64
|
2003-03-30 23:02:40 +02:00
|
|
|
if (env->eflags & VM_MASK) {
|
2003-05-10 17:10:36 +02:00
|
|
|
handle_vm86_trap(env, trapnr);
|
2007-04-06 10:56:50 +02:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2003-03-30 23:02:40 +02:00
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
2003-05-08 17:33:33 +02:00
|
|
|
info.si_code = TARGET_SI_KERNEL;
|
2003-03-30 23:02:40 +02:00
|
|
|
info._sifields._sigfault._addr = 0;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-03-30 23:02:40 +02:00
|
|
|
}
|
2003-03-23 17:49:39 +01:00
|
|
|
break;
|
|
|
|
case EXCP06_ILLOP:
|
|
|
|
info.si_signo = SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLOPN;
|
|
|
|
info._sifields._sigfault._addr = env->eip;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-03-23 17:49:39 +01:00
|
|
|
break;
|
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2005-04-17 21:16:13 +02:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig (env, TARGET_SIGTRAP);
|
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-04-17 21:16:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2003-03-22 18:31:38 +01:00
|
|
|
default:
|
2003-06-21 15:13:25 +02:00
|
|
|
pc = env->segs[R_CS].base + env->eip;
|
2007-09-16 23:08:06 +02:00
|
|
|
fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n",
|
2003-03-30 23:02:40 +02:00
|
|
|
(long)pc, trapnr);
|
2003-03-22 18:31:38 +01:00
|
|
|
abort();
|
|
|
|
}
|
2003-03-23 02:06:05 +01:00
|
|
|
process_pending_signals(env);
|
2003-03-22 18:31:38 +01:00
|
|
|
}
|
|
|
|
}
|
2003-06-15 22:05:50 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef TARGET_ARM
|
|
|
|
|
2008-05-29 02:20:44 +02:00
|
|
|
/* Handle a jump to the kernel code page. */
|
|
|
|
static int
|
|
|
|
do_kernel_trap(CPUARMState *env)
|
|
|
|
{
|
|
|
|
uint32_t addr;
|
|
|
|
uint32_t cpsr;
|
|
|
|
uint32_t val;
|
|
|
|
|
|
|
|
switch (env->regs[15]) {
|
|
|
|
case 0xffff0fa0: /* __kernel_memory_barrier */
|
|
|
|
/* ??? No-op. Will need to do better for SMP. */
|
|
|
|
break;
|
|
|
|
case 0xffff0fc0: /* __kernel_cmpxchg */
|
2008-06-07 22:50:51 +02:00
|
|
|
/* XXX: This only works between threads, not between processes.
|
|
|
|
It's probably possible to implement this with native host
|
|
|
|
operations. However things like ldrex/strex are much harder so
|
|
|
|
there's not much point trying. */
|
|
|
|
start_exclusive();
|
2008-05-29 02:20:44 +02:00
|
|
|
cpsr = cpsr_read(env);
|
|
|
|
addr = env->regs[2];
|
|
|
|
/* FIXME: This should SEGV if the access fails. */
|
|
|
|
if (get_user_u32(val, addr))
|
|
|
|
val = ~env->regs[0];
|
|
|
|
if (val == env->regs[0]) {
|
|
|
|
val = env->regs[1];
|
|
|
|
/* FIXME: Check for segfaults. */
|
|
|
|
put_user_u32(val, addr);
|
|
|
|
env->regs[0] = 0;
|
|
|
|
cpsr |= CPSR_C;
|
|
|
|
} else {
|
|
|
|
env->regs[0] = -1;
|
|
|
|
cpsr &= ~CPSR_C;
|
|
|
|
}
|
|
|
|
cpsr_write(env, cpsr, CPSR_C);
|
2008-06-07 22:50:51 +02:00
|
|
|
end_exclusive();
|
2008-05-29 02:20:44 +02:00
|
|
|
break;
|
|
|
|
case 0xffff0fe0: /* __kernel_get_tls */
|
|
|
|
env->regs[0] = env->cp15.c13_tls2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
/* Jump back to the caller. */
|
|
|
|
addr = env->regs[14];
|
|
|
|
if (addr & 1) {
|
|
|
|
env->thumb = 1;
|
|
|
|
addr &= ~1;
|
|
|
|
}
|
|
|
|
env->regs[15] = addr;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-22 22:35:13 +01:00
|
|
|
static int do_strex(CPUARMState *env)
|
|
|
|
{
|
|
|
|
uint32_t val;
|
|
|
|
int size;
|
|
|
|
int rc = 1;
|
|
|
|
int segv = 0;
|
|
|
|
uint32_t addr;
|
|
|
|
start_exclusive();
|
|
|
|
addr = env->exclusive_addr;
|
|
|
|
if (addr != env->exclusive_test) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
size = env->exclusive_info & 0xf;
|
|
|
|
switch (size) {
|
|
|
|
case 0:
|
|
|
|
segv = get_user_u8(val, addr);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
segv = get_user_u16(val, addr);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
case 3:
|
|
|
|
segv = get_user_u32(val, addr);
|
|
|
|
break;
|
2009-12-24 00:17:12 +01:00
|
|
|
default:
|
|
|
|
abort();
|
2009-11-22 22:35:13 +01:00
|
|
|
}
|
|
|
|
if (segv) {
|
|
|
|
env->cp15.c6_data = addr;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (val != env->exclusive_val) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (size == 3) {
|
|
|
|
segv = get_user_u32(val, addr + 4);
|
|
|
|
if (segv) {
|
|
|
|
env->cp15.c6_data = addr + 4;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (val != env->exclusive_high) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
val = env->regs[(env->exclusive_info >> 8) & 0xf];
|
|
|
|
switch (size) {
|
|
|
|
case 0:
|
|
|
|
segv = put_user_u8(val, addr);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
segv = put_user_u16(val, addr);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
case 3:
|
|
|
|
segv = put_user_u32(val, addr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (segv) {
|
|
|
|
env->cp15.c6_data = addr;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (size == 3) {
|
|
|
|
val = env->regs[(env->exclusive_info >> 12) & 0xf];
|
2010-12-07 16:37:34 +01:00
|
|
|
segv = put_user_u32(val, addr + 4);
|
2009-11-22 22:35:13 +01:00
|
|
|
if (segv) {
|
|
|
|
env->cp15.c6_data = addr + 4;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rc = 0;
|
|
|
|
fail:
|
2009-12-11 16:38:10 +01:00
|
|
|
env->regs[15] += 4;
|
2009-11-22 22:35:13 +01:00
|
|
|
env->regs[(env->exclusive_info >> 4) & 0xf] = rc;
|
|
|
|
done:
|
|
|
|
end_exclusive();
|
|
|
|
return segv;
|
|
|
|
}
|
|
|
|
|
2003-06-15 22:05:50 +02:00
|
|
|
void cpu_loop(CPUARMState *env)
|
|
|
|
{
|
|
|
|
int trapnr;
|
|
|
|
unsigned int n, insn;
|
2009-10-01 23:12:16 +02:00
|
|
|
target_siginfo_t info;
|
2005-11-26 11:38:39 +01:00
|
|
|
uint32_t addr;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2003-06-15 22:05:50 +02:00
|
|
|
for(;;) {
|
2008-06-07 22:50:51 +02:00
|
|
|
cpu_exec_start(env);
|
2003-06-15 22:05:50 +02:00
|
|
|
trapnr = cpu_arm_exec(env);
|
2008-06-07 22:50:51 +02:00
|
|
|
cpu_exec_end(env);
|
2003-06-15 22:05:50 +02:00
|
|
|
switch(trapnr) {
|
|
|
|
case EXCP_UDEF:
|
2004-02-16 22:49:03 +01:00
|
|
|
{
|
|
|
|
TaskState *ts = env->opaque;
|
|
|
|
uint32_t opcode;
|
2008-04-07 22:30:53 +02:00
|
|
|
int rc;
|
2004-02-16 22:49:03 +01:00
|
|
|
|
|
|
|
/* we handle the FPU emulation here, as Linux */
|
|
|
|
/* we get the opcode */
|
2007-11-16 11:46:05 +01:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
|
|
|
get_user_u32(opcode, env->regs[15]);
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2008-04-07 22:30:53 +02:00
|
|
|
rc = EmulateAll(opcode, &ts->fpa, env);
|
|
|
|
if (rc == 0) { /* illegal instruction */
|
2004-02-16 22:49:03 +01:00
|
|
|
info.si_signo = SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLOPN;
|
|
|
|
info._sifields._sigfault._addr = env->regs[15];
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2008-04-07 22:30:53 +02:00
|
|
|
} else if (rc < 0) { /* FP exception */
|
|
|
|
int arm_fpe=0;
|
|
|
|
|
|
|
|
/* translate softfloat flags to FPSR flags */
|
|
|
|
if (-rc & float_flag_invalid)
|
|
|
|
arm_fpe |= BIT_IOC;
|
|
|
|
if (-rc & float_flag_divbyzero)
|
|
|
|
arm_fpe |= BIT_DZC;
|
|
|
|
if (-rc & float_flag_overflow)
|
|
|
|
arm_fpe |= BIT_OFC;
|
|
|
|
if (-rc & float_flag_underflow)
|
|
|
|
arm_fpe |= BIT_UFC;
|
|
|
|
if (-rc & float_flag_inexact)
|
|
|
|
arm_fpe |= BIT_IXC;
|
|
|
|
|
|
|
|
FPSR fpsr = ts->fpa.fpsr;
|
|
|
|
//printf("fpsr 0x%x, arm_fpe 0x%x\n",fpsr,arm_fpe);
|
|
|
|
|
|
|
|
if (fpsr & (arm_fpe << 16)) { /* exception enabled? */
|
|
|
|
info.si_signo = SIGFPE;
|
|
|
|
info.si_errno = 0;
|
|
|
|
|
|
|
|
/* ordered by priority, least first */
|
|
|
|
if (arm_fpe & BIT_IXC) info.si_code = TARGET_FPE_FLTRES;
|
|
|
|
if (arm_fpe & BIT_UFC) info.si_code = TARGET_FPE_FLTUND;
|
|
|
|
if (arm_fpe & BIT_OFC) info.si_code = TARGET_FPE_FLTOVF;
|
|
|
|
if (arm_fpe & BIT_DZC) info.si_code = TARGET_FPE_FLTDIV;
|
|
|
|
if (arm_fpe & BIT_IOC) info.si_code = TARGET_FPE_FLTINV;
|
|
|
|
|
|
|
|
info._sifields._sigfault._addr = env->regs[15];
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2008-04-07 22:30:53 +02:00
|
|
|
} else {
|
|
|
|
env->regs[15] += 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* accumulate unenabled exceptions */
|
|
|
|
if ((!(fpsr & BIT_IXE)) && (arm_fpe & BIT_IXC))
|
|
|
|
fpsr |= BIT_IXC;
|
|
|
|
if ((!(fpsr & BIT_UFE)) && (arm_fpe & BIT_UFC))
|
|
|
|
fpsr |= BIT_UFC;
|
|
|
|
if ((!(fpsr & BIT_OFE)) && (arm_fpe & BIT_OFC))
|
|
|
|
fpsr |= BIT_OFC;
|
|
|
|
if ((!(fpsr & BIT_DZE)) && (arm_fpe & BIT_DZC))
|
|
|
|
fpsr |= BIT_DZC;
|
|
|
|
if ((!(fpsr & BIT_IOE)) && (arm_fpe & BIT_IOC))
|
|
|
|
fpsr |= BIT_IOC;
|
|
|
|
ts->fpa.fpsr=fpsr;
|
|
|
|
} else { /* everything OK */
|
2004-02-16 22:49:03 +01:00
|
|
|
/* increment PC */
|
|
|
|
env->regs[15] += 4;
|
|
|
|
}
|
|
|
|
}
|
2003-06-15 22:05:50 +02:00
|
|
|
break;
|
|
|
|
case EXCP_SWI:
|
2006-02-04 20:35:26 +01:00
|
|
|
case EXCP_BKPT:
|
2003-06-15 22:05:50 +02:00
|
|
|
{
|
2006-02-09 17:49:55 +01:00
|
|
|
env->eabi = 1;
|
2003-06-15 22:05:50 +02:00
|
|
|
/* system call */
|
2006-02-04 20:35:26 +01:00
|
|
|
if (trapnr == EXCP_BKPT) {
|
|
|
|
if (env->thumb) {
|
2007-11-16 11:46:05 +01:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
|
|
|
get_user_u16(insn, env->regs[15]);
|
2006-02-04 20:35:26 +01:00
|
|
|
n = insn & 0xff;
|
|
|
|
env->regs[15] += 2;
|
|
|
|
} else {
|
2007-11-16 11:46:05 +01:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
|
|
|
get_user_u32(insn, env->regs[15]);
|
2006-02-04 20:35:26 +01:00
|
|
|
n = (insn & 0xf) | ((insn >> 4) & 0xff0);
|
|
|
|
env->regs[15] += 4;
|
|
|
|
}
|
2005-04-27 22:11:21 +02:00
|
|
|
} else {
|
2006-02-04 20:35:26 +01:00
|
|
|
if (env->thumb) {
|
2007-11-16 11:46:05 +01:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
|
|
|
get_user_u16(insn, env->regs[15] - 2);
|
2006-02-04 20:35:26 +01:00
|
|
|
n = insn & 0xff;
|
|
|
|
} else {
|
2007-11-16 11:46:05 +01:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
|
|
|
get_user_u32(insn, env->regs[15] - 4);
|
2006-02-04 20:35:26 +01:00
|
|
|
n = insn & 0xffffff;
|
|
|
|
}
|
2005-04-27 22:11:21 +02:00
|
|
|
}
|
|
|
|
|
2004-04-25 20:00:45 +02:00
|
|
|
if (n == ARM_NR_cacheflush) {
|
2011-05-14 13:55:30 +02:00
|
|
|
/* nop */
|
2005-04-23 20:25:41 +02:00
|
|
|
} else if (n == ARM_NR_semihosting
|
|
|
|
|| n == ARM_NR_thumb_semihosting) {
|
|
|
|
env->regs[0] = do_arm_semihosting (env);
|
2006-02-09 17:49:55 +01:00
|
|
|
} else if (n == 0 || n >= ARM_SYSCALL_BASE
|
2005-04-27 22:11:21 +02:00
|
|
|
|| (env->thumb && n == ARM_THUMB_SYSCALL)) {
|
2003-06-15 22:05:50 +02:00
|
|
|
/* linux syscall */
|
2006-02-09 17:49:55 +01:00
|
|
|
if (env->thumb || n == 0) {
|
2005-04-27 22:11:21 +02:00
|
|
|
n = env->regs[7];
|
|
|
|
} else {
|
|
|
|
n -= ARM_SYSCALL_BASE;
|
2006-02-09 17:49:55 +01:00
|
|
|
env->eabi = 0;
|
2005-04-27 22:11:21 +02:00
|
|
|
}
|
2008-05-29 02:20:44 +02:00
|
|
|
if ( n > ARM_NR_BASE) {
|
|
|
|
switch (n) {
|
|
|
|
case ARM_NR_cacheflush:
|
2011-05-14 13:55:30 +02:00
|
|
|
/* nop */
|
2008-05-29 02:20:44 +02:00
|
|
|
break;
|
|
|
|
case ARM_NR_set_tls:
|
|
|
|
cpu_set_tls(env, env->regs[0]);
|
|
|
|
env->regs[0] = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gemu_log("qemu: Unsupported ARM syscall: 0x%x\n",
|
|
|
|
n);
|
|
|
|
env->regs[0] = -TARGET_ENOSYS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
env->regs[0] = do_syscall(env,
|
|
|
|
n,
|
|
|
|
env->regs[0],
|
|
|
|
env->regs[1],
|
|
|
|
env->regs[2],
|
|
|
|
env->regs[3],
|
|
|
|
env->regs[4],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->regs[5],
|
|
|
|
0, 0);
|
2008-05-29 02:20:44 +02:00
|
|
|
}
|
2003-06-15 22:05:50 +02:00
|
|
|
} else {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2003-07-09 21:31:39 +02:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2005-02-08 00:12:27 +01:00
|
|
|
case EXCP_PREFETCH_ABORT:
|
2008-07-29 16:09:57 +02:00
|
|
|
addr = env->cp15.c6_insn;
|
2005-11-26 11:38:39 +01:00
|
|
|
goto do_segv;
|
2005-02-08 00:12:27 +01:00
|
|
|
case EXCP_DATA_ABORT:
|
2008-07-29 16:09:57 +02:00
|
|
|
addr = env->cp15.c6_data;
|
2005-11-26 11:38:39 +01:00
|
|
|
goto do_segv;
|
|
|
|
do_segv:
|
2005-02-08 00:12:27 +01:00
|
|
|
{
|
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
2005-11-26 11:38:39 +01:00
|
|
|
info._sifields._sigfault._addr = addr;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-02-08 00:12:27 +01:00
|
|
|
}
|
|
|
|
break;
|
2005-04-17 21:16:13 +02:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig (env, TARGET_SIGTRAP);
|
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-04-17 21:16:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2008-05-29 02:20:44 +02:00
|
|
|
case EXCP_KERNEL_TRAP:
|
|
|
|
if (do_kernel_trap(env))
|
|
|
|
goto error;
|
|
|
|
break;
|
2009-11-22 22:35:13 +01:00
|
|
|
case EXCP_STREX:
|
|
|
|
if (do_strex(env)) {
|
|
|
|
addr = env->cp15.c6_data;
|
|
|
|
goto do_segv;
|
|
|
|
}
|
2009-11-24 14:10:08 +01:00
|
|
|
break;
|
2003-06-15 22:05:50 +02:00
|
|
|
default:
|
|
|
|
error:
|
2007-09-16 23:08:06 +02:00
|
|
|
fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
|
2003-06-15 22:05:50 +02:00
|
|
|
trapnr);
|
2004-10-09 20:08:01 +02:00
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
2003-06-15 22:05:50 +02:00
|
|
|
abort();
|
|
|
|
}
|
|
|
|
process_pending_signals(env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2003-03-22 18:31:38 +01:00
|
|
|
|
2011-04-12 10:27:03 +02:00
|
|
|
#ifdef TARGET_UNICORE32
|
|
|
|
|
|
|
|
void cpu_loop(CPUState *env)
|
|
|
|
{
|
|
|
|
int trapnr;
|
|
|
|
unsigned int n, insn;
|
|
|
|
target_siginfo_t info;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
cpu_exec_start(env);
|
|
|
|
trapnr = uc32_cpu_exec(env);
|
|
|
|
cpu_exec_end(env);
|
|
|
|
switch (trapnr) {
|
|
|
|
case UC32_EXCP_PRIV:
|
|
|
|
{
|
|
|
|
/* system call */
|
|
|
|
get_user_u32(insn, env->regs[31] - 4);
|
|
|
|
n = insn & 0xffffff;
|
|
|
|
|
|
|
|
if (n >= UC32_SYSCALL_BASE) {
|
|
|
|
/* linux syscall */
|
|
|
|
n -= UC32_SYSCALL_BASE;
|
|
|
|
if (n == UC32_SYSCALL_NR_set_tls) {
|
|
|
|
cpu_set_tls(env, env->regs[0]);
|
|
|
|
env->regs[0] = 0;
|
|
|
|
} else {
|
|
|
|
env->regs[0] = do_syscall(env,
|
|
|
|
n,
|
|
|
|
env->regs[0],
|
|
|
|
env->regs[1],
|
|
|
|
env->regs[2],
|
|
|
|
env->regs[3],
|
|
|
|
env->regs[4],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->regs[5],
|
|
|
|
0, 0);
|
2011-04-12 10:27:03 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case UC32_EXCP_TRAP:
|
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
info._sifields._sigfault._addr = env->cp0.c4_faultaddr;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig(env, TARGET_SIGTRAP);
|
|
|
|
if (sig) {
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
process_pending_signals(env);
|
|
|
|
}
|
|
|
|
|
|
|
|
error:
|
|
|
|
fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", trapnr);
|
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2003-09-30 22:57:29 +02:00
|
|
|
#ifdef TARGET_SPARC
|
2008-08-30 11:20:21 +02:00
|
|
|
#define SPARC64_STACK_BIAS 2047
|
2003-09-30 22:57:29 +02:00
|
|
|
|
2004-01-04 16:50:01 +01:00
|
|
|
//#define DEBUG_WIN
|
|
|
|
|
2005-02-19 18:25:31 +01:00
|
|
|
/* WARNING: dealing with register windows _is_ complicated. More info
|
|
|
|
can be found at http://www.sics.se/~psm/sparcstack.html */
|
2004-01-04 16:50:01 +01:00
|
|
|
static inline int get_reg_index(CPUSPARCState *env, int cwp, int index)
|
|
|
|
{
|
2008-06-07 10:07:37 +02:00
|
|
|
index = (index + cwp * 16) % (16 * env->nwindows);
|
2004-01-04 16:50:01 +01:00
|
|
|
/* wrap handling : if cwp is on the last window, then we use the
|
|
|
|
registers 'after' the end */
|
2008-06-07 10:07:37 +02:00
|
|
|
if (index < 8 && env->cwp == env->nwindows - 1)
|
|
|
|
index += 16 * env->nwindows;
|
2004-01-04 16:50:01 +01:00
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
2005-02-19 18:25:31 +01:00
|
|
|
/* save the register window 'cwp1' */
|
|
|
|
static inline void save_window_offset(CPUSPARCState *env, int cwp1)
|
2004-01-04 16:50:01 +01:00
|
|
|
{
|
2005-02-19 18:25:31 +01:00
|
|
|
unsigned int i;
|
2007-10-14 18:27:31 +02:00
|
|
|
abi_ulong sp_ptr;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2006-03-25 20:31:22 +01:00
|
|
|
sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
|
2008-08-30 11:20:21 +02:00
|
|
|
#ifdef TARGET_SPARC64
|
|
|
|
if (sp_ptr & 3)
|
|
|
|
sp_ptr += SPARC64_STACK_BIAS;
|
|
|
|
#endif
|
2004-01-04 16:50:01 +01:00
|
|
|
#if defined(DEBUG_WIN)
|
2008-06-15 20:02:48 +02:00
|
|
|
printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n",
|
|
|
|
sp_ptr, cwp1);
|
2004-01-04 16:50:01 +01:00
|
|
|
#endif
|
2005-02-19 18:25:31 +01:00
|
|
|
for(i = 0; i < 16; i++) {
|
2007-11-16 11:46:05 +01:00
|
|
|
/* FIXME - what to do if put_user() fails? */
|
|
|
|
put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
|
2007-10-14 18:27:31 +02:00
|
|
|
sp_ptr += sizeof(abi_ulong);
|
2005-02-19 18:25:31 +01:00
|
|
|
}
|
2004-01-04 16:50:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void save_window(CPUSPARCState *env)
|
|
|
|
{
|
2006-07-18 23:14:09 +02:00
|
|
|
#ifndef TARGET_SPARC64
|
2005-02-19 18:25:31 +01:00
|
|
|
unsigned int new_wim;
|
2008-06-07 10:07:37 +02:00
|
|
|
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));
|
2005-02-19 18:25:31 +01:00
|
|
|
env->wim = new_wim;
|
2006-07-18 23:14:09 +02:00
|
|
|
#else
|
2008-06-07 10:07:37 +02:00
|
|
|
save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
|
2006-07-18 23:14:09 +02:00
|
|
|
env->cansave++;
|
|
|
|
env->canrestore--;
|
|
|
|
#endif
|
2004-01-04 16:50:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void restore_window(CPUSPARCState *env)
|
|
|
|
{
|
2008-08-27 21:19:44 +02:00
|
|
|
#ifndef TARGET_SPARC64
|
|
|
|
unsigned int new_wim;
|
|
|
|
#endif
|
|
|
|
unsigned int i, cwp1;
|
2007-10-14 18:27:31 +02:00
|
|
|
abi_ulong sp_ptr;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2008-08-27 21:19:44 +02:00
|
|
|
#ifndef TARGET_SPARC64
|
2008-06-07 10:07:37 +02:00
|
|
|
new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) &
|
|
|
|
((1LL << env->nwindows) - 1);
|
2008-08-27 21:19:44 +02:00
|
|
|
#endif
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2004-01-04 16:50:01 +01:00
|
|
|
/* restore the invalid window */
|
2008-06-07 10:07:37 +02:00
|
|
|
cwp1 = cpu_cwp_inc(env, env->cwp + 1);
|
2006-03-25 20:31:22 +01:00
|
|
|
sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
|
2008-08-30 11:20:21 +02:00
|
|
|
#ifdef TARGET_SPARC64
|
|
|
|
if (sp_ptr & 3)
|
|
|
|
sp_ptr += SPARC64_STACK_BIAS;
|
|
|
|
#endif
|
2004-01-04 16:50:01 +01:00
|
|
|
#if defined(DEBUG_WIN)
|
2008-06-15 20:02:48 +02:00
|
|
|
printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n",
|
|
|
|
sp_ptr, cwp1);
|
2004-01-04 16:50:01 +01:00
|
|
|
#endif
|
2005-02-19 18:25:31 +01:00
|
|
|
for(i = 0; i < 16; i++) {
|
2007-11-16 11:46:05 +01:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
|
|
|
get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
|
2007-10-14 18:27:31 +02:00
|
|
|
sp_ptr += sizeof(abi_ulong);
|
2005-02-19 18:25:31 +01:00
|
|
|
}
|
2006-07-18 23:14:09 +02:00
|
|
|
#ifdef TARGET_SPARC64
|
|
|
|
env->canrestore++;
|
2008-06-07 10:07:37 +02:00
|
|
|
if (env->cleanwin < env->nwindows - 1)
|
|
|
|
env->cleanwin++;
|
2006-07-18 23:14:09 +02:00
|
|
|
env->cansave--;
|
2008-08-27 21:19:44 +02:00
|
|
|
#else
|
|
|
|
env->wim = new_wim;
|
2006-07-18 23:14:09 +02:00
|
|
|
#endif
|
2004-01-04 16:50:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void flush_windows(CPUSPARCState *env)
|
|
|
|
{
|
|
|
|
int offset, cwp1;
|
2005-02-19 18:25:31 +01:00
|
|
|
|
|
|
|
offset = 1;
|
2004-01-04 16:50:01 +01:00
|
|
|
for(;;) {
|
|
|
|
/* if restore would invoke restore_window(), then we can stop */
|
2008-06-07 10:07:37 +02:00
|
|
|
cwp1 = cpu_cwp_inc(env, env->cwp + offset);
|
2008-08-27 21:19:44 +02:00
|
|
|
#ifndef TARGET_SPARC64
|
2004-01-04 16:50:01 +01:00
|
|
|
if (env->wim & (1 << cwp1))
|
|
|
|
break;
|
2008-08-27 21:19:44 +02:00
|
|
|
#else
|
|
|
|
if (env->canrestore == 0)
|
|
|
|
break;
|
|
|
|
env->cansave++;
|
|
|
|
env->canrestore--;
|
|
|
|
#endif
|
2005-02-19 18:25:31 +01:00
|
|
|
save_window_offset(env, cwp1);
|
2004-01-04 16:50:01 +01:00
|
|
|
offset++;
|
|
|
|
}
|
2008-06-07 10:07:37 +02:00
|
|
|
cwp1 = cpu_cwp_inc(env, env->cwp + 1);
|
2008-08-27 21:19:44 +02:00
|
|
|
#ifndef TARGET_SPARC64
|
|
|
|
/* set wim so that restore will reload the registers */
|
2005-02-19 18:25:31 +01:00
|
|
|
env->wim = 1 << cwp1;
|
2008-08-27 21:19:44 +02:00
|
|
|
#endif
|
2005-02-19 18:25:31 +01:00
|
|
|
#if defined(DEBUG_WIN)
|
|
|
|
printf("flush_windows: nb=%d\n", offset - 1);
|
2005-01-04 00:31:27 +01:00
|
|
|
#endif
|
2005-02-19 18:25:31 +01:00
|
|
|
}
|
2004-01-04 16:50:01 +01:00
|
|
|
|
2003-09-30 22:57:29 +02:00
|
|
|
void cpu_loop (CPUSPARCState *env)
|
|
|
|
{
|
2010-04-25 20:01:25 +02:00
|
|
|
int trapnr;
|
|
|
|
abi_long ret;
|
2009-10-01 23:12:16 +02:00
|
|
|
target_siginfo_t info;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2004-01-04 16:50:01 +01:00
|
|
|
while (1) {
|
|
|
|
trapnr = cpu_sparc_exec (env);
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2004-01-04 16:50:01 +01:00
|
|
|
switch (trapnr) {
|
2006-07-18 23:14:09 +02:00
|
|
|
#ifndef TARGET_SPARC64
|
2007-09-16 23:08:06 +02:00
|
|
|
case 0x88:
|
2004-01-04 16:50:01 +01:00
|
|
|
case 0x90:
|
2006-07-18 23:14:09 +02:00
|
|
|
#else
|
2007-10-09 18:34:29 +02:00
|
|
|
case 0x110:
|
2006-07-18 23:14:09 +02:00
|
|
|
case 0x16d:
|
|
|
|
#endif
|
2004-01-04 16:50:01 +01:00
|
|
|
ret = do_syscall (env, env->gregs[1],
|
2007-09-16 23:08:06 +02:00
|
|
|
env->regwptr[0], env->regwptr[1],
|
|
|
|
env->regwptr[2], env->regwptr[3],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->regwptr[4], env->regwptr[5],
|
|
|
|
0, 0);
|
2010-04-25 20:01:25 +02:00
|
|
|
if ((abi_ulong)ret >= (abi_ulong)(-515)) {
|
2007-10-14 18:27:31 +02:00
|
|
|
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
|
2006-10-23 23:31:01 +02:00
|
|
|
env->xcc |= PSR_CARRY;
|
|
|
|
#else
|
2004-01-04 16:50:01 +01:00
|
|
|
env->psr |= PSR_CARRY;
|
2006-10-23 23:31:01 +02:00
|
|
|
#endif
|
2004-01-04 16:50:01 +01:00
|
|
|
ret = -ret;
|
|
|
|
} else {
|
2007-10-14 18:27:31 +02:00
|
|
|
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
|
2006-10-23 23:31:01 +02:00
|
|
|
env->xcc &= ~PSR_CARRY;
|
|
|
|
#else
|
2004-01-04 16:50:01 +01:00
|
|
|
env->psr &= ~PSR_CARRY;
|
2006-10-23 23:31:01 +02:00
|
|
|
#endif
|
2004-01-04 16:50:01 +01:00
|
|
|
}
|
|
|
|
env->regwptr[0] = ret;
|
|
|
|
/* next instruction */
|
|
|
|
env->pc = env->npc;
|
|
|
|
env->npc = env->npc + 4;
|
|
|
|
break;
|
|
|
|
case 0x83: /* flush windows */
|
2007-10-14 18:27:31 +02:00
|
|
|
#ifdef TARGET_ABI32
|
|
|
|
case 0x103:
|
|
|
|
#endif
|
2005-02-19 18:25:31 +01:00
|
|
|
flush_windows(env);
|
2004-01-04 16:50:01 +01:00
|
|
|
/* next instruction */
|
|
|
|
env->pc = env->npc;
|
|
|
|
env->npc = env->npc + 4;
|
|
|
|
break;
|
2005-07-02 16:31:34 +02:00
|
|
|
#ifndef TARGET_SPARC64
|
2004-01-04 16:50:01 +01:00
|
|
|
case TT_WIN_OVF: /* window overflow */
|
|
|
|
save_window(env);
|
|
|
|
break;
|
|
|
|
case TT_WIN_UNF: /* window underflow */
|
|
|
|
restore_window(env);
|
|
|
|
break;
|
2005-02-15 23:54:53 +01:00
|
|
|
case TT_TFAULT:
|
|
|
|
case TT_DFAULT:
|
|
|
|
{
|
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
info._sifields._sigfault._addr = env->mmuregs[4];
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-02-15 23:54:53 +01:00
|
|
|
}
|
|
|
|
break;
|
2005-07-02 16:31:34 +02:00
|
|
|
#else
|
2006-07-18 23:14:09 +02:00
|
|
|
case TT_SPILL: /* window overflow */
|
|
|
|
save_window(env);
|
|
|
|
break;
|
|
|
|
case TT_FILL: /* window underflow */
|
|
|
|
restore_window(env);
|
|
|
|
break;
|
2007-07-07 22:46:41 +02:00
|
|
|
case TT_TFAULT:
|
|
|
|
case TT_DFAULT:
|
|
|
|
{
|
|
|
|
info.si_signo = 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->dmmuregs[4];
|
|
|
|
else
|
2009-08-03 21:15:02 +02:00
|
|
|
info._sifields._sigfault._addr = cpu_tsptr(env)->tpc;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-07-07 22:46:41 +02:00
|
|
|
}
|
|
|
|
break;
|
2007-11-11 20:32:52 +01:00
|
|
|
#ifndef TARGET_ABI32
|
2007-10-05 19:01:51 +02:00
|
|
|
case 0x16e:
|
|
|
|
flush_windows(env);
|
|
|
|
sparc64_get_context(env);
|
|
|
|
break;
|
|
|
|
case 0x16f:
|
|
|
|
flush_windows(env);
|
|
|
|
sparc64_set_context(env);
|
|
|
|
break;
|
2007-11-11 20:32:52 +01:00
|
|
|
#endif
|
2005-07-02 16:31:34 +02:00
|
|
|
#endif
|
2006-06-21 20:15:50 +02:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2005-04-17 21:16:13 +02:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig (env, TARGET_SIGTRAP);
|
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-04-17 21:16:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2004-01-04 16:50:01 +01:00
|
|
|
default:
|
|
|
|
printf ("Unhandled trap: 0x%x\n", trapnr);
|
2004-10-09 20:08:01 +02:00
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
2004-01-04 16:50:01 +01:00
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
2003-09-30 22:57:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2003-11-23 18:05:30 +01:00
|
|
|
#ifdef TARGET_PPC
|
2004-05-21 14:59:32 +02:00
|
|
|
static inline uint64_t cpu_ppc_get_tb (CPUState *env)
|
|
|
|
{
|
|
|
|
/* TO FIX */
|
|
|
|
return 0;
|
|
|
|
}
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2009-12-21 12:24:17 +01:00
|
|
|
uint64_t cpu_ppc_load_tbl (CPUState *env)
|
2004-05-21 14:59:32 +02:00
|
|
|
{
|
2009-12-21 12:24:17 +01:00
|
|
|
return cpu_ppc_get_tb(env);
|
2004-05-21 14:59:32 +02:00
|
|
|
}
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2004-05-21 14:59:32 +02:00
|
|
|
uint32_t cpu_ppc_load_tbu (CPUState *env)
|
|
|
|
{
|
|
|
|
return cpu_ppc_get_tb(env) >> 32;
|
|
|
|
}
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2009-12-21 13:52:08 +01:00
|
|
|
uint64_t cpu_ppc_load_atbl (CPUState *env)
|
2004-05-21 14:59:32 +02:00
|
|
|
{
|
2009-12-21 13:52:08 +01:00
|
|
|
return cpu_ppc_get_tb(env);
|
2004-05-21 14:59:32 +02:00
|
|
|
}
|
2007-09-16 23:08:06 +02:00
|
|
|
|
2007-09-30 02:38:38 +02:00
|
|
|
uint32_t cpu_ppc_load_atbu (CPUState *env)
|
2004-05-21 14:59:32 +02:00
|
|
|
{
|
2007-09-30 02:38:38 +02:00
|
|
|
return cpu_ppc_get_tb(env) >> 32;
|
2004-05-21 14:59:32 +02:00
|
|
|
}
|
2007-03-07 09:32:30 +01:00
|
|
|
|
|
|
|
uint32_t cpu_ppc601_load_rtcu (CPUState *env)
|
|
|
|
__attribute__ (( alias ("cpu_ppc_load_tbu") ));
|
|
|
|
|
|
|
|
uint32_t cpu_ppc601_load_rtcl (CPUState *env)
|
2004-05-21 14:59:32 +02:00
|
|
|
{
|
2007-03-07 09:32:30 +01:00
|
|
|
return cpu_ppc_load_tbl(env) & 0x3FFFFF80;
|
2004-05-21 14:59:32 +02:00
|
|
|
}
|
2007-03-07 09:32:30 +01:00
|
|
|
|
Great rework and cleanups to ease PowerPC implementations definitions.
* cleanup cpu.h, removing definitions used only in translate.c/translate_init.c
* add new flags to define instructions sets more precisely
* various changes in MMU models definitions
* add definitions for PowerPC 440/460 support (insns and SPRs).
* add definitions for PowerPC 401/403 and 620 input pins model
* Fix definitions for most PowerPC 401, 403, 405, 440, 601, 602, 603 and 7x0
* Preliminary support for PowerPC 74xx (aka G4) without altivec.
* Code provision for other PowerPC support (7x5, 970, ...).
* New SPR and PVR defined, from PowerPC 2.04 specification and other sources
* Misc code bugs, error messages and styles fixes.
* Update status files for PowerPC cores support.
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3244 c046a42c-6fe2-441c-8c8c-71466251a162
2007-09-27 01:54:22 +02:00
|
|
|
/* XXX: to be fixed */
|
2009-12-21 14:02:39 +01:00
|
|
|
int ppc_dcr_read (ppc_dcr_t *dcr_env, int dcrn, uint32_t *valp)
|
Great rework and cleanups to ease PowerPC implementations definitions.
* cleanup cpu.h, removing definitions used only in translate.c/translate_init.c
* add new flags to define instructions sets more precisely
* various changes in MMU models definitions
* add definitions for PowerPC 440/460 support (insns and SPRs).
* add definitions for PowerPC 401/403 and 620 input pins model
* Fix definitions for most PowerPC 401, 403, 405, 440, 601, 602, 603 and 7x0
* Preliminary support for PowerPC 74xx (aka G4) without altivec.
* Code provision for other PowerPC support (7x5, 970, ...).
* New SPR and PVR defined, from PowerPC 2.04 specification and other sources
* Misc code bugs, error messages and styles fixes.
* Update status files for PowerPC cores support.
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3244 c046a42c-6fe2-441c-8c8c-71466251a162
2007-09-27 01:54:22 +02:00
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-12-21 14:02:39 +01:00
|
|
|
int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, uint32_t val)
|
Great rework and cleanups to ease PowerPC implementations definitions.
* cleanup cpu.h, removing definitions used only in translate.c/translate_init.c
* add new flags to define instructions sets more precisely
* various changes in MMU models definitions
* add definitions for PowerPC 440/460 support (insns and SPRs).
* add definitions for PowerPC 401/403 and 620 input pins model
* Fix definitions for most PowerPC 401, 403, 405, 440, 601, 602, 603 and 7x0
* Preliminary support for PowerPC 74xx (aka G4) without altivec.
* Code provision for other PowerPC support (7x5, 970, ...).
* New SPR and PVR defined, from PowerPC 2.04 specification and other sources
* Misc code bugs, error messages and styles fixes.
* Update status files for PowerPC cores support.
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3244 c046a42c-6fe2-441c-8c8c-71466251a162
2007-09-27 01:54:22 +02:00
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-05-13 19:53:17 +02:00
|
|
|
#define EXCP_DUMP(env, fmt, ...) \
|
|
|
|
do { \
|
|
|
|
fprintf(stderr, fmt , ## __VA_ARGS__); \
|
|
|
|
cpu_dump_state(env, stderr, fprintf, 0); \
|
|
|
|
qemu_log(fmt, ## __VA_ARGS__); \
|
2009-07-15 18:52:47 +02:00
|
|
|
if (logfile) \
|
|
|
|
log_cpu_state(env, 0); \
|
2007-09-29 15:06:16 +02:00
|
|
|
} while (0)
|
|
|
|
|
2009-08-03 17:43:27 +02:00
|
|
|
static int do_store_exclusive(CPUPPCState *env)
|
|
|
|
{
|
|
|
|
target_ulong addr;
|
|
|
|
target_ulong page_addr;
|
|
|
|
target_ulong val;
|
|
|
|
int flags;
|
|
|
|
int segv = 0;
|
|
|
|
|
|
|
|
addr = env->reserve_ea;
|
|
|
|
page_addr = addr & TARGET_PAGE_MASK;
|
|
|
|
start_exclusive();
|
|
|
|
mmap_lock();
|
|
|
|
flags = page_get_flags(page_addr);
|
|
|
|
if ((flags & PAGE_READ) == 0) {
|
|
|
|
segv = 1;
|
|
|
|
} else {
|
|
|
|
int reg = env->reserve_info & 0x1f;
|
|
|
|
int size = (env->reserve_info >> 5) & 0xf;
|
|
|
|
int stored = 0;
|
|
|
|
|
|
|
|
if (addr == env->reserve_addr) {
|
|
|
|
switch (size) {
|
|
|
|
case 1: segv = get_user_u8(val, addr); break;
|
|
|
|
case 2: segv = get_user_u16(val, addr); break;
|
|
|
|
case 4: segv = get_user_u32(val, addr); break;
|
|
|
|
#if defined(TARGET_PPC64)
|
|
|
|
case 8: segv = get_user_u64(val, addr); break;
|
|
|
|
#endif
|
|
|
|
default: abort();
|
|
|
|
}
|
|
|
|
if (!segv && val == env->reserve_val) {
|
|
|
|
val = env->gpr[reg];
|
|
|
|
switch (size) {
|
|
|
|
case 1: segv = put_user_u8(val, addr); break;
|
|
|
|
case 2: segv = put_user_u16(val, addr); break;
|
|
|
|
case 4: segv = put_user_u32(val, addr); break;
|
|
|
|
#if defined(TARGET_PPC64)
|
|
|
|
case 8: segv = put_user_u64(val, addr); break;
|
|
|
|
#endif
|
|
|
|
default: abort();
|
|
|
|
}
|
|
|
|
if (!segv) {
|
|
|
|
stored = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
env->crf[0] = (stored << 1) | xer_so;
|
|
|
|
env->reserve_addr = (target_ulong)-1;
|
|
|
|
}
|
|
|
|
if (!segv) {
|
|
|
|
env->nip += 4;
|
|
|
|
}
|
|
|
|
mmap_unlock();
|
|
|
|
end_exclusive();
|
|
|
|
return segv;
|
|
|
|
}
|
|
|
|
|
2003-11-23 18:05:30 +01:00
|
|
|
void cpu_loop(CPUPPCState *env)
|
|
|
|
{
|
2009-10-01 23:12:16 +02:00
|
|
|
target_siginfo_t info;
|
2004-01-05 00:54:31 +01:00
|
|
|
int trapnr;
|
|
|
|
uint32_t ret;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2003-11-23 18:05:30 +01:00
|
|
|
for(;;) {
|
2009-08-03 17:43:27 +02:00
|
|
|
cpu_exec_start(env);
|
2003-11-23 18:05:30 +01:00
|
|
|
trapnr = cpu_ppc_exec(env);
|
2009-08-03 17:43:27 +02:00
|
|
|
cpu_exec_end(env);
|
2003-11-23 18:05:30 +01:00
|
|
|
switch(trapnr) {
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_NONE:
|
|
|
|
/* Just go on */
|
2003-11-23 18:05:30 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_CRITICAL: /* Critical input */
|
|
|
|
cpu_abort(env, "Critical interrupt while in user mode. "
|
|
|
|
"Aborting\n");
|
2004-01-05 00:54:31 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_MCHECK: /* Machine check exception */
|
|
|
|
cpu_abort(env, "Machine check exception while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DSI: /* Data storage exception */
|
2009-08-16 13:13:18 +02:00
|
|
|
EXCP_DUMP(env, "Invalid data memory access: 0x" TARGET_FMT_lx "\n",
|
2007-09-29 15:06:16 +02:00
|
|
|
env->spr[SPR_DAR]);
|
|
|
|
/* XXX: check this. Seems bugged */
|
2005-07-03 00:09:27 +02:00
|
|
|
switch (env->error_code & 0xFF000000) {
|
|
|
|
case 0x40000000:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
break;
|
2005-07-03 00:09:27 +02:00
|
|
|
case 0x04000000:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLADR;
|
|
|
|
break;
|
2005-07-03 00:09:27 +02:00
|
|
|
case 0x08000000:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_ACCERR;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Let's send a regular segfault... */
|
2007-09-29 15:06:16 +02:00
|
|
|
EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
|
|
|
|
env->error_code);
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
break;
|
|
|
|
}
|
2003-11-23 18:05:30 +01:00
|
|
|
info._sifields._sigfault._addr = env->nip;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-11-23 18:05:30 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_ISI: /* Instruction storage exception */
|
2009-08-16 13:13:18 +02:00
|
|
|
EXCP_DUMP(env, "Invalid instruction fetch: 0x\n" TARGET_FMT_lx
|
|
|
|
"\n", env->spr[SPR_SRR0]);
|
2007-09-29 15:06:16 +02:00
|
|
|
/* XXX: check this */
|
2005-07-03 00:09:27 +02:00
|
|
|
switch (env->error_code & 0xFF000000) {
|
|
|
|
case 0x40000000:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2003-11-23 18:05:30 +01:00
|
|
|
info.si_errno = 0;
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
break;
|
2005-07-03 00:09:27 +02:00
|
|
|
case 0x10000000:
|
|
|
|
case 0x08000000:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_ACCERR;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Let's send a regular segfault... */
|
2007-09-29 15:06:16 +02:00
|
|
|
EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
|
|
|
|
env->error_code);
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
info._sifields._sigfault._addr = env->nip - 4;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-11-23 18:05:30 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_EXTERNAL: /* External input */
|
|
|
|
cpu_abort(env, "External interrupt while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_ALIGN: /* Alignment exception */
|
|
|
|
EXCP_DUMP(env, "Unaligned memory access\n");
|
|
|
|
/* XXX: check this */
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGBUS;
|
2003-11-23 18:05:30 +01:00
|
|
|
info.si_errno = 0;
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_BUS_ADRALN;
|
|
|
|
info._sifields._sigfault._addr = env->nip - 4;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-11-23 18:05:30 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_PROGRAM: /* Program exception */
|
|
|
|
/* XXX: check this */
|
2004-01-05 00:54:31 +01:00
|
|
|
switch (env->error_code & ~0xF) {
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_FP:
|
|
|
|
EXCP_DUMP(env, "Floating point program exception\n");
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGFPE;
|
|
|
|
info.si_errno = 0;
|
|
|
|
switch (env->error_code & 0xF) {
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_FP_OX:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_FPE_FLTOVF;
|
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_FP_UX:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_FPE_FLTUND;
|
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_FP_ZX:
|
|
|
|
case POWERPC_EXCP_FP_VXZDZ:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_FPE_FLTDIV;
|
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_FP_XX:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_FPE_FLTRES;
|
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_FP_VXSOFT:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_FPE_FLTINV;
|
|
|
|
break;
|
2007-10-27 19:54:30 +02:00
|
|
|
case POWERPC_EXCP_FP_VXSNAN:
|
2007-09-29 15:06:16 +02:00
|
|
|
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:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_FPE_FLTSUB;
|
|
|
|
break;
|
|
|
|
default:
|
2007-09-29 15:06:16 +02:00
|
|
|
EXCP_DUMP(env, "Unknown floating point exception (%02x)\n",
|
|
|
|
env->error_code);
|
|
|
|
break;
|
2004-01-05 00:54:31 +01:00
|
|
|
}
|
2007-09-29 15:06:16 +02:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_INVAL:
|
|
|
|
EXCP_DUMP(env, "Invalid instruction\n");
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
switch (env->error_code & 0xF) {
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_INVAL_INVAL:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_ILL_ILLOPC;
|
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_INVAL_LSWX:
|
Great rework and cleanups to ease PowerPC implementations definitions.
* cleanup cpu.h, removing definitions used only in translate.c/translate_init.c
* add new flags to define instructions sets more precisely
* various changes in MMU models definitions
* add definitions for PowerPC 440/460 support (insns and SPRs).
* add definitions for PowerPC 401/403 and 620 input pins model
* Fix definitions for most PowerPC 401, 403, 405, 440, 601, 602, 603 and 7x0
* Preliminary support for PowerPC 74xx (aka G4) without altivec.
* Code provision for other PowerPC support (7x5, 970, ...).
* New SPR and PVR defined, from PowerPC 2.04 specification and other sources
* Misc code bugs, error messages and styles fixes.
* Update status files for PowerPC cores support.
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3244 c046a42c-6fe2-441c-8c8c-71466251a162
2007-09-27 01:54:22 +02:00
|
|
|
info.si_code = TARGET_ILL_ILLOPN;
|
2004-01-05 00:54:31 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_INVAL_SPR:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_ILL_PRVREG;
|
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_INVAL_FP:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_ILL_COPROC;
|
|
|
|
break;
|
|
|
|
default:
|
2007-09-29 15:06:16 +02:00
|
|
|
EXCP_DUMP(env, "Unknown invalid operation (%02x)\n",
|
|
|
|
env->error_code & 0xF);
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_ILL_ILLADR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_PRIV:
|
|
|
|
EXCP_DUMP(env, "Privilege violation\n");
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
switch (env->error_code & 0xF) {
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_PRIV_OPC:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_ILL_PRVOPC;
|
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_PRIV_REG:
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_ILL_PRVREG;
|
2007-09-29 15:06:16 +02:00
|
|
|
break;
|
2004-01-05 00:54:31 +01:00
|
|
|
default:
|
2007-09-29 15:06:16 +02:00
|
|
|
EXCP_DUMP(env, "Unknown privilege violation (%02x)\n",
|
|
|
|
env->error_code & 0xF);
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_ILL_PRVOPC;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_TRAP:
|
|
|
|
cpu_abort(env, "Tried to call a TRAP\n");
|
|
|
|
break;
|
2004-01-05 00:54:31 +01:00
|
|
|
default:
|
|
|
|
/* Should not happen ! */
|
2007-09-29 15:06:16 +02:00
|
|
|
cpu_abort(env, "Unknown program exception (%02x)\n",
|
|
|
|
env->error_code);
|
|
|
|
break;
|
2004-01-05 00:54:31 +01:00
|
|
|
}
|
|
|
|
info._sifields._sigfault._addr = env->nip - 4;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-11-23 18:05:30 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */
|
|
|
|
EXCP_DUMP(env, "No floating point allowed\n");
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
2003-11-23 18:05:30 +01:00
|
|
|
info.si_errno = 0;
|
2004-01-05 00:54:31 +01:00
|
|
|
info.si_code = TARGET_ILL_COPROC;
|
|
|
|
info._sifields._sigfault._addr = env->nip - 4;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-11-23 18:05:30 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_SYSCALL: /* System call exception */
|
|
|
|
cpu_abort(env, "Syscall exception while in user mode. "
|
|
|
|
"Aborting\n");
|
2004-01-05 00:54:31 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_APU: /* Auxiliary processor unavailable */
|
|
|
|
EXCP_DUMP(env, "No APU instruction allowed\n");
|
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_COPROC;
|
|
|
|
info._sifields._sigfault._addr = env->nip - 4;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2004-01-05 00:54:31 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_DECR: /* Decrementer exception */
|
|
|
|
cpu_abort(env, "Decrementer interrupt while in user mode. "
|
|
|
|
"Aborting\n");
|
2004-01-05 00:54:31 +01:00
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_FIT: /* Fixed-interval timer interrupt */
|
|
|
|
cpu_abort(env, "Fix interval timer interrupt while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_WDT: /* Watchdog timer interrupt */
|
|
|
|
cpu_abort(env, "Watchdog timer interrupt while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DTLB: /* Data TLB error */
|
|
|
|
cpu_abort(env, "Data TLB exception while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_ITLB: /* Instruction TLB error */
|
|
|
|
cpu_abort(env, "Instruction TLB exception while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_SPEU: /* SPE/embedded floating-point unavail. */
|
|
|
|
EXCP_DUMP(env, "No SPE/floating-point instruction allowed\n");
|
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_COPROC;
|
|
|
|
info._sifields._sigfault._addr = env->nip - 4;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-09-29 15:06:16 +02:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_EFPDI: /* Embedded floating-point data IRQ */
|
|
|
|
cpu_abort(env, "Embedded floating-point data IRQ not handled\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_EFPRI: /* Embedded floating-point round IRQ */
|
|
|
|
cpu_abort(env, "Embedded floating-point round IRQ not handled\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_EPERFM: /* Embedded performance monitor IRQ */
|
|
|
|
cpu_abort(env, "Performance monitor exception not handled\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DOORI: /* Embedded doorbell interrupt */
|
|
|
|
cpu_abort(env, "Doorbell interrupt while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DOORCI: /* Embedded doorbell critical interrupt */
|
|
|
|
cpu_abort(env, "Doorbell critical interrupt while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_RESET: /* System reset exception */
|
|
|
|
cpu_abort(env, "Reset interrupt while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DSEG: /* Data segment exception */
|
|
|
|
cpu_abort(env, "Data segment exception while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_ISEG: /* Instruction segment exception */
|
|
|
|
cpu_abort(env, "Instruction segment exception "
|
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
2007-10-18 21:59:49 +02:00
|
|
|
/* PowerPC 64 with hypervisor mode support */
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_HDECR: /* Hypervisor decrementer exception */
|
|
|
|
cpu_abort(env, "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;
|
2007-10-18 21:59:49 +02:00
|
|
|
/* PowerPC 64 with hypervisor mode support */
|
2007-09-29 15:06:16 +02:00
|
|
|
case POWERPC_EXCP_HDSI: /* Hypervisor data storage exception */
|
|
|
|
cpu_abort(env, "Hypervisor data storage exception "
|
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_HISI: /* Hypervisor instruction storage excp */
|
|
|
|
cpu_abort(env, "Hypervisor instruction storage exception "
|
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_HDSEG: /* Hypervisor data segment exception */
|
|
|
|
cpu_abort(env, "Hypervisor data segment exception "
|
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_HISEG: /* Hypervisor instruction segment excp */
|
|
|
|
cpu_abort(env, "Hypervisor instruction segment exception "
|
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_VPU: /* Vector unavailable exception */
|
|
|
|
EXCP_DUMP(env, "No Altivec instructions allowed\n");
|
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_COPROC;
|
|
|
|
info._sifields._sigfault._addr = env->nip - 4;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-09-29 15:06:16 +02:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_PIT: /* Programmable interval timer IRQ */
|
|
|
|
cpu_abort(env, "Programable interval timer interrupt "
|
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_IO: /* IO error exception */
|
|
|
|
cpu_abort(env, "IO error exception while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_RUNM: /* Run mode exception */
|
|
|
|
cpu_abort(env, "Run mode exception while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_EMUL: /* Emulation trap exception */
|
|
|
|
cpu_abort(env, "Emulation trap exception not handled\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_IFTLB: /* Instruction fetch TLB error */
|
|
|
|
cpu_abort(env, "Instruction fetch TLB exception "
|
|
|
|
"while in user-mode. Aborting");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DLTLB: /* Data load TLB miss */
|
|
|
|
cpu_abort(env, "Data load TLB exception while in user-mode. "
|
|
|
|
"Aborting");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DSTLB: /* Data store TLB miss */
|
|
|
|
cpu_abort(env, "Data store TLB exception while in user-mode. "
|
|
|
|
"Aborting");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_FPA: /* Floating-point assist exception */
|
|
|
|
cpu_abort(env, "Floating-point assist exception not handled\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_IABR: /* Instruction address breakpoint */
|
|
|
|
cpu_abort(env, "Instruction address breakpoint exception "
|
|
|
|
"not handled\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_SMI: /* System management interrupt */
|
|
|
|
cpu_abort(env, "System management interrupt while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_THERM: /* Thermal interrupt */
|
|
|
|
cpu_abort(env, "Thermal interrupt interrupt while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_PERFM: /* Embedded performance monitor IRQ */
|
|
|
|
cpu_abort(env, "Performance monitor exception not handled\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_VPUA: /* Vector assist exception */
|
|
|
|
cpu_abort(env, "Vector assist exception not handled\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_SOFTP: /* Soft patch exception */
|
|
|
|
cpu_abort(env, "Soft patch exception not handled\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_MAINT: /* Maintenance exception */
|
|
|
|
cpu_abort(env, "Maintenance exception while in user mode. "
|
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_STOP: /* stop translation */
|
|
|
|
/* We did invalidate the instruction cache. Go on */
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_BRANCH: /* branch instruction: */
|
|
|
|
/* We just stopped because of a branch. Go on */
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
#if 0
|
|
|
|
printf("syscall %d 0x%08x 0x%08x 0x%08x 0x%08x\n", env->gpr[0],
|
|
|
|
env->gpr[3], env->gpr[4], env->gpr[5], env->gpr[6]);
|
|
|
|
#endif
|
|
|
|
env->crf[0] &= ~0x1;
|
|
|
|
ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
|
|
|
|
env->gpr[5], env->gpr[6], env->gpr[7],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->gpr[8], 0, 0);
|
2009-05-13 04:13:18 +02:00
|
|
|
if (ret == (uint32_t)(-TARGET_QEMU_ESIGRETURN)) {
|
|
|
|
/* Returning from a successful sigreturn syscall.
|
|
|
|
Avoid corrupting register state. */
|
|
|
|
break;
|
|
|
|
}
|
2007-09-29 15:06:16 +02:00
|
|
|
if (ret > (uint32_t)(-515)) {
|
|
|
|
env->crf[0] |= 0x1;
|
|
|
|
ret = -ret;
|
2004-01-05 00:54:31 +01:00
|
|
|
}
|
2007-09-29 15:06:16 +02:00
|
|
|
env->gpr[3] = ret;
|
|
|
|
#if 0
|
|
|
|
printf("syscall returned 0x%08x (%d)\n", ret, ret);
|
|
|
|
#endif
|
|
|
|
break;
|
2009-08-03 17:43:27 +02:00
|
|
|
case POWERPC_EXCP_STCX:
|
|
|
|
if (do_store_exclusive(env)) {
|
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
info._sifields._sigfault._addr = env->nip;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
break;
|
2008-11-14 18:05:54 +01:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig(env, TARGET_SIGTRAP);
|
|
|
|
if (sig) {
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2007-09-30 17:15:18 +02:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2007-09-29 15:06:16 +02:00
|
|
|
default:
|
|
|
|
cpu_abort(env, "Unknown exception 0x%d. Aborting\n", trapnr);
|
|
|
|
break;
|
2003-11-23 18:05:30 +01:00
|
|
|
}
|
|
|
|
process_pending_signals(env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-11-26 19:47:20 +01:00
|
|
|
#ifdef TARGET_MIPS
|
|
|
|
|
|
|
|
#define MIPS_SYS(name, args) args,
|
|
|
|
|
|
|
|
static const uint8_t mips_syscall_args[] = {
|
|
|
|
MIPS_SYS(sys_syscall , 0) /* 4000 */
|
|
|
|
MIPS_SYS(sys_exit , 1)
|
|
|
|
MIPS_SYS(sys_fork , 0)
|
|
|
|
MIPS_SYS(sys_read , 3)
|
|
|
|
MIPS_SYS(sys_write , 3)
|
|
|
|
MIPS_SYS(sys_open , 3) /* 4005 */
|
|
|
|
MIPS_SYS(sys_close , 1)
|
|
|
|
MIPS_SYS(sys_waitpid , 3)
|
|
|
|
MIPS_SYS(sys_creat , 2)
|
|
|
|
MIPS_SYS(sys_link , 2)
|
|
|
|
MIPS_SYS(sys_unlink , 1) /* 4010 */
|
|
|
|
MIPS_SYS(sys_execve , 0)
|
|
|
|
MIPS_SYS(sys_chdir , 1)
|
|
|
|
MIPS_SYS(sys_time , 1)
|
|
|
|
MIPS_SYS(sys_mknod , 3)
|
|
|
|
MIPS_SYS(sys_chmod , 2) /* 4015 */
|
|
|
|
MIPS_SYS(sys_lchown , 3)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* was sys_stat */
|
|
|
|
MIPS_SYS(sys_lseek , 3)
|
|
|
|
MIPS_SYS(sys_getpid , 0) /* 4020 */
|
|
|
|
MIPS_SYS(sys_mount , 5)
|
|
|
|
MIPS_SYS(sys_oldumount , 1)
|
|
|
|
MIPS_SYS(sys_setuid , 1)
|
|
|
|
MIPS_SYS(sys_getuid , 0)
|
|
|
|
MIPS_SYS(sys_stime , 1) /* 4025 */
|
|
|
|
MIPS_SYS(sys_ptrace , 4)
|
|
|
|
MIPS_SYS(sys_alarm , 1)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* was sys_fstat */
|
|
|
|
MIPS_SYS(sys_pause , 0)
|
|
|
|
MIPS_SYS(sys_utime , 2) /* 4030 */
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0)
|
|
|
|
MIPS_SYS(sys_access , 2)
|
|
|
|
MIPS_SYS(sys_nice , 1)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* 4035 */
|
|
|
|
MIPS_SYS(sys_sync , 0)
|
|
|
|
MIPS_SYS(sys_kill , 2)
|
|
|
|
MIPS_SYS(sys_rename , 2)
|
|
|
|
MIPS_SYS(sys_mkdir , 2)
|
|
|
|
MIPS_SYS(sys_rmdir , 1) /* 4040 */
|
|
|
|
MIPS_SYS(sys_dup , 1)
|
|
|
|
MIPS_SYS(sys_pipe , 0)
|
|
|
|
MIPS_SYS(sys_times , 1)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0)
|
|
|
|
MIPS_SYS(sys_brk , 1) /* 4045 */
|
|
|
|
MIPS_SYS(sys_setgid , 1)
|
|
|
|
MIPS_SYS(sys_getgid , 0)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* was signal(2) */
|
|
|
|
MIPS_SYS(sys_geteuid , 0)
|
|
|
|
MIPS_SYS(sys_getegid , 0) /* 4050 */
|
|
|
|
MIPS_SYS(sys_acct , 0)
|
|
|
|
MIPS_SYS(sys_umount , 2)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0)
|
|
|
|
MIPS_SYS(sys_ioctl , 3)
|
|
|
|
MIPS_SYS(sys_fcntl , 3) /* 4055 */
|
|
|
|
MIPS_SYS(sys_ni_syscall , 2)
|
|
|
|
MIPS_SYS(sys_setpgid , 2)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0)
|
|
|
|
MIPS_SYS(sys_olduname , 1)
|
|
|
|
MIPS_SYS(sys_umask , 1) /* 4060 */
|
|
|
|
MIPS_SYS(sys_chroot , 1)
|
|
|
|
MIPS_SYS(sys_ustat , 2)
|
|
|
|
MIPS_SYS(sys_dup2 , 2)
|
|
|
|
MIPS_SYS(sys_getppid , 0)
|
|
|
|
MIPS_SYS(sys_getpgrp , 0) /* 4065 */
|
|
|
|
MIPS_SYS(sys_setsid , 0)
|
|
|
|
MIPS_SYS(sys_sigaction , 3)
|
|
|
|
MIPS_SYS(sys_sgetmask , 0)
|
|
|
|
MIPS_SYS(sys_ssetmask , 1)
|
|
|
|
MIPS_SYS(sys_setreuid , 2) /* 4070 */
|
|
|
|
MIPS_SYS(sys_setregid , 2)
|
|
|
|
MIPS_SYS(sys_sigsuspend , 0)
|
|
|
|
MIPS_SYS(sys_sigpending , 1)
|
|
|
|
MIPS_SYS(sys_sethostname , 2)
|
|
|
|
MIPS_SYS(sys_setrlimit , 2) /* 4075 */
|
|
|
|
MIPS_SYS(sys_getrlimit , 2)
|
|
|
|
MIPS_SYS(sys_getrusage , 2)
|
|
|
|
MIPS_SYS(sys_gettimeofday, 2)
|
|
|
|
MIPS_SYS(sys_settimeofday, 2)
|
|
|
|
MIPS_SYS(sys_getgroups , 2) /* 4080 */
|
|
|
|
MIPS_SYS(sys_setgroups , 2)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* old_select */
|
|
|
|
MIPS_SYS(sys_symlink , 2)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* was sys_lstat */
|
|
|
|
MIPS_SYS(sys_readlink , 3) /* 4085 */
|
|
|
|
MIPS_SYS(sys_uselib , 1)
|
|
|
|
MIPS_SYS(sys_swapon , 2)
|
|
|
|
MIPS_SYS(sys_reboot , 3)
|
|
|
|
MIPS_SYS(old_readdir , 3)
|
|
|
|
MIPS_SYS(old_mmap , 6) /* 4090 */
|
|
|
|
MIPS_SYS(sys_munmap , 2)
|
|
|
|
MIPS_SYS(sys_truncate , 2)
|
|
|
|
MIPS_SYS(sys_ftruncate , 2)
|
|
|
|
MIPS_SYS(sys_fchmod , 2)
|
|
|
|
MIPS_SYS(sys_fchown , 3) /* 4095 */
|
|
|
|
MIPS_SYS(sys_getpriority , 2)
|
|
|
|
MIPS_SYS(sys_setpriority , 3)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0)
|
|
|
|
MIPS_SYS(sys_statfs , 2)
|
|
|
|
MIPS_SYS(sys_fstatfs , 2) /* 4100 */
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* was ioperm(2) */
|
|
|
|
MIPS_SYS(sys_socketcall , 2)
|
|
|
|
MIPS_SYS(sys_syslog , 3)
|
|
|
|
MIPS_SYS(sys_setitimer , 3)
|
|
|
|
MIPS_SYS(sys_getitimer , 2) /* 4105 */
|
|
|
|
MIPS_SYS(sys_newstat , 2)
|
|
|
|
MIPS_SYS(sys_newlstat , 2)
|
|
|
|
MIPS_SYS(sys_newfstat , 2)
|
|
|
|
MIPS_SYS(sys_uname , 1)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* 4110 was iopl(2) */
|
|
|
|
MIPS_SYS(sys_vhangup , 0)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* was sys_idle() */
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* was sys_vm86 */
|
|
|
|
MIPS_SYS(sys_wait4 , 4)
|
|
|
|
MIPS_SYS(sys_swapoff , 1) /* 4115 */
|
|
|
|
MIPS_SYS(sys_sysinfo , 1)
|
|
|
|
MIPS_SYS(sys_ipc , 6)
|
|
|
|
MIPS_SYS(sys_fsync , 1)
|
|
|
|
MIPS_SYS(sys_sigreturn , 0)
|
2009-07-09 14:11:52 +02:00
|
|
|
MIPS_SYS(sys_clone , 6) /* 4120 */
|
2005-11-26 19:47:20 +01:00
|
|
|
MIPS_SYS(sys_setdomainname, 2)
|
|
|
|
MIPS_SYS(sys_newuname , 1)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* sys_modify_ldt */
|
|
|
|
MIPS_SYS(sys_adjtimex , 1)
|
|
|
|
MIPS_SYS(sys_mprotect , 3) /* 4125 */
|
|
|
|
MIPS_SYS(sys_sigprocmask , 3)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* was create_module */
|
|
|
|
MIPS_SYS(sys_init_module , 5)
|
|
|
|
MIPS_SYS(sys_delete_module, 1)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* 4130 was get_kernel_syms */
|
|
|
|
MIPS_SYS(sys_quotactl , 0)
|
|
|
|
MIPS_SYS(sys_getpgid , 1)
|
|
|
|
MIPS_SYS(sys_fchdir , 1)
|
|
|
|
MIPS_SYS(sys_bdflush , 2)
|
|
|
|
MIPS_SYS(sys_sysfs , 3) /* 4135 */
|
|
|
|
MIPS_SYS(sys_personality , 1)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* for afs_syscall */
|
|
|
|
MIPS_SYS(sys_setfsuid , 1)
|
|
|
|
MIPS_SYS(sys_setfsgid , 1)
|
|
|
|
MIPS_SYS(sys_llseek , 5) /* 4140 */
|
|
|
|
MIPS_SYS(sys_getdents , 3)
|
|
|
|
MIPS_SYS(sys_select , 5)
|
|
|
|
MIPS_SYS(sys_flock , 2)
|
|
|
|
MIPS_SYS(sys_msync , 3)
|
|
|
|
MIPS_SYS(sys_readv , 3) /* 4145 */
|
|
|
|
MIPS_SYS(sys_writev , 3)
|
|
|
|
MIPS_SYS(sys_cacheflush , 3)
|
|
|
|
MIPS_SYS(sys_cachectl , 3)
|
|
|
|
MIPS_SYS(sys_sysmips , 4)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* 4150 */
|
|
|
|
MIPS_SYS(sys_getsid , 1)
|
|
|
|
MIPS_SYS(sys_fdatasync , 0)
|
|
|
|
MIPS_SYS(sys_sysctl , 1)
|
|
|
|
MIPS_SYS(sys_mlock , 2)
|
|
|
|
MIPS_SYS(sys_munlock , 2) /* 4155 */
|
|
|
|
MIPS_SYS(sys_mlockall , 1)
|
|
|
|
MIPS_SYS(sys_munlockall , 0)
|
|
|
|
MIPS_SYS(sys_sched_setparam, 2)
|
|
|
|
MIPS_SYS(sys_sched_getparam, 2)
|
|
|
|
MIPS_SYS(sys_sched_setscheduler, 3) /* 4160 */
|
|
|
|
MIPS_SYS(sys_sched_getscheduler, 1)
|
|
|
|
MIPS_SYS(sys_sched_yield , 0)
|
|
|
|
MIPS_SYS(sys_sched_get_priority_max, 1)
|
|
|
|
MIPS_SYS(sys_sched_get_priority_min, 1)
|
|
|
|
MIPS_SYS(sys_sched_rr_get_interval, 2) /* 4165 */
|
|
|
|
MIPS_SYS(sys_nanosleep, 2)
|
|
|
|
MIPS_SYS(sys_mremap , 4)
|
|
|
|
MIPS_SYS(sys_accept , 3)
|
|
|
|
MIPS_SYS(sys_bind , 3)
|
|
|
|
MIPS_SYS(sys_connect , 3) /* 4170 */
|
|
|
|
MIPS_SYS(sys_getpeername , 3)
|
|
|
|
MIPS_SYS(sys_getsockname , 3)
|
|
|
|
MIPS_SYS(sys_getsockopt , 5)
|
|
|
|
MIPS_SYS(sys_listen , 2)
|
|
|
|
MIPS_SYS(sys_recv , 4) /* 4175 */
|
|
|
|
MIPS_SYS(sys_recvfrom , 6)
|
|
|
|
MIPS_SYS(sys_recvmsg , 3)
|
|
|
|
MIPS_SYS(sys_send , 4)
|
|
|
|
MIPS_SYS(sys_sendmsg , 3)
|
|
|
|
MIPS_SYS(sys_sendto , 6) /* 4180 */
|
|
|
|
MIPS_SYS(sys_setsockopt , 5)
|
|
|
|
MIPS_SYS(sys_shutdown , 2)
|
|
|
|
MIPS_SYS(sys_socket , 3)
|
|
|
|
MIPS_SYS(sys_socketpair , 4)
|
|
|
|
MIPS_SYS(sys_setresuid , 3) /* 4185 */
|
|
|
|
MIPS_SYS(sys_getresuid , 3)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* was sys_query_module */
|
|
|
|
MIPS_SYS(sys_poll , 3)
|
|
|
|
MIPS_SYS(sys_nfsservctl , 3)
|
|
|
|
MIPS_SYS(sys_setresgid , 3) /* 4190 */
|
|
|
|
MIPS_SYS(sys_getresgid , 3)
|
|
|
|
MIPS_SYS(sys_prctl , 5)
|
|
|
|
MIPS_SYS(sys_rt_sigreturn, 0)
|
|
|
|
MIPS_SYS(sys_rt_sigaction, 4)
|
|
|
|
MIPS_SYS(sys_rt_sigprocmask, 4) /* 4195 */
|
|
|
|
MIPS_SYS(sys_rt_sigpending, 2)
|
|
|
|
MIPS_SYS(sys_rt_sigtimedwait, 4)
|
|
|
|
MIPS_SYS(sys_rt_sigqueueinfo, 3)
|
|
|
|
MIPS_SYS(sys_rt_sigsuspend, 0)
|
|
|
|
MIPS_SYS(sys_pread64 , 6) /* 4200 */
|
|
|
|
MIPS_SYS(sys_pwrite64 , 6)
|
|
|
|
MIPS_SYS(sys_chown , 3)
|
|
|
|
MIPS_SYS(sys_getcwd , 2)
|
|
|
|
MIPS_SYS(sys_capget , 2)
|
|
|
|
MIPS_SYS(sys_capset , 2) /* 4205 */
|
2011-07-12 13:32:31 +02:00
|
|
|
MIPS_SYS(sys_sigaltstack , 2)
|
2005-11-26 19:47:20 +01:00
|
|
|
MIPS_SYS(sys_sendfile , 4)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0)
|
|
|
|
MIPS_SYS(sys_mmap2 , 6) /* 4210 */
|
|
|
|
MIPS_SYS(sys_truncate64 , 4)
|
|
|
|
MIPS_SYS(sys_ftruncate64 , 4)
|
|
|
|
MIPS_SYS(sys_stat64 , 2)
|
|
|
|
MIPS_SYS(sys_lstat64 , 2)
|
|
|
|
MIPS_SYS(sys_fstat64 , 2) /* 4215 */
|
|
|
|
MIPS_SYS(sys_pivot_root , 2)
|
|
|
|
MIPS_SYS(sys_mincore , 3)
|
|
|
|
MIPS_SYS(sys_madvise , 3)
|
|
|
|
MIPS_SYS(sys_getdents64 , 3)
|
|
|
|
MIPS_SYS(sys_fcntl64 , 3) /* 4220 */
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0)
|
|
|
|
MIPS_SYS(sys_gettid , 0)
|
|
|
|
MIPS_SYS(sys_readahead , 5)
|
|
|
|
MIPS_SYS(sys_setxattr , 5)
|
|
|
|
MIPS_SYS(sys_lsetxattr , 5) /* 4225 */
|
|
|
|
MIPS_SYS(sys_fsetxattr , 5)
|
|
|
|
MIPS_SYS(sys_getxattr , 4)
|
|
|
|
MIPS_SYS(sys_lgetxattr , 4)
|
|
|
|
MIPS_SYS(sys_fgetxattr , 4)
|
|
|
|
MIPS_SYS(sys_listxattr , 3) /* 4230 */
|
|
|
|
MIPS_SYS(sys_llistxattr , 3)
|
|
|
|
MIPS_SYS(sys_flistxattr , 3)
|
|
|
|
MIPS_SYS(sys_removexattr , 2)
|
|
|
|
MIPS_SYS(sys_lremovexattr, 2)
|
|
|
|
MIPS_SYS(sys_fremovexattr, 2) /* 4235 */
|
|
|
|
MIPS_SYS(sys_tkill , 2)
|
|
|
|
MIPS_SYS(sys_sendfile64 , 5)
|
|
|
|
MIPS_SYS(sys_futex , 2)
|
|
|
|
MIPS_SYS(sys_sched_setaffinity, 3)
|
|
|
|
MIPS_SYS(sys_sched_getaffinity, 3) /* 4240 */
|
|
|
|
MIPS_SYS(sys_io_setup , 2)
|
|
|
|
MIPS_SYS(sys_io_destroy , 1)
|
|
|
|
MIPS_SYS(sys_io_getevents, 5)
|
|
|
|
MIPS_SYS(sys_io_submit , 3)
|
|
|
|
MIPS_SYS(sys_io_cancel , 3) /* 4245 */
|
|
|
|
MIPS_SYS(sys_exit_group , 1)
|
|
|
|
MIPS_SYS(sys_lookup_dcookie, 3)
|
|
|
|
MIPS_SYS(sys_epoll_create, 1)
|
|
|
|
MIPS_SYS(sys_epoll_ctl , 4)
|
|
|
|
MIPS_SYS(sys_epoll_wait , 3) /* 4250 */
|
|
|
|
MIPS_SYS(sys_remap_file_pages, 5)
|
|
|
|
MIPS_SYS(sys_set_tid_address, 1)
|
|
|
|
MIPS_SYS(sys_restart_syscall, 0)
|
|
|
|
MIPS_SYS(sys_fadvise64_64, 7)
|
|
|
|
MIPS_SYS(sys_statfs64 , 3) /* 4255 */
|
|
|
|
MIPS_SYS(sys_fstatfs64 , 2)
|
|
|
|
MIPS_SYS(sys_timer_create, 3)
|
|
|
|
MIPS_SYS(sys_timer_settime, 4)
|
|
|
|
MIPS_SYS(sys_timer_gettime, 2)
|
|
|
|
MIPS_SYS(sys_timer_getoverrun, 1) /* 4260 */
|
|
|
|
MIPS_SYS(sys_timer_delete, 1)
|
|
|
|
MIPS_SYS(sys_clock_settime, 2)
|
|
|
|
MIPS_SYS(sys_clock_gettime, 2)
|
|
|
|
MIPS_SYS(sys_clock_getres, 2)
|
|
|
|
MIPS_SYS(sys_clock_nanosleep, 4) /* 4265 */
|
|
|
|
MIPS_SYS(sys_tgkill , 3)
|
|
|
|
MIPS_SYS(sys_utimes , 2)
|
|
|
|
MIPS_SYS(sys_mbind , 4)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* sys_get_mempolicy */
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* 4270 sys_set_mempolicy */
|
|
|
|
MIPS_SYS(sys_mq_open , 4)
|
|
|
|
MIPS_SYS(sys_mq_unlink , 1)
|
|
|
|
MIPS_SYS(sys_mq_timedsend, 5)
|
|
|
|
MIPS_SYS(sys_mq_timedreceive, 5)
|
|
|
|
MIPS_SYS(sys_mq_notify , 2) /* 4275 */
|
|
|
|
MIPS_SYS(sys_mq_getsetattr, 3)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* sys_vserver */
|
|
|
|
MIPS_SYS(sys_waitid , 4)
|
|
|
|
MIPS_SYS(sys_ni_syscall , 0) /* available, was setaltroot */
|
|
|
|
MIPS_SYS(sys_add_key , 5)
|
2007-05-13 15:58:00 +02:00
|
|
|
MIPS_SYS(sys_request_key, 4)
|
2005-11-26 19:47:20 +01:00
|
|
|
MIPS_SYS(sys_keyctl , 5)
|
2007-03-02 21:48:00 +01:00
|
|
|
MIPS_SYS(sys_set_thread_area, 1)
|
2007-05-13 15:58:00 +02:00
|
|
|
MIPS_SYS(sys_inotify_init, 0)
|
|
|
|
MIPS_SYS(sys_inotify_add_watch, 3) /* 4285 */
|
|
|
|
MIPS_SYS(sys_inotify_rm_watch, 2)
|
|
|
|
MIPS_SYS(sys_migrate_pages, 4)
|
|
|
|
MIPS_SYS(sys_openat, 4)
|
|
|
|
MIPS_SYS(sys_mkdirat, 3)
|
|
|
|
MIPS_SYS(sys_mknodat, 4) /* 4290 */
|
|
|
|
MIPS_SYS(sys_fchownat, 5)
|
|
|
|
MIPS_SYS(sys_futimesat, 3)
|
|
|
|
MIPS_SYS(sys_fstatat64, 4)
|
|
|
|
MIPS_SYS(sys_unlinkat, 3)
|
|
|
|
MIPS_SYS(sys_renameat, 4) /* 4295 */
|
|
|
|
MIPS_SYS(sys_linkat, 5)
|
|
|
|
MIPS_SYS(sys_symlinkat, 3)
|
|
|
|
MIPS_SYS(sys_readlinkat, 4)
|
|
|
|
MIPS_SYS(sys_fchmodat, 3)
|
|
|
|
MIPS_SYS(sys_faccessat, 3) /* 4300 */
|
|
|
|
MIPS_SYS(sys_pselect6, 6)
|
|
|
|
MIPS_SYS(sys_ppoll, 5)
|
|
|
|
MIPS_SYS(sys_unshare, 1)
|
|
|
|
MIPS_SYS(sys_splice, 4)
|
|
|
|
MIPS_SYS(sys_sync_file_range, 7) /* 4305 */
|
|
|
|
MIPS_SYS(sys_tee, 4)
|
|
|
|
MIPS_SYS(sys_vmsplice, 4)
|
|
|
|
MIPS_SYS(sys_move_pages, 6)
|
|
|
|
MIPS_SYS(sys_set_robust_list, 2)
|
|
|
|
MIPS_SYS(sys_get_robust_list, 3) /* 4310 */
|
|
|
|
MIPS_SYS(sys_kexec_load, 4)
|
|
|
|
MIPS_SYS(sys_getcpu, 3)
|
|
|
|
MIPS_SYS(sys_epoll_pwait, 6)
|
|
|
|
MIPS_SYS(sys_ioprio_set, 3)
|
|
|
|
MIPS_SYS(sys_ioprio_get, 2)
|
2011-06-27 18:44:51 +02:00
|
|
|
MIPS_SYS(sys_utimensat, 4)
|
|
|
|
MIPS_SYS(sys_signalfd, 3)
|
|
|
|
MIPS_SYS(sys_ni_syscall, 0) /* was timerfd */
|
|
|
|
MIPS_SYS(sys_eventfd, 1)
|
|
|
|
MIPS_SYS(sys_fallocate, 6) /* 4320 */
|
|
|
|
MIPS_SYS(sys_timerfd_create, 2)
|
|
|
|
MIPS_SYS(sys_timerfd_gettime, 2)
|
|
|
|
MIPS_SYS(sys_timerfd_settime, 4)
|
|
|
|
MIPS_SYS(sys_signalfd4, 4)
|
|
|
|
MIPS_SYS(sys_eventfd2, 2) /* 4325 */
|
|
|
|
MIPS_SYS(sys_epoll_create1, 1)
|
|
|
|
MIPS_SYS(sys_dup3, 3)
|
|
|
|
MIPS_SYS(sys_pipe2, 2)
|
|
|
|
MIPS_SYS(sys_inotify_init1, 1)
|
|
|
|
MIPS_SYS(sys_preadv, 6) /* 4330 */
|
|
|
|
MIPS_SYS(sys_pwritev, 6)
|
|
|
|
MIPS_SYS(sys_rt_tgsigqueueinfo, 4)
|
|
|
|
MIPS_SYS(sys_perf_event_open, 5)
|
|
|
|
MIPS_SYS(sys_accept4, 4)
|
|
|
|
MIPS_SYS(sys_recvmmsg, 5) /* 4335 */
|
|
|
|
MIPS_SYS(sys_fanotify_init, 2)
|
|
|
|
MIPS_SYS(sys_fanotify_mark, 6)
|
|
|
|
MIPS_SYS(sys_prlimit64, 4)
|
|
|
|
MIPS_SYS(sys_name_to_handle_at, 5)
|
|
|
|
MIPS_SYS(sys_open_by_handle_at, 3) /* 4340 */
|
|
|
|
MIPS_SYS(sys_clock_adjtime, 2)
|
|
|
|
MIPS_SYS(sys_syncfs, 1)
|
2005-11-26 19:47:20 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#undef MIPS_SYS
|
|
|
|
|
2009-07-09 18:45:17 +02:00
|
|
|
static int do_store_exclusive(CPUMIPSState *env)
|
|
|
|
{
|
|
|
|
target_ulong addr;
|
|
|
|
target_ulong page_addr;
|
|
|
|
target_ulong val;
|
|
|
|
int flags;
|
|
|
|
int segv = 0;
|
|
|
|
int reg;
|
|
|
|
int d;
|
|
|
|
|
2009-11-22 13:08:14 +01:00
|
|
|
addr = env->lladdr;
|
2009-07-09 18:45:17 +02:00
|
|
|
page_addr = addr & TARGET_PAGE_MASK;
|
|
|
|
start_exclusive();
|
|
|
|
mmap_lock();
|
|
|
|
flags = page_get_flags(page_addr);
|
|
|
|
if ((flags & PAGE_READ) == 0) {
|
|
|
|
segv = 1;
|
|
|
|
} else {
|
|
|
|
reg = env->llreg & 0x1f;
|
|
|
|
d = (env->llreg & 0x20) != 0;
|
|
|
|
if (d) {
|
|
|
|
segv = get_user_s64(val, addr);
|
|
|
|
} else {
|
|
|
|
segv = get_user_s32(val, addr);
|
|
|
|
}
|
|
|
|
if (!segv) {
|
|
|
|
if (val != env->llval) {
|
|
|
|
env->active_tc.gpr[reg] = 0;
|
|
|
|
} else {
|
|
|
|
if (d) {
|
|
|
|
segv = put_user_u64(env->llnewval, addr);
|
|
|
|
} else {
|
|
|
|
segv = put_user_u32(env->llnewval, addr);
|
|
|
|
}
|
|
|
|
if (!segv) {
|
|
|
|
env->active_tc.gpr[reg] = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-11-22 13:08:14 +01:00
|
|
|
env->lladdr = -1;
|
2009-07-09 18:45:17 +02:00
|
|
|
if (!segv) {
|
|
|
|
env->active_tc.PC += 4;
|
|
|
|
}
|
|
|
|
mmap_unlock();
|
|
|
|
end_exclusive();
|
|
|
|
return segv;
|
|
|
|
}
|
|
|
|
|
2005-11-26 19:47:20 +01:00
|
|
|
void cpu_loop(CPUMIPSState *env)
|
|
|
|
{
|
2009-10-01 23:12:16 +02:00
|
|
|
target_siginfo_t info;
|
2007-05-13 15:58:00 +02:00
|
|
|
int trapnr, ret;
|
2005-11-26 19:47:20 +01:00
|
|
|
unsigned int syscall_num;
|
|
|
|
|
|
|
|
for(;;) {
|
2009-07-09 18:45:17 +02:00
|
|
|
cpu_exec_start(env);
|
2005-11-26 19:47:20 +01:00
|
|
|
trapnr = cpu_mips_exec(env);
|
2009-07-09 18:45:17 +02:00
|
|
|
cpu_exec_end(env);
|
2005-11-26 19:47:20 +01:00
|
|
|
switch(trapnr) {
|
|
|
|
case EXCP_SYSCALL:
|
2008-06-27 12:02:35 +02:00
|
|
|
syscall_num = env->active_tc.gpr[2] - 4000;
|
|
|
|
env->active_tc.PC += 4;
|
2007-05-13 15:58:00 +02:00
|
|
|
if (syscall_num >= sizeof(mips_syscall_args)) {
|
2011-07-12 13:33:23 +02:00
|
|
|
ret = -TARGET_ENOSYS;
|
2007-05-13 15:58:00 +02:00
|
|
|
} else {
|
|
|
|
int nb_args;
|
2007-10-14 18:27:31 +02:00
|
|
|
abi_ulong sp_reg;
|
|
|
|
abi_ulong arg5 = 0, arg6 = 0, arg7 = 0, arg8 = 0;
|
2007-05-13 15:58:00 +02:00
|
|
|
|
|
|
|
nb_args = mips_syscall_args[syscall_num];
|
2008-06-27 12:02:35 +02:00
|
|
|
sp_reg = env->active_tc.gpr[29];
|
2007-05-13 15:58:00 +02:00
|
|
|
switch (nb_args) {
|
|
|
|
/* these arguments are taken from the stack */
|
2007-11-16 11:46:05 +01:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
|
|
|
case 8: get_user_ual(arg8, sp_reg + 28);
|
|
|
|
case 7: get_user_ual(arg7, sp_reg + 24);
|
|
|
|
case 6: get_user_ual(arg6, sp_reg + 20);
|
|
|
|
case 5: get_user_ual(arg5, sp_reg + 16);
|
2007-05-13 15:58:00 +02:00
|
|
|
default:
|
|
|
|
break;
|
2005-11-26 19:47:20 +01:00
|
|
|
}
|
2008-06-27 12:02:35 +02:00
|
|
|
ret = do_syscall(env, env->active_tc.gpr[2],
|
|
|
|
env->active_tc.gpr[4],
|
|
|
|
env->active_tc.gpr[5],
|
|
|
|
env->active_tc.gpr[6],
|
|
|
|
env->active_tc.gpr[7],
|
2011-06-16 18:37:13 +02:00
|
|
|
arg5, arg6, arg7, arg8);
|
2007-05-13 15:58:00 +02:00
|
|
|
}
|
2009-04-21 03:41:10 +02:00
|
|
|
if (ret == -TARGET_QEMU_ESIGRETURN) {
|
|
|
|
/* Returning from a successful sigreturn syscall.
|
|
|
|
Avoid clobbering register state. */
|
|
|
|
break;
|
|
|
|
}
|
2007-05-13 15:58:00 +02:00
|
|
|
if ((unsigned int)ret >= (unsigned int)(-1133)) {
|
2008-06-27 12:02:35 +02:00
|
|
|
env->active_tc.gpr[7] = 1; /* error flag */
|
2007-05-13 15:58:00 +02:00
|
|
|
ret = -ret;
|
|
|
|
} else {
|
2008-06-27 12:02:35 +02:00
|
|
|
env->active_tc.gpr[7] = 0; /* error flag */
|
2005-11-26 19:47:20 +01:00
|
|
|
}
|
2008-06-27 12:02:35 +02:00
|
|
|
env->active_tc.gpr[2] = ret;
|
2005-11-26 19:47:20 +01:00
|
|
|
break;
|
2006-12-10 23:08:10 +01:00
|
|
|
case EXCP_TLBL:
|
|
|
|
case EXCP_TLBS:
|
2011-07-12 13:34:23 +02:00
|
|
|
case EXCP_AdEL:
|
|
|
|
case EXCP_AdES:
|
2009-04-21 03:03:10 +02:00
|
|
|
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->CP0_BadVAddr;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
2005-12-05 22:04:24 +01:00
|
|
|
case EXCP_CpU:
|
2005-11-26 19:47:20 +01:00
|
|
|
case EXCP_RI:
|
2006-06-14 15:37:55 +02:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = 0;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-11-26 19:47:20 +01:00
|
|
|
break;
|
2006-06-27 23:08:10 +02:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2006-11-04 17:46:29 +01:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig (env, TARGET_SIGTRAP);
|
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2006-11-04 17:46:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2009-07-09 18:45:17 +02:00
|
|
|
case EXCP_SC:
|
|
|
|
if (do_store_exclusive(env)) {
|
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
info._sifields._sigfault._addr = env->active_tc.PC;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
break;
|
2005-11-26 19:47:20 +01:00
|
|
|
default:
|
|
|
|
// error:
|
2007-09-16 23:08:06 +02:00
|
|
|
fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
|
2005-11-26 19:47:20 +01:00
|
|
|
trapnr);
|
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
process_pending_signals(env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-04-27 23:07:38 +02:00
|
|
|
#ifdef TARGET_SH4
|
|
|
|
void cpu_loop (CPUState *env)
|
|
|
|
{
|
|
|
|
int trapnr, ret;
|
2009-10-01 23:12:16 +02:00
|
|
|
target_siginfo_t info;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2006-04-27 23:07:38 +02:00
|
|
|
while (1) {
|
|
|
|
trapnr = cpu_sh4_exec (env);
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2006-04-27 23:07:38 +02:00
|
|
|
switch (trapnr) {
|
|
|
|
case 0x160:
|
2008-09-15 09:43:43 +02:00
|
|
|
env->pc += 2;
|
2007-09-16 23:08:06 +02:00
|
|
|
ret = do_syscall(env,
|
|
|
|
env->gregs[3],
|
|
|
|
env->gregs[4],
|
|
|
|
env->gregs[5],
|
|
|
|
env->gregs[6],
|
|
|
|
env->gregs[7],
|
|
|
|
env->gregs[0],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->gregs[1],
|
|
|
|
0, 0);
|
2006-06-18 21:12:54 +02:00
|
|
|
env->gregs[0] = ret;
|
2006-04-27 23:07:38 +02:00
|
|
|
break;
|
2007-12-02 07:31:25 +01:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2006-06-17 21:58:25 +02:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig (env, TARGET_SIGTRAP);
|
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2006-06-17 21:58:25 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2007-12-02 07:31:25 +01:00
|
|
|
case 0xa0:
|
|
|
|
case 0xc0:
|
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
info._sifields._sigfault._addr = env->tea;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-12-02 07:31:25 +01:00
|
|
|
break;
|
|
|
|
|
2006-04-27 23:07:38 +02:00
|
|
|
default:
|
|
|
|
printf ("Unhandled trap: 0x%x\n", trapnr);
|
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-10-08 15:36:46 +02:00
|
|
|
#ifdef TARGET_CRIS
|
|
|
|
void cpu_loop (CPUState *env)
|
|
|
|
{
|
|
|
|
int trapnr, ret;
|
2009-10-01 23:12:16 +02:00
|
|
|
target_siginfo_t info;
|
2007-10-08 15:36:46 +02:00
|
|
|
|
|
|
|
while (1) {
|
|
|
|
trapnr = cpu_cris_exec (env);
|
|
|
|
switch (trapnr) {
|
|
|
|
case 0xaa:
|
|
|
|
{
|
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
2008-05-27 23:12:09 +02:00
|
|
|
info._sifields._sigfault._addr = env->pregs[PR_EDA];
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-10-08 15:36:46 +02:00
|
|
|
}
|
|
|
|
break;
|
2008-02-28 12:29:27 +01:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2007-10-08 15:36:46 +02:00
|
|
|
case EXCP_BREAK:
|
|
|
|
ret = do_syscall(env,
|
|
|
|
env->regs[9],
|
|
|
|
env->regs[10],
|
|
|
|
env->regs[11],
|
|
|
|
env->regs[12],
|
|
|
|
env->regs[13],
|
|
|
|
env->pregs[7],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->pregs[11],
|
|
|
|
0, 0);
|
2007-10-08 15:36:46 +02:00
|
|
|
env->regs[10] = ret;
|
|
|
|
break;
|
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig (env, TARGET_SIGTRAP);
|
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-10-08 15:36:46 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf ("Unhandled trap: 0x%x\n", trapnr);
|
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-05-20 21:31:33 +02:00
|
|
|
#ifdef TARGET_MICROBLAZE
|
|
|
|
void cpu_loop (CPUState *env)
|
|
|
|
{
|
|
|
|
int trapnr, ret;
|
2009-10-01 23:12:16 +02:00
|
|
|
target_siginfo_t info;
|
2009-05-20 21:31:33 +02:00
|
|
|
|
|
|
|
while (1) {
|
|
|
|
trapnr = cpu_mb_exec (env);
|
|
|
|
switch (trapnr) {
|
|
|
|
case 0xaa:
|
|
|
|
{
|
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
info._sifields._sigfault._addr = 0;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
|
|
|
case EXCP_BREAK:
|
|
|
|
/* Return address is 4 bytes after the call. */
|
|
|
|
env->regs[14] += 4;
|
|
|
|
ret = do_syscall(env,
|
|
|
|
env->regs[12],
|
|
|
|
env->regs[5],
|
|
|
|
env->regs[6],
|
|
|
|
env->regs[7],
|
|
|
|
env->regs[8],
|
|
|
|
env->regs[9],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->regs[10],
|
|
|
|
0, 0);
|
2009-05-20 21:31:33 +02:00
|
|
|
env->regs[3] = ret;
|
|
|
|
env->sregs[SR_PC] = env->regs[14];
|
|
|
|
break;
|
2010-09-09 10:24:01 +02:00
|
|
|
case EXCP_HW_EXCP:
|
|
|
|
env->regs[17] = env->sregs[SR_PC] + 4;
|
|
|
|
if (env->iflags & D_FLAG) {
|
|
|
|
env->sregs[SR_ESR] |= 1 << 12;
|
|
|
|
env->sregs[SR_PC] -= 4;
|
|
|
|
/* FIXME: if branch was immed, replay the imm aswell. */
|
|
|
|
}
|
|
|
|
|
|
|
|
env->iflags &= ~(IMM_FLAG | D_FLAG);
|
|
|
|
|
|
|
|
switch (env->sregs[SR_ESR] & 31) {
|
|
|
|
case ESR_EC_FPU:
|
|
|
|
info.si_signo = SIGFPE;
|
|
|
|
info.si_errno = 0;
|
|
|
|
if (env->sregs[SR_FSR] & FSR_IO) {
|
|
|
|
info.si_code = TARGET_FPE_FLTINV;
|
|
|
|
}
|
|
|
|
if (env->sregs[SR_FSR] & FSR_DZ) {
|
|
|
|
info.si_code = TARGET_FPE_FLTDIV;
|
|
|
|
}
|
|
|
|
info._sifields._sigfault._addr = 0;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf ("Unhandled hw-exception: 0x%x\n",
|
2011-04-11 23:57:07 +02:00
|
|
|
env->sregs[SR_ESR] & ESR_EC_MASK);
|
2010-09-09 10:24:01 +02:00
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
|
|
|
exit (1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2009-05-20 21:31:33 +02:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig (env, TARGET_SIGTRAP);
|
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf ("Unhandled trap: 0x%x\n", trapnr);
|
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-10-22 02:18:54 +02:00
|
|
|
#ifdef TARGET_M68K
|
|
|
|
|
|
|
|
void cpu_loop(CPUM68KState *env)
|
|
|
|
{
|
|
|
|
int trapnr;
|
|
|
|
unsigned int n;
|
2009-10-01 23:12:16 +02:00
|
|
|
target_siginfo_t info;
|
2006-10-22 02:18:54 +02:00
|
|
|
TaskState *ts = env->opaque;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2006-10-22 02:18:54 +02:00
|
|
|
for(;;) {
|
|
|
|
trapnr = cpu_m68k_exec(env);
|
|
|
|
switch(trapnr) {
|
|
|
|
case EXCP_ILLEGAL:
|
|
|
|
{
|
|
|
|
if (ts->sim_syscalls) {
|
|
|
|
uint16_t nr;
|
|
|
|
nr = lduw(env->pc + 2);
|
|
|
|
env->pc += 4;
|
|
|
|
do_m68k_simcall(env, nr);
|
|
|
|
} else {
|
|
|
|
goto do_sigill;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2007-05-26 17:09:38 +02:00
|
|
|
case EXCP_HALT_INSN:
|
2006-10-22 02:18:54 +02:00
|
|
|
/* Semihosing syscall. */
|
2007-05-26 17:09:38 +02:00
|
|
|
env->pc += 4;
|
2006-10-22 02:18:54 +02:00
|
|
|
do_m68k_semihosting(env, env->dregs[0]);
|
|
|
|
break;
|
|
|
|
case EXCP_LINEA:
|
|
|
|
case EXCP_LINEF:
|
|
|
|
case EXCP_UNSUPPORTED:
|
|
|
|
do_sigill:
|
|
|
|
info.si_signo = SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLOPN;
|
|
|
|
info._sifields._sigfault._addr = env->pc;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2006-10-22 02:18:54 +02:00
|
|
|
break;
|
|
|
|
case EXCP_TRAP0:
|
|
|
|
{
|
|
|
|
ts->sim_syscalls = 0;
|
|
|
|
n = env->dregs[0];
|
|
|
|
env->pc += 2;
|
2007-09-16 23:08:06 +02:00
|
|
|
env->dregs[0] = do_syscall(env,
|
|
|
|
n,
|
2006-10-22 02:18:54 +02:00
|
|
|
env->dregs[1],
|
|
|
|
env->dregs[2],
|
|
|
|
env->dregs[3],
|
|
|
|
env->dregs[4],
|
|
|
|
env->dregs[5],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->aregs[0],
|
|
|
|
0, 0);
|
2006-10-22 02:18:54 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
|
|
|
case EXCP_ACCESS:
|
|
|
|
{
|
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
info._sifields._sigfault._addr = env->mmu.ar;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2006-10-22 02:18:54 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig (env, TARGET_SIGTRAP);
|
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 18:11:38 +02:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2006-10-22 02:18:54 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2007-09-16 23:08:06 +02:00
|
|
|
fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
|
2006-10-22 02:18:54 +02:00
|
|
|
trapnr);
|
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
process_pending_signals(env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* TARGET_M68K */
|
|
|
|
|
2007-04-05 09:13:51 +02:00
|
|
|
#ifdef TARGET_ALPHA
|
2010-04-08 00:42:26 +02:00
|
|
|
static void do_store_exclusive(CPUAlphaState *env, int reg, int quad)
|
|
|
|
{
|
|
|
|
target_ulong addr, val, tmp;
|
|
|
|
target_siginfo_t info;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
addr = env->lock_addr;
|
|
|
|
tmp = env->lock_st_addr;
|
|
|
|
env->lock_addr = -1;
|
|
|
|
env->lock_st_addr = 0;
|
|
|
|
|
|
|
|
start_exclusive();
|
|
|
|
mmap_lock();
|
|
|
|
|
|
|
|
if (addr == tmp) {
|
|
|
|
if (quad ? get_user_s64(val, addr) : get_user_s32(val, addr)) {
|
|
|
|
goto do_sigsegv;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (val == env->lock_value) {
|
|
|
|
tmp = env->ir[reg];
|
|
|
|
if (quad ? put_user_u64(tmp, addr) : put_user_u32(tmp, addr)) {
|
|
|
|
goto do_sigsegv;
|
|
|
|
}
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
env->ir[reg] = ret;
|
|
|
|
env->pc += 4;
|
|
|
|
|
|
|
|
mmap_unlock();
|
|
|
|
end_exclusive();
|
|
|
|
return;
|
|
|
|
|
|
|
|
do_sigsegv:
|
|
|
|
mmap_unlock();
|
|
|
|
end_exclusive();
|
|
|
|
|
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
info._sifields._sigfault._addr = addr;
|
|
|
|
queue_signal(env, TARGET_SIGSEGV, &info);
|
|
|
|
}
|
|
|
|
|
2007-04-05 09:13:51 +02:00
|
|
|
void cpu_loop (CPUState *env)
|
|
|
|
{
|
2007-04-14 14:17:09 +02:00
|
|
|
int trapnr;
|
2009-10-01 23:12:16 +02:00
|
|
|
target_siginfo_t info;
|
2009-12-28 03:30:03 +01:00
|
|
|
abi_long sysret;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2007-04-05 09:13:51 +02:00
|
|
|
while (1) {
|
|
|
|
trapnr = cpu_alpha_exec (env);
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2010-04-13 01:14:54 +02:00
|
|
|
/* All of the traps imply a transition through PALcode, which
|
|
|
|
implies an REI instruction has been executed. Which means
|
|
|
|
that the intr_flag should be cleared. */
|
|
|
|
env->intr_flag = 0;
|
|
|
|
|
2007-04-05 09:13:51 +02:00
|
|
|
switch (trapnr) {
|
|
|
|
case EXCP_RESET:
|
|
|
|
fprintf(stderr, "Reset requested. Exit\n");
|
|
|
|
exit(1);
|
|
|
|
break;
|
|
|
|
case EXCP_MCHK:
|
|
|
|
fprintf(stderr, "Machine check exception. Exit\n");
|
|
|
|
exit(1);
|
|
|
|
break;
|
2011-05-20 23:04:57 +02:00
|
|
|
case EXCP_SMP_INTERRUPT:
|
|
|
|
case EXCP_CLK_INTERRUPT:
|
|
|
|
case EXCP_DEV_INTERRUPT:
|
2007-09-16 23:08:06 +02:00
|
|
|
fprintf(stderr, "External interrupt. Exit\n");
|
2007-04-05 09:13:51 +02:00
|
|
|
exit(1);
|
|
|
|
break;
|
2011-05-20 23:04:57 +02:00
|
|
|
case EXCP_MMFAULT:
|
2010-04-08 00:42:26 +02:00
|
|
|
env->lock_addr = -1;
|
2009-12-28 03:30:03 +01:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
2011-05-20 22:30:00 +02:00
|
|
|
info.si_code = (page_get_flags(env->trap_arg0) & PAGE_VALID
|
2010-05-21 19:03:33 +02:00
|
|
|
? TARGET_SEGV_ACCERR : TARGET_SEGV_MAPERR);
|
2011-05-20 22:30:00 +02:00
|
|
|
info._sifields._sigfault._addr = env->trap_arg0;
|
2009-12-28 03:30:03 +01:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-04-05 09:13:51 +02:00
|
|
|
break;
|
|
|
|
case EXCP_UNALIGN:
|
2010-04-08 00:42:26 +02:00
|
|
|
env->lock_addr = -1;
|
2009-12-28 03:30:03 +01:00
|
|
|
info.si_signo = TARGET_SIGBUS;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_BUS_ADRALN;
|
2011-05-20 22:30:00 +02:00
|
|
|
info._sifields._sigfault._addr = env->trap_arg0;
|
2009-12-28 03:30:03 +01:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-04-05 09:13:51 +02:00
|
|
|
break;
|
|
|
|
case EXCP_OPCDEC:
|
2009-12-28 03:30:03 +01:00
|
|
|
do_sigill:
|
2010-04-08 00:42:26 +02:00
|
|
|
env->lock_addr = -1;
|
2009-12-28 03:30:03 +01:00
|
|
|
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, &info);
|
2007-04-05 09:13:51 +02:00
|
|
|
break;
|
2011-05-20 23:04:57 +02:00
|
|
|
case EXCP_ARITH:
|
|
|
|
env->lock_addr = -1;
|
|
|
|
info.si_signo = TARGET_SIGFPE;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_FPE_FLTINV;
|
|
|
|
info._sifields._sigfault._addr = env->pc;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
2007-04-05 09:13:51 +02:00
|
|
|
case EXCP_FEN:
|
2009-12-28 03:30:03 +01:00
|
|
|
/* No-op. Linux simply re-enables the FPU. */
|
2007-04-05 09:13:51 +02:00
|
|
|
break;
|
2011-05-20 23:04:57 +02:00
|
|
|
case EXCP_CALL_PAL:
|
2010-04-08 00:42:26 +02:00
|
|
|
env->lock_addr = -1;
|
2011-05-20 23:04:57 +02:00
|
|
|
switch (env->error_code) {
|
2009-12-28 03:30:03 +01:00
|
|
|
case 0x80:
|
|
|
|
/* BPT */
|
|
|
|
info.si_signo = TARGET_SIGTRAP;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
|
|
|
info._sifields._sigfault._addr = env->pc;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
|
|
|
case 0x81:
|
|
|
|
/* BUGCHK */
|
|
|
|
info.si_signo = TARGET_SIGTRAP;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = 0;
|
|
|
|
info._sifields._sigfault._addr = env->pc;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
|
|
|
case 0x83:
|
|
|
|
/* CALLSYS */
|
|
|
|
trapnr = env->ir[IR_V0];
|
|
|
|
sysret = do_syscall(env, trapnr,
|
|
|
|
env->ir[IR_A0], env->ir[IR_A1],
|
|
|
|
env->ir[IR_A2], env->ir[IR_A3],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->ir[IR_A4], env->ir[IR_A5],
|
|
|
|
0, 0);
|
2010-05-03 19:07:55 +02:00
|
|
|
if (trapnr == TARGET_NR_sigreturn
|
|
|
|
|| trapnr == TARGET_NR_rt_sigreturn) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Syscall writes 0 to V0 to bypass error check, similar
|
|
|
|
to how this is handled internal to Linux kernel. */
|
|
|
|
if (env->ir[IR_V0] == 0) {
|
|
|
|
env->ir[IR_V0] = sysret;
|
|
|
|
} else {
|
2009-12-28 03:30:03 +01:00
|
|
|
env->ir[IR_V0] = (sysret < 0 ? -sysret : sysret);
|
|
|
|
env->ir[IR_A3] = (sysret < 0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 0x86:
|
|
|
|
/* IMB */
|
|
|
|
/* ??? We can probably elide the code using page_unprotect
|
|
|
|
that is checking for self-modifying code. Instead we
|
|
|
|
could simply call tb_flush here. Until we work out the
|
|
|
|
changes required to turn off the extra write protection,
|
|
|
|
this can be a no-op. */
|
|
|
|
break;
|
|
|
|
case 0x9E:
|
|
|
|
/* RDUNIQUE */
|
|
|
|
/* Handled in the translator for usermode. */
|
|
|
|
abort();
|
|
|
|
case 0x9F:
|
|
|
|
/* WRUNIQUE */
|
|
|
|
/* Handled in the translator for usermode. */
|
|
|
|
abort();
|
|
|
|
case 0xAA:
|
|
|
|
/* GENTRAP */
|
|
|
|
info.si_signo = TARGET_SIGFPE;
|
|
|
|
switch (env->ir[IR_A0]) {
|
|
|
|
case TARGET_GEN_INTOVF:
|
|
|
|
info.si_code = TARGET_FPE_INTOVF;
|
|
|
|
break;
|
|
|
|
case TARGET_GEN_INTDIV:
|
|
|
|
info.si_code = TARGET_FPE_INTDIV;
|
|
|
|
break;
|
|
|
|
case TARGET_GEN_FLTOVF:
|
|
|
|
info.si_code = TARGET_FPE_FLTOVF;
|
|
|
|
break;
|
|
|
|
case TARGET_GEN_FLTUND:
|
|
|
|
info.si_code = TARGET_FPE_FLTUND;
|
|
|
|
break;
|
|
|
|
case TARGET_GEN_FLTINV:
|
|
|
|
info.si_code = TARGET_FPE_FLTINV;
|
|
|
|
break;
|
|
|
|
case TARGET_GEN_FLTINE:
|
|
|
|
info.si_code = TARGET_FPE_FLTRES;
|
|
|
|
break;
|
|
|
|
case TARGET_GEN_ROPRAND:
|
|
|
|
info.si_code = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
info.si_signo = TARGET_SIGTRAP;
|
|
|
|
info.si_code = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
info.si_errno = 0;
|
|
|
|
info._sifields._sigfault._addr = env->pc;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto do_sigill;
|
|
|
|
}
|
2007-04-05 09:13:51 +02:00
|
|
|
break;
|
|
|
|
case EXCP_DEBUG:
|
2009-12-28 03:30:03 +01:00
|
|
|
info.si_signo = gdb_handlesig (env, TARGET_SIGTRAP);
|
|
|
|
if (info.si_signo) {
|
2010-04-08 00:42:26 +02:00
|
|
|
env->lock_addr = -1;
|
2009-12-28 03:30:03 +01:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-04-05 09:13:51 +02:00
|
|
|
}
|
|
|
|
break;
|
2010-04-08 00:42:26 +02:00
|
|
|
case EXCP_STL_C:
|
|
|
|
case EXCP_STQ_C:
|
|
|
|
do_store_exclusive(env, env->error_code, trapnr - EXCP_STL_C);
|
|
|
|
break;
|
2007-04-05 09:13:51 +02:00
|
|
|
default:
|
|
|
|
printf ("Unhandled trap: 0x%x\n", trapnr);
|
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* TARGET_ALPHA */
|
|
|
|
|
2009-07-24 16:57:31 +02:00
|
|
|
#ifdef TARGET_S390X
|
|
|
|
void cpu_loop(CPUS390XState *env)
|
|
|
|
{
|
|
|
|
int trapnr;
|
|
|
|
target_siginfo_t info;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
trapnr = cpu_s390x_exec (env);
|
|
|
|
|
|
|
|
switch (trapnr) {
|
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
|
|
|
sig = gdb_handlesig (env, TARGET_SIGTRAP);
|
|
|
|
if (sig) {
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EXCP_SVC:
|
|
|
|
{
|
|
|
|
int n = env->int_svc_code;
|
|
|
|
if (!n) {
|
|
|
|
/* syscalls > 255 */
|
|
|
|
n = env->regs[1];
|
|
|
|
}
|
|
|
|
env->psw.addr += env->int_svc_ilc;
|
|
|
|
env->regs[2] = do_syscall(env, n,
|
|
|
|
env->regs[2],
|
|
|
|
env->regs[3],
|
|
|
|
env->regs[4],
|
|
|
|
env->regs[5],
|
|
|
|
env->regs[6],
|
2011-06-16 18:37:13 +02:00
|
|
|
env->regs[7],
|
|
|
|
0, 0);
|
2009-07-24 16:57:31 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EXCP_ADDR:
|
|
|
|
{
|
|
|
|
info.si_signo = SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
info._sifields._sigfault._addr = env->__excp_addr;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EXCP_SPEC:
|
|
|
|
{
|
|
|
|
fprintf(stderr,"specification exception insn 0x%08x%04x\n", ldl(env->psw.addr), lduw(env->psw.addr + 4));
|
|
|
|
info.si_signo = SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLOPC;
|
|
|
|
info._sifields._sigfault._addr = env->__excp_addr;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf ("Unhandled trap: 0x%x\n", trapnr);
|
|
|
|
cpu_dump_state(env, stderr, fprintf, 0);
|
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* TARGET_S390X */
|
|
|
|
|
2011-01-20 04:28:02 +01:00
|
|
|
static void version(void)
|
|
|
|
{
|
|
|
|
printf("qemu-" TARGET_ARCH " version " QEMU_VERSION QEMU_PKGVERSION
|
|
|
|
", Copyright (c) 2003-2008 Fabrice Bellard\n");
|
|
|
|
}
|
|
|
|
|
2008-08-17 22:26:25 +02:00
|
|
|
static void usage(void)
|
2003-02-18 23:55:36 +01:00
|
|
|
{
|
2011-01-20 04:28:02 +01:00
|
|
|
version();
|
|
|
|
printf("usage: qemu-" TARGET_ARCH " [options] program [arguments...]\n"
|
2003-06-15 22:05:50 +02:00
|
|
|
"Linux CPU emulator (compiled for %s emulation)\n"
|
2003-03-24 22:58:34 +01:00
|
|
|
"\n"
|
2008-01-06 18:21:48 +01:00
|
|
|
"Standard options:\n"
|
2007-06-17 18:38:39 +02:00
|
|
|
"-h print this help\n"
|
2011-01-20 04:28:02 +01:00
|
|
|
"-version display version information and exit\n"
|
2007-06-17 18:38:39 +02:00
|
|
|
"-g port wait gdb connection to port\n"
|
|
|
|
"-L path set the elf interpreter prefix (default=%s)\n"
|
|
|
|
"-s size set the stack size in bytes (default=%ld)\n"
|
|
|
|
"-cpu model select CPU (-cpu ? for list)\n"
|
|
|
|
"-drop-ld-preload drop LD_PRELOAD for target process\n"
|
2009-01-30 20:59:17 +01:00
|
|
|
"-E var=value sets/modifies targets environment variable(s)\n"
|
|
|
|
"-U var unsets targets environment variable(s)\n"
|
2009-04-15 18:11:52 +02:00
|
|
|
"-0 argv0 forces target process argv[0] to be argv0\n"
|
2009-07-17 13:48:08 +02:00
|
|
|
#if defined(CONFIG_USE_GUEST_BASE)
|
|
|
|
"-B address set guest_base address to address\n"
|
2010-05-29 03:27:35 +02:00
|
|
|
"-R size reserve size bytes for guest virtual address space\n"
|
2009-07-17 13:48:08 +02:00
|
|
|
#endif
|
2003-05-13 02:25:15 +02:00
|
|
|
"\n"
|
2008-01-06 18:21:48 +01:00
|
|
|
"Debug options:\n"
|
2004-04-25 20:00:45 +02:00
|
|
|
"-d options activate log (logfile=%s)\n"
|
2007-11-11 15:46:06 +01:00
|
|
|
"-p pagesize set the host page size to 'pagesize'\n"
|
2009-04-05 22:08:59 +02:00
|
|
|
"-singlestep always run in singlestep mode\n"
|
2007-12-16 14:05:59 +01:00
|
|
|
"-strace log system calls\n"
|
|
|
|
"\n"
|
2008-01-06 18:21:48 +01:00
|
|
|
"Environment variables:\n"
|
2007-12-16 14:05:59 +01:00
|
|
|
"QEMU_STRACE Print system calls and arguments similar to the\n"
|
|
|
|
" 'strace' program. Enable by setting to any value.\n"
|
2009-01-30 20:59:17 +01:00
|
|
|
"You can use -E and -U options to set/unset environment variables\n"
|
|
|
|
"for target process. It is possible to provide several variables\n"
|
|
|
|
"by repeating the option. For example:\n"
|
|
|
|
" -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n"
|
|
|
|
"Note that if you provide several changes to single variable\n"
|
|
|
|
"last change will stay in effect.\n"
|
2007-12-16 14:05:59 +01:00
|
|
|
,
|
2003-06-15 22:05:50 +02:00
|
|
|
TARGET_ARCH,
|
2007-09-16 23:08:06 +02:00
|
|
|
interp_prefix,
|
2010-03-19 22:21:13 +01:00
|
|
|
guest_stack_size,
|
2003-05-13 02:25:15 +02:00
|
|
|
DEBUG_LOGFILE);
|
2009-02-28 21:14:00 +01:00
|
|
|
exit(1);
|
2003-02-18 23:55:36 +01:00
|
|
|
}
|
|
|
|
|
2008-06-07 22:50:51 +02:00
|
|
|
THREAD CPUState *thread_env;
|
2003-06-25 18:18:50 +02:00
|
|
|
|
2009-04-07 08:57:11 +02:00
|
|
|
void task_settid(TaskState *ts)
|
|
|
|
{
|
|
|
|
if (ts->ts_tid == 0) {
|
2009-07-27 16:13:24 +02:00
|
|
|
#ifdef CONFIG_USE_NPTL
|
2009-04-07 08:57:11 +02:00
|
|
|
ts->ts_tid = (pid_t)syscall(SYS_gettid);
|
|
|
|
#else
|
|
|
|
/* when no threads are used, tid becomes pid */
|
|
|
|
ts->ts_tid = getpid();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void stop_all_tasks(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We trust that when using NPTL, start_exclusive()
|
|
|
|
* handles thread stopping correctly.
|
|
|
|
*/
|
|
|
|
start_exclusive();
|
|
|
|
}
|
|
|
|
|
2008-06-09 16:02:50 +02:00
|
|
|
/* Assumes contents are already zeroed. */
|
2008-05-31 18:11:38 +02:00
|
|
|
void init_task_state(TaskState *ts)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ts->used = 1;
|
|
|
|
ts->first_free = ts->sigqueue_table;
|
|
|
|
for (i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++) {
|
|
|
|
ts->sigqueue_table[i].next = &ts->sigqueue_table[i + 1];
|
|
|
|
}
|
|
|
|
ts->sigqueue_table[i].next = NULL;
|
|
|
|
}
|
|
|
|
|
2008-12-10 20:18:40 +01:00
|
|
|
int main(int argc, char **argv, char **envp)
|
2003-02-18 23:55:36 +01:00
|
|
|
{
|
|
|
|
const char *filename;
|
2007-03-19 09:08:28 +01:00
|
|
|
const char *cpu_model;
|
2011-06-07 18:32:40 +02:00
|
|
|
const char *log_file = DEBUG_LOGFILE;
|
|
|
|
const char *log_mask = NULL;
|
2003-02-19 00:00:51 +01:00
|
|
|
struct target_pt_regs regs1, *regs = ®s1;
|
2003-02-18 23:55:36 +01:00
|
|
|
struct image_info info1, *info = &info1;
|
2009-04-07 08:57:11 +02:00
|
|
|
struct linux_binprm bprm;
|
linux-user: fix memory leaks with NPTL emulation
Running programs that create large numbers of threads, such as this
snippet from libstdc++'s pthread7-rope.cc:
const int max_thread_count = 4;
const int max_loop_count = 10000;
...
for (int j = 0; j < max_loop_count; j++)
{
...
for (int i = 0; i < max_thread_count; i++)
pthread_create (&tid[i], NULL, thread_main, 0);
for (int i = 0; i < max_thread_count; i++)
pthread_join (tid[i], NULL);
}
in user-mode emulation will quickly run out of memory. This is caused
by a failure to free memory in do_syscall prior to thread exit:
/* TODO: Free CPU state. */
pthread_exit(NULL);
The first step in fixing this is to make all TaskStates used by QEMU
dynamically allocated. The TaskState used by the initial thread was
not, as it was allocated on main's stack. So fix that, free the
cpu_env, free the TaskState, and we're home free, right?
Not exactly. When we create a thread, we do:
ts = qemu_mallocz(sizeof(TaskState) + NEW_STACK_SIZE);
...
new_stack = ts->stack;
...
ret = pthread_attr_setstack(&attr, new_stack, NEW_STACK_SIZE);
If we blindly free the TaskState, then, we yank the current (host)
thread's stack out from underneath it while it still has things to do,
like calling pthread_exit. That causes problems, as you might expect.
The solution adopted here is to let the C library allocate the thread's
stack (so the C library can properly clean it up at pthread_exit) and
provide a hint that we want NEW_STACK_SIZE bytes of stack.
With those two changes, we're done, right? Well, almost. You see,
we're creating all these host threads and their parent threads never
bother to check that their children are finished. There's no good place
for the parent threads to do so. Therefore, we need to create the
threads in a detached state so the parent thread doesn't have to call
pthread_join on the child to release the child's resources; the child
does so automatically.
With those three major changes, we can comfortably run programs like the
above without exhausting memory. We do need to delete 'stack' from the
TaskState structure.
Signed-off-by: Nathan Froyd <froydnj@codesourcery.com>
Signed-off-by: Riku Voipio <riku.voipio@nokia.com>
2010-10-29 16:48:57 +02:00
|
|
|
TaskState *ts;
|
2003-06-15 22:05:50 +02:00
|
|
|
CPUState *env;
|
2003-03-03 16:02:29 +01:00
|
|
|
int optind;
|
2003-03-24 22:58:34 +01:00
|
|
|
const char *r;
|
2005-10-30 22:01:05 +01:00
|
|
|
int gdbstub_port = 0;
|
2009-01-30 20:59:17 +01:00
|
|
|
char **target_environ, **wrk;
|
2009-04-15 18:11:52 +02:00
|
|
|
char **target_argv;
|
|
|
|
int target_argc;
|
2009-01-30 20:59:17 +01:00
|
|
|
envlist_t *envlist = NULL;
|
2009-04-15 18:11:52 +02:00
|
|
|
const char *argv0 = NULL;
|
|
|
|
int i;
|
2009-06-19 09:39:36 +02:00
|
|
|
int ret;
|
2007-06-17 18:38:39 +02:00
|
|
|
|
2003-02-18 23:55:36 +01:00
|
|
|
if (argc <= 1)
|
2008-03-26 23:40:25 +01:00
|
|
|
usage();
|
2003-04-07 23:31:06 +02:00
|
|
|
|
2008-12-10 20:18:40 +01:00
|
|
|
qemu_cache_utils_init(envp);
|
|
|
|
|
2009-01-30 20:59:17 +01:00
|
|
|
if ((envlist = envlist_create()) == NULL) {
|
|
|
|
(void) fprintf(stderr, "Unable to allocate envlist\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add current environment into the list */
|
|
|
|
for (wrk = environ; *wrk != NULL; wrk++) {
|
|
|
|
(void) envlist_setenv(envlist, *wrk);
|
|
|
|
}
|
|
|
|
|
2010-03-19 22:21:13 +01:00
|
|
|
/* Read the stack limit from the kernel. If it's "unlimited",
|
|
|
|
then we can do little else besides use the default. */
|
|
|
|
{
|
|
|
|
struct rlimit lim;
|
|
|
|
if (getrlimit(RLIMIT_STACK, &lim) == 0
|
2010-04-11 21:07:35 +02:00
|
|
|
&& lim.rlim_cur != RLIM_INFINITY
|
|
|
|
&& lim.rlim_cur == (target_long)lim.rlim_cur) {
|
2010-03-19 22:21:13 +01:00
|
|
|
guest_stack_size = lim.rlim_cur;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-03-19 09:08:28 +01:00
|
|
|
cpu_model = NULL;
|
2010-02-20 18:14:59 +01:00
|
|
|
#if defined(cpudef_setup)
|
|
|
|
cpudef_setup(); /* parse cpu definitions in target config file (TBD) */
|
|
|
|
#endif
|
|
|
|
|
2003-03-03 16:02:29 +01:00
|
|
|
optind = 1;
|
2003-03-24 22:58:34 +01:00
|
|
|
for(;;) {
|
|
|
|
if (optind >= argc)
|
|
|
|
break;
|
|
|
|
r = argv[optind];
|
|
|
|
if (r[0] != '-')
|
|
|
|
break;
|
2003-03-03 16:02:29 +01:00
|
|
|
optind++;
|
2003-03-24 22:58:34 +01:00
|
|
|
r++;
|
|
|
|
if (!strcmp(r, "-")) {
|
|
|
|
break;
|
|
|
|
} else if (!strcmp(r, "d")) {
|
2011-06-07 18:32:40 +02:00
|
|
|
if (optind >= argc) {
|
2004-04-25 20:00:45 +02:00
|
|
|
break;
|
2004-03-21 18:08:23 +01:00
|
|
|
}
|
2011-06-07 18:32:40 +02:00
|
|
|
log_mask = argv[optind++];
|
|
|
|
} else if (!strcmp(r, "D")) {
|
|
|
|
if (optind >= argc) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
log_file = argv[optind++];
|
2009-01-30 20:59:17 +01:00
|
|
|
} else if (!strcmp(r, "E")) {
|
|
|
|
r = argv[optind++];
|
|
|
|
if (envlist_setenv(envlist, r) != 0)
|
|
|
|
usage();
|
2010-07-15 22:28:02 +02:00
|
|
|
} else if (!strcmp(r, "ignore-environment")) {
|
|
|
|
envlist_free(envlist);
|
|
|
|
if ((envlist = envlist_create()) == NULL) {
|
|
|
|
(void) fprintf(stderr, "Unable to allocate envlist\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2009-01-30 20:59:17 +01:00
|
|
|
} else if (!strcmp(r, "U")) {
|
|
|
|
r = argv[optind++];
|
|
|
|
if (envlist_unsetenv(envlist, r) != 0)
|
|
|
|
usage();
|
2009-04-15 18:11:52 +02:00
|
|
|
} else if (!strcmp(r, "0")) {
|
|
|
|
r = argv[optind++];
|
|
|
|
argv0 = r;
|
2003-03-24 22:58:34 +01:00
|
|
|
} else if (!strcmp(r, "s")) {
|
2009-02-09 20:02:09 +01:00
|
|
|
if (optind >= argc)
|
|
|
|
break;
|
2003-03-24 22:58:34 +01:00
|
|
|
r = argv[optind++];
|
2010-03-19 22:21:13 +01:00
|
|
|
guest_stack_size = strtoul(r, (char **)&r, 0);
|
|
|
|
if (guest_stack_size == 0)
|
2008-03-26 23:40:25 +01:00
|
|
|
usage();
|
2003-03-24 22:58:34 +01:00
|
|
|
if (*r == 'M')
|
2010-03-19 22:21:13 +01:00
|
|
|
guest_stack_size *= 1024 * 1024;
|
2003-03-24 22:58:34 +01:00
|
|
|
else if (*r == 'k' || *r == 'K')
|
2010-03-19 22:21:13 +01:00
|
|
|
guest_stack_size *= 1024;
|
2003-03-24 22:58:34 +01:00
|
|
|
} else if (!strcmp(r, "L")) {
|
|
|
|
interp_prefix = argv[optind++];
|
2003-05-13 02:25:15 +02:00
|
|
|
} else if (!strcmp(r, "p")) {
|
2009-02-09 20:02:09 +01:00
|
|
|
if (optind >= argc)
|
|
|
|
break;
|
2004-07-05 23:25:26 +02:00
|
|
|
qemu_host_page_size = atoi(argv[optind++]);
|
|
|
|
if (qemu_host_page_size == 0 ||
|
|
|
|
(qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
|
2003-05-13 02:25:15 +02:00
|
|
|
fprintf(stderr, "page size must be a power of two\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2005-04-17 21:16:13 +02:00
|
|
|
} else if (!strcmp(r, "g")) {
|
2009-02-09 20:02:09 +01:00
|
|
|
if (optind >= argc)
|
|
|
|
break;
|
2005-10-30 22:01:05 +01:00
|
|
|
gdbstub_port = atoi(argv[optind++]);
|
2006-05-14 13:30:38 +02:00
|
|
|
} else if (!strcmp(r, "r")) {
|
|
|
|
qemu_uname_release = argv[optind++];
|
2007-03-19 09:08:28 +01:00
|
|
|
} else if (!strcmp(r, "cpu")) {
|
|
|
|
cpu_model = argv[optind++];
|
2009-02-09 20:02:09 +01:00
|
|
|
if (cpu_model == NULL || strcmp(cpu_model, "?") == 0) {
|
2007-10-12 08:47:46 +02:00
|
|
|
/* XXX: implement xxx_cpu_list for targets that still miss it */
|
2010-02-20 18:14:59 +01:00
|
|
|
#if defined(cpu_list_id)
|
|
|
|
cpu_list_id(stdout, &fprintf, "");
|
2010-05-24 00:35:20 +02:00
|
|
|
#elif defined(cpu_list)
|
|
|
|
cpu_list(stdout, &fprintf); /* deprecated */
|
2007-03-19 09:08:28 +01:00
|
|
|
#endif
|
2009-02-28 21:14:00 +01:00
|
|
|
exit(1);
|
2007-03-19 09:08:28 +01:00
|
|
|
}
|
2009-07-17 13:48:08 +02:00
|
|
|
#if defined(CONFIG_USE_GUEST_BASE)
|
|
|
|
} else if (!strcmp(r, "B")) {
|
|
|
|
guest_base = strtol(argv[optind++], NULL, 0);
|
|
|
|
have_guest_base = 1;
|
2010-05-29 03:27:35 +02:00
|
|
|
} else if (!strcmp(r, "R")) {
|
|
|
|
char *p;
|
|
|
|
int shift = 0;
|
|
|
|
reserved_va = strtoul(argv[optind++], &p, 0);
|
|
|
|
switch (*p) {
|
|
|
|
case 'k':
|
|
|
|
case 'K':
|
|
|
|
shift = 10;
|
|
|
|
break;
|
|
|
|
case 'M':
|
|
|
|
shift = 20;
|
|
|
|
break;
|
|
|
|
case 'G':
|
|
|
|
shift = 30;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (shift) {
|
|
|
|
unsigned long unshifted = reserved_va;
|
|
|
|
p++;
|
|
|
|
reserved_va <<= shift;
|
|
|
|
if (((reserved_va >> shift) != unshifted)
|
|
|
|
#if HOST_LONG_BITS > TARGET_VIRT_ADDR_SPACE_BITS
|
|
|
|
|| (reserved_va > (1ul << TARGET_VIRT_ADDR_SPACE_BITS))
|
|
|
|
#endif
|
|
|
|
) {
|
|
|
|
fprintf(stderr, "Reserved virtual address too big\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (*p) {
|
|
|
|
fprintf(stderr, "Unrecognised -R size suffix '%s'\n", p);
|
|
|
|
exit(1);
|
|
|
|
}
|
2009-07-17 13:48:08 +02:00
|
|
|
#endif
|
2007-06-17 18:38:39 +02:00
|
|
|
} else if (!strcmp(r, "drop-ld-preload")) {
|
2009-01-30 20:59:17 +01:00
|
|
|
(void) envlist_unsetenv(envlist, "LD_PRELOAD");
|
2009-04-05 22:08:59 +02:00
|
|
|
} else if (!strcmp(r, "singlestep")) {
|
|
|
|
singlestep = 1;
|
2007-11-11 15:46:06 +01:00
|
|
|
} else if (!strcmp(r, "strace")) {
|
|
|
|
do_strace = 1;
|
2011-01-20 04:28:02 +01:00
|
|
|
} else if (!strcmp(r, "version")) {
|
|
|
|
version();
|
|
|
|
exit(0);
|
|
|
|
} else {
|
2003-03-24 22:58:34 +01:00
|
|
|
usage();
|
|
|
|
}
|
2003-03-03 16:02:29 +01:00
|
|
|
}
|
2011-06-07 18:32:40 +02:00
|
|
|
/* init debug */
|
|
|
|
cpu_set_log_filename(log_file);
|
|
|
|
if (log_mask) {
|
|
|
|
int mask;
|
|
|
|
const CPULogItem *item;
|
|
|
|
|
2011-06-28 20:57:09 +02:00
|
|
|
mask = cpu_str_to_log_mask(log_mask);
|
2011-06-07 18:32:40 +02:00
|
|
|
if (!mask) {
|
|
|
|
printf("Log items (comma separated):\n");
|
|
|
|
for (item = cpu_log_items; item->mask != 0; item++) {
|
|
|
|
printf("%-10s %s\n", item->name, item->help);
|
|
|
|
}
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
cpu_set_log(mask);
|
|
|
|
}
|
2011-07-18 12:44:09 +02:00
|
|
|
|
|
|
|
if (optind >= argc) {
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
filename = argv[optind];
|
|
|
|
exec_path = argv[optind];
|
2003-03-03 16:02:29 +01:00
|
|
|
|
2003-02-18 23:55:36 +01:00
|
|
|
/* Zero out regs */
|
2003-02-19 00:00:51 +01:00
|
|
|
memset(regs, 0, sizeof(struct target_pt_regs));
|
2003-02-18 23:55:36 +01:00
|
|
|
|
|
|
|
/* Zero out image_info */
|
|
|
|
memset(info, 0, sizeof(struct image_info));
|
|
|
|
|
2009-04-07 08:57:11 +02:00
|
|
|
memset(&bprm, 0, sizeof (bprm));
|
|
|
|
|
2003-04-11 02:13:41 +02:00
|
|
|
/* Scan interp_prefix dir for replacement files. */
|
|
|
|
init_paths(interp_prefix);
|
|
|
|
|
2007-11-08 14:56:19 +01:00
|
|
|
if (cpu_model == NULL) {
|
2007-11-10 16:15:54 +01:00
|
|
|
#if defined(TARGET_I386)
|
2007-11-08 14:56:19 +01:00
|
|
|
#ifdef TARGET_X86_64
|
|
|
|
cpu_model = "qemu64";
|
|
|
|
#else
|
|
|
|
cpu_model = "qemu32";
|
|
|
|
#endif
|
2007-11-10 16:15:54 +01:00
|
|
|
#elif defined(TARGET_ARM)
|
2009-04-09 17:20:50 +02:00
|
|
|
cpu_model = "any";
|
2011-04-12 10:27:03 +02:00
|
|
|
#elif defined(TARGET_UNICORE32)
|
|
|
|
cpu_model = "any";
|
2007-11-10 16:15:54 +01:00
|
|
|
#elif defined(TARGET_M68K)
|
|
|
|
cpu_model = "any";
|
|
|
|
#elif defined(TARGET_SPARC)
|
|
|
|
#ifdef TARGET_SPARC64
|
|
|
|
cpu_model = "TI UltraSparc II";
|
|
|
|
#else
|
|
|
|
cpu_model = "Fujitsu MB86904";
|
2007-11-08 14:56:19 +01:00
|
|
|
#endif
|
2007-11-10 16:15:54 +01:00
|
|
|
#elif defined(TARGET_MIPS)
|
|
|
|
#if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)
|
|
|
|
cpu_model = "20Kc";
|
|
|
|
#else
|
|
|
|
cpu_model = "24Kf";
|
|
|
|
#endif
|
|
|
|
#elif defined(TARGET_PPC)
|
2007-11-15 16:37:50 +01:00
|
|
|
#ifdef TARGET_PPC64
|
2010-04-06 12:21:05 +02:00
|
|
|
cpu_model = "970fx";
|
2007-11-15 16:37:50 +01:00
|
|
|
#else
|
2007-11-10 16:15:54 +01:00
|
|
|
cpu_model = "750";
|
2007-11-15 16:37:50 +01:00
|
|
|
#endif
|
2007-11-10 16:15:54 +01:00
|
|
|
#else
|
|
|
|
cpu_model = "any";
|
|
|
|
#endif
|
|
|
|
}
|
2011-08-02 16:10:21 +02:00
|
|
|
tcg_exec_init(0);
|
|
|
|
cpu_exec_init_all();
|
2004-07-05 23:25:26 +02:00
|
|
|
/* NOTE: we need to init the CPU at this stage to get
|
|
|
|
qemu_host_page_size */
|
2007-11-10 16:15:54 +01:00
|
|
|
env = cpu_init(cpu_model);
|
|
|
|
if (!env) {
|
|
|
|
fprintf(stderr, "Unable to find CPU definition\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2009-11-07 11:37:06 +01:00
|
|
|
#if defined(TARGET_I386) || defined(TARGET_SPARC) || defined(TARGET_PPC)
|
|
|
|
cpu_reset(env);
|
|
|
|
#endif
|
|
|
|
|
2008-06-07 22:50:51 +02:00
|
|
|
thread_env = env;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2007-11-11 15:46:06 +01:00
|
|
|
if (getenv("QEMU_STRACE")) {
|
|
|
|
do_strace = 1;
|
2007-11-01 01:07:38 +01:00
|
|
|
}
|
|
|
|
|
2009-01-30 20:59:17 +01:00
|
|
|
target_environ = envlist_to_environ(envlist, NULL);
|
|
|
|
envlist_free(envlist);
|
2007-06-17 18:38:39 +02:00
|
|
|
|
2009-07-17 13:48:08 +02:00
|
|
|
#if defined(CONFIG_USE_GUEST_BASE)
|
|
|
|
/*
|
|
|
|
* Now that page sizes are configured in cpu_init() we can do
|
|
|
|
* proper page alignment for guest_base.
|
|
|
|
*/
|
|
|
|
guest_base = HOST_PAGE_ALIGN(guest_base);
|
2010-05-29 03:27:35 +02:00
|
|
|
|
|
|
|
if (reserved_va) {
|
|
|
|
void *p;
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE;
|
|
|
|
if (have_guest_base) {
|
|
|
|
flags |= MAP_FIXED;
|
|
|
|
}
|
|
|
|
p = mmap((void *)guest_base, reserved_va, PROT_NONE, flags, -1, 0);
|
|
|
|
if (p == MAP_FAILED) {
|
|
|
|
fprintf(stderr, "Unable to reserve guest address space\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
guest_base = (unsigned long)p;
|
|
|
|
/* Make sure the address is properly aligned. */
|
|
|
|
if (guest_base & ~qemu_host_page_mask) {
|
|
|
|
munmap(p, reserved_va);
|
|
|
|
p = mmap((void *)guest_base, reserved_va + qemu_host_page_size,
|
|
|
|
PROT_NONE, flags, -1, 0);
|
|
|
|
if (p == MAP_FAILED) {
|
|
|
|
fprintf(stderr, "Unable to reserve guest address space\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
guest_base = HOST_PAGE_ALIGN((unsigned long)p);
|
|
|
|
}
|
|
|
|
qemu_log("Reserved 0x%lx bytes of guest address space\n", reserved_va);
|
|
|
|
}
|
2010-03-11 00:39:07 +01:00
|
|
|
#endif /* CONFIG_USE_GUEST_BASE */
|
2009-07-17 13:48:08 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Read in mmap_min_addr kernel parameter. This value is used
|
|
|
|
* When loading the ELF image to determine whether guest_base
|
2010-03-11 00:39:07 +01:00
|
|
|
* is needed. It is also used in mmap_find_vma.
|
2009-07-17 13:48:08 +02:00
|
|
|
*/
|
2010-03-11 00:39:07 +01:00
|
|
|
{
|
2009-07-17 13:48:08 +02:00
|
|
|
FILE *fp;
|
|
|
|
|
|
|
|
if ((fp = fopen("/proc/sys/vm/mmap_min_addr", "r")) != NULL) {
|
|
|
|
unsigned long tmp;
|
|
|
|
if (fscanf(fp, "%lu", &tmp) == 1) {
|
|
|
|
mmap_min_addr = tmp;
|
|
|
|
qemu_log("host mmap_min_addr=0x%lx\n", mmap_min_addr);
|
|
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-15 18:11:52 +02:00
|
|
|
/*
|
|
|
|
* Prepare copy of argv vector for target.
|
|
|
|
*/
|
|
|
|
target_argc = argc - optind;
|
|
|
|
target_argv = calloc(target_argc + 1, sizeof (char *));
|
|
|
|
if (target_argv == NULL) {
|
|
|
|
(void) fprintf(stderr, "Unable to allocate memory for target_argv\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If argv0 is specified (using '-0' switch) we replace
|
|
|
|
* argv[0] pointer with the given one.
|
|
|
|
*/
|
|
|
|
i = 0;
|
|
|
|
if (argv0 != NULL) {
|
|
|
|
target_argv[i++] = strdup(argv0);
|
|
|
|
}
|
|
|
|
for (; i < target_argc; i++) {
|
|
|
|
target_argv[i] = strdup(argv[optind + i]);
|
|
|
|
}
|
|
|
|
target_argv[target_argc] = NULL;
|
|
|
|
|
linux-user: fix memory leaks with NPTL emulation
Running programs that create large numbers of threads, such as this
snippet from libstdc++'s pthread7-rope.cc:
const int max_thread_count = 4;
const int max_loop_count = 10000;
...
for (int j = 0; j < max_loop_count; j++)
{
...
for (int i = 0; i < max_thread_count; i++)
pthread_create (&tid[i], NULL, thread_main, 0);
for (int i = 0; i < max_thread_count; i++)
pthread_join (tid[i], NULL);
}
in user-mode emulation will quickly run out of memory. This is caused
by a failure to free memory in do_syscall prior to thread exit:
/* TODO: Free CPU state. */
pthread_exit(NULL);
The first step in fixing this is to make all TaskStates used by QEMU
dynamically allocated. The TaskState used by the initial thread was
not, as it was allocated on main's stack. So fix that, free the
cpu_env, free the TaskState, and we're home free, right?
Not exactly. When we create a thread, we do:
ts = qemu_mallocz(sizeof(TaskState) + NEW_STACK_SIZE);
...
new_stack = ts->stack;
...
ret = pthread_attr_setstack(&attr, new_stack, NEW_STACK_SIZE);
If we blindly free the TaskState, then, we yank the current (host)
thread's stack out from underneath it while it still has things to do,
like calling pthread_exit. That causes problems, as you might expect.
The solution adopted here is to let the C library allocate the thread's
stack (so the C library can properly clean it up at pthread_exit) and
provide a hint that we want NEW_STACK_SIZE bytes of stack.
With those two changes, we're done, right? Well, almost. You see,
we're creating all these host threads and their parent threads never
bother to check that their children are finished. There's no good place
for the parent threads to do so. Therefore, we need to create the
threads in a detached state so the parent thread doesn't have to call
pthread_join on the child to release the child's resources; the child
does so automatically.
With those three major changes, we can comfortably run programs like the
above without exhausting memory. We do need to delete 'stack' from the
TaskState structure.
Signed-off-by: Nathan Froyd <froydnj@codesourcery.com>
Signed-off-by: Riku Voipio <riku.voipio@nokia.com>
2010-10-29 16:48:57 +02:00
|
|
|
ts = qemu_mallocz (sizeof(TaskState));
|
2009-04-07 08:57:11 +02:00
|
|
|
init_task_state(ts);
|
|
|
|
/* build Task State */
|
|
|
|
ts->info = info;
|
|
|
|
ts->bprm = &bprm;
|
|
|
|
env->opaque = ts;
|
|
|
|
task_settid(ts);
|
|
|
|
|
2009-06-19 09:39:36 +02:00
|
|
|
ret = loader_exec(filename, target_argv, target_environ, regs,
|
|
|
|
info, &bprm);
|
|
|
|
if (ret != 0) {
|
|
|
|
printf("Error %d while loading %s\n", ret, filename);
|
2007-06-17 18:38:39 +02:00
|
|
|
_exit(1);
|
|
|
|
}
|
|
|
|
|
2009-04-15 18:11:52 +02:00
|
|
|
for (i = 0; i < target_argc; i++) {
|
|
|
|
free(target_argv[i]);
|
|
|
|
}
|
|
|
|
free(target_argv);
|
|
|
|
|
2007-06-17 18:38:39 +02:00
|
|
|
for (wrk = target_environ; *wrk; wrk++) {
|
|
|
|
free(*wrk);
|
2003-02-18 23:55:36 +01:00
|
|
|
}
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2007-06-17 18:38:39 +02:00
|
|
|
free(target_environ);
|
|
|
|
|
2009-01-20 17:57:34 +01:00
|
|
|
if (qemu_log_enabled()) {
|
2009-07-17 13:48:08 +02:00
|
|
|
#if defined(CONFIG_USE_GUEST_BASE)
|
|
|
|
qemu_log("guest_base 0x%lx\n", guest_base);
|
|
|
|
#endif
|
2009-01-20 17:57:34 +01:00
|
|
|
log_page_dump();
|
|
|
|
|
|
|
|
qemu_log("start_brk 0x" TARGET_ABI_FMT_lx "\n", info->start_brk);
|
|
|
|
qemu_log("end_code 0x" TARGET_ABI_FMT_lx "\n", info->end_code);
|
|
|
|
qemu_log("start_code 0x" TARGET_ABI_FMT_lx "\n",
|
|
|
|
info->start_code);
|
|
|
|
qemu_log("start_data 0x" TARGET_ABI_FMT_lx "\n",
|
|
|
|
info->start_data);
|
|
|
|
qemu_log("end_data 0x" TARGET_ABI_FMT_lx "\n", info->end_data);
|
|
|
|
qemu_log("start_stack 0x" TARGET_ABI_FMT_lx "\n",
|
|
|
|
info->start_stack);
|
|
|
|
qemu_log("brk 0x" TARGET_ABI_FMT_lx "\n", info->brk);
|
|
|
|
qemu_log("entry 0x" TARGET_ABI_FMT_lx "\n", info->entry);
|
|
|
|
}
|
2003-02-18 23:55:36 +01:00
|
|
|
|
2006-03-25 20:31:22 +01:00
|
|
|
target_set_brk(info->brk);
|
2003-02-18 23:55:36 +01:00
|
|
|
syscall_init();
|
2003-03-23 02:06:05 +01:00
|
|
|
signal_init();
|
2003-02-18 23:55:36 +01:00
|
|
|
|
2010-05-06 17:50:41 +02:00
|
|
|
#if defined(CONFIG_USE_GUEST_BASE)
|
|
|
|
/* Now that we've loaded the binary, GUEST_BASE is fixed. Delay
|
|
|
|
generating the prologue until now so that the prologue can take
|
|
|
|
the real value of GUEST_BASE into account. */
|
|
|
|
tcg_prologue_init(&tcg_ctx);
|
|
|
|
#endif
|
|
|
|
|
2003-06-15 22:05:50 +02:00
|
|
|
#if defined(TARGET_I386)
|
2003-08-22 01:25:21 +02:00
|
|
|
cpu_x86_set_cpl(env, 3);
|
|
|
|
|
2003-07-26 20:02:28 +02:00
|
|
|
env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK;
|
2005-01-12 23:34:47 +01:00
|
|
|
env->hflags |= HF_PE_MASK;
|
|
|
|
if (env->cpuid_features & CPUID_SSE) {
|
|
|
|
env->cr[4] |= CR4_OSFXSR_MASK;
|
|
|
|
env->hflags |= HF_OSFXSR_MASK;
|
|
|
|
}
|
2007-11-14 19:08:56 +01:00
|
|
|
#ifndef TARGET_ABI32
|
2007-11-15 16:27:03 +01:00
|
|
|
/* enable 64 bit mode if possible */
|
|
|
|
if (!(env->cpuid_ext2_features & CPUID_EXT2_LM)) {
|
|
|
|
fprintf(stderr, "The selected x86 CPU does not support 64 bit mode\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2007-11-14 19:08:56 +01:00
|
|
|
env->cr[4] |= CR4_PAE_MASK;
|
2007-11-15 16:27:03 +01:00
|
|
|
env->efer |= MSR_EFER_LMA | MSR_EFER_LME;
|
2007-11-14 19:08:56 +01:00
|
|
|
env->hflags |= HF_LMA_MASK;
|
|
|
|
#endif
|
2005-01-12 23:34:47 +01:00
|
|
|
|
2004-02-04 00:37:12 +01:00
|
|
|
/* flags setup : we activate the IRQs by default as in user mode */
|
|
|
|
env->eflags |= IF_MASK;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2003-03-16 19:05:05 +01:00
|
|
|
/* linux register setup */
|
2007-11-14 19:08:56 +01:00
|
|
|
#ifndef TARGET_ABI32
|
2007-04-06 10:56:50 +02:00
|
|
|
env->regs[R_EAX] = regs->rax;
|
|
|
|
env->regs[R_EBX] = regs->rbx;
|
|
|
|
env->regs[R_ECX] = regs->rcx;
|
|
|
|
env->regs[R_EDX] = regs->rdx;
|
|
|
|
env->regs[R_ESI] = regs->rsi;
|
|
|
|
env->regs[R_EDI] = regs->rdi;
|
|
|
|
env->regs[R_EBP] = regs->rbp;
|
|
|
|
env->regs[R_ESP] = regs->rsp;
|
|
|
|
env->eip = regs->rip;
|
|
|
|
#else
|
2003-03-03 15:32:43 +01:00
|
|
|
env->regs[R_EAX] = regs->eax;
|
|
|
|
env->regs[R_EBX] = regs->ebx;
|
|
|
|
env->regs[R_ECX] = regs->ecx;
|
|
|
|
env->regs[R_EDX] = regs->edx;
|
|
|
|
env->regs[R_ESI] = regs->esi;
|
|
|
|
env->regs[R_EDI] = regs->edi;
|
|
|
|
env->regs[R_EBP] = regs->ebp;
|
|
|
|
env->regs[R_ESP] = regs->esp;
|
2003-03-22 16:23:14 +01:00
|
|
|
env->eip = regs->eip;
|
2007-04-06 10:56:50 +02:00
|
|
|
#endif
|
2003-02-18 23:55:36 +01:00
|
|
|
|
2003-05-28 01:28:08 +02:00
|
|
|
/* linux interrupt setup */
|
2008-11-10 03:55:33 +01:00
|
|
|
#ifndef TARGET_ABI32
|
|
|
|
env->idt.limit = 511;
|
|
|
|
#else
|
|
|
|
env->idt.limit = 255;
|
|
|
|
#endif
|
|
|
|
env->idt.base = target_mmap(0, sizeof(uint64_t) * (env->idt.limit + 1),
|
|
|
|
PROT_READ|PROT_WRITE,
|
|
|
|
MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
|
|
|
|
idt_table = g2h(env->idt.base);
|
2003-05-28 01:28:08 +02:00
|
|
|
set_idt(0, 0);
|
|
|
|
set_idt(1, 0);
|
|
|
|
set_idt(2, 0);
|
|
|
|
set_idt(3, 3);
|
|
|
|
set_idt(4, 3);
|
2008-05-12 14:23:31 +02:00
|
|
|
set_idt(5, 0);
|
2003-05-28 01:28:08 +02:00
|
|
|
set_idt(6, 0);
|
|
|
|
set_idt(7, 0);
|
|
|
|
set_idt(8, 0);
|
|
|
|
set_idt(9, 0);
|
|
|
|
set_idt(10, 0);
|
|
|
|
set_idt(11, 0);
|
|
|
|
set_idt(12, 0);
|
|
|
|
set_idt(13, 0);
|
|
|
|
set_idt(14, 0);
|
|
|
|
set_idt(15, 0);
|
|
|
|
set_idt(16, 0);
|
|
|
|
set_idt(17, 0);
|
|
|
|
set_idt(18, 0);
|
|
|
|
set_idt(19, 0);
|
|
|
|
set_idt(0x80, 3);
|
|
|
|
|
2003-03-16 19:05:05 +01:00
|
|
|
/* linux segment setup */
|
2007-11-14 16:18:40 +01:00
|
|
|
{
|
|
|
|
uint64_t *gdt_table;
|
2008-11-10 03:55:33 +01:00
|
|
|
env->gdt.base = target_mmap(0, sizeof(uint64_t) * TARGET_GDT_ENTRIES,
|
|
|
|
PROT_READ|PROT_WRITE,
|
|
|
|
MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
|
2007-11-14 16:18:40 +01:00
|
|
|
env->gdt.limit = sizeof(uint64_t) * TARGET_GDT_ENTRIES - 1;
|
2008-11-10 03:55:33 +01:00
|
|
|
gdt_table = g2h(env->gdt.base);
|
2007-11-14 19:08:56 +01:00
|
|
|
#ifdef TARGET_ABI32
|
2007-11-14 16:18:40 +01:00
|
|
|
write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
|
|
|
|
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
|
|
|
|
(3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
|
2007-11-14 19:08:56 +01:00
|
|
|
#else
|
|
|
|
/* 64 bit code segment */
|
|
|
|
write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
|
|
|
|
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
|
|
|
|
DESC_L_MASK |
|
|
|
|
(3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
|
|
|
|
#endif
|
2007-11-14 16:18:40 +01:00
|
|
|
write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff,
|
|
|
|
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
|
|
|
|
(3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));
|
|
|
|
}
|
2003-03-16 19:05:05 +01:00
|
|
|
cpu_x86_load_seg(env, R_CS, __USER_CS);
|
2007-11-14 19:08:56 +01:00
|
|
|
cpu_x86_load_seg(env, R_SS, __USER_DS);
|
|
|
|
#ifdef TARGET_ABI32
|
2003-03-16 19:05:05 +01:00
|
|
|
cpu_x86_load_seg(env, R_DS, __USER_DS);
|
|
|
|
cpu_x86_load_seg(env, R_ES, __USER_DS);
|
|
|
|
cpu_x86_load_seg(env, R_FS, __USER_DS);
|
|
|
|
cpu_x86_load_seg(env, R_GS, __USER_DS);
|
2007-06-22 00:55:02 +02:00
|
|
|
/* This hack makes Wine work... */
|
|
|
|
env->segs[R_FS].selector = 0;
|
2007-11-14 19:08:56 +01:00
|
|
|
#else
|
|
|
|
cpu_x86_load_seg(env, R_DS, 0);
|
|
|
|
cpu_x86_load_seg(env, R_ES, 0);
|
|
|
|
cpu_x86_load_seg(env, R_FS, 0);
|
|
|
|
cpu_x86_load_seg(env, R_GS, 0);
|
|
|
|
#endif
|
2003-06-15 22:05:50 +02:00
|
|
|
#elif defined(TARGET_ARM)
|
|
|
|
{
|
|
|
|
int i;
|
2005-11-26 11:38:39 +01:00
|
|
|
cpsr_write(env, regs->uregs[16], 0xffffffff);
|
2003-06-15 22:05:50 +02:00
|
|
|
for(i = 0; i < 16; i++) {
|
|
|
|
env->regs[i] = regs->uregs[i];
|
|
|
|
}
|
|
|
|
}
|
2011-04-12 10:27:03 +02:00
|
|
|
#elif defined(TARGET_UNICORE32)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
cpu_asr_write(env, regs->uregs[32], 0xffffffff);
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
|
|
env->regs[i] = regs->uregs[i];
|
|
|
|
}
|
|
|
|
}
|
2003-09-30 22:57:29 +02:00
|
|
|
#elif defined(TARGET_SPARC)
|
2004-01-04 16:50:01 +01:00
|
|
|
{
|
|
|
|
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];
|
|
|
|
}
|
2003-11-23 18:05:30 +01:00
|
|
|
#elif defined(TARGET_PPC)
|
|
|
|
{
|
|
|
|
int i;
|
2005-07-02 22:59:34 +02:00
|
|
|
|
2007-10-25 23:35:50 +02:00
|
|
|
#if defined(TARGET_PPC64)
|
|
|
|
#if defined(TARGET_ABI32)
|
|
|
|
env->msr &= ~((target_ulong)1 << MSR_SF);
|
2007-10-18 21:59:49 +02:00
|
|
|
#else
|
2007-10-25 23:35:50 +02:00
|
|
|
env->msr |= (target_ulong)1 << MSR_SF;
|
|
|
|
#endif
|
2007-04-06 10:56:50 +02:00
|
|
|
#endif
|
2003-11-23 18:05:30 +01:00
|
|
|
env->nip = regs->nip;
|
|
|
|
for(i = 0; i < 32; i++) {
|
|
|
|
env->gpr[i] = regs->gpr[i];
|
|
|
|
}
|
|
|
|
}
|
2006-10-22 02:18:54 +02:00
|
|
|
#elif defined(TARGET_M68K)
|
|
|
|
{
|
|
|
|
env->pc = regs->pc;
|
|
|
|
env->dregs[0] = regs->d0;
|
|
|
|
env->dregs[1] = regs->d1;
|
|
|
|
env->dregs[2] = regs->d2;
|
|
|
|
env->dregs[3] = regs->d3;
|
|
|
|
env->dregs[4] = regs->d4;
|
|
|
|
env->dregs[5] = regs->d5;
|
|
|
|
env->dregs[6] = regs->d6;
|
|
|
|
env->dregs[7] = regs->d7;
|
|
|
|
env->aregs[0] = regs->a0;
|
|
|
|
env->aregs[1] = regs->a1;
|
|
|
|
env->aregs[2] = regs->a2;
|
|
|
|
env->aregs[3] = regs->a3;
|
|
|
|
env->aregs[4] = regs->a4;
|
|
|
|
env->aregs[5] = regs->a5;
|
|
|
|
env->aregs[6] = regs->a6;
|
|
|
|
env->aregs[7] = regs->usp;
|
|
|
|
env->sr = regs->sr;
|
|
|
|
ts->sim_syscalls = 1;
|
|
|
|
}
|
2009-05-20 21:31:33 +02:00
|
|
|
#elif defined(TARGET_MICROBLAZE)
|
|
|
|
{
|
|
|
|
env->regs[0] = regs->r0;
|
|
|
|
env->regs[1] = regs->r1;
|
|
|
|
env->regs[2] = regs->r2;
|
|
|
|
env->regs[3] = regs->r3;
|
|
|
|
env->regs[4] = regs->r4;
|
|
|
|
env->regs[5] = regs->r5;
|
|
|
|
env->regs[6] = regs->r6;
|
|
|
|
env->regs[7] = regs->r7;
|
|
|
|
env->regs[8] = regs->r8;
|
|
|
|
env->regs[9] = regs->r9;
|
|
|
|
env->regs[10] = regs->r10;
|
|
|
|
env->regs[11] = regs->r11;
|
|
|
|
env->regs[12] = regs->r12;
|
|
|
|
env->regs[13] = regs->r13;
|
|
|
|
env->regs[14] = regs->r14;
|
|
|
|
env->regs[15] = regs->r15;
|
|
|
|
env->regs[16] = regs->r16;
|
|
|
|
env->regs[17] = regs->r17;
|
|
|
|
env->regs[18] = regs->r18;
|
|
|
|
env->regs[19] = regs->r19;
|
|
|
|
env->regs[20] = regs->r20;
|
|
|
|
env->regs[21] = regs->r21;
|
|
|
|
env->regs[22] = regs->r22;
|
|
|
|
env->regs[23] = regs->r23;
|
|
|
|
env->regs[24] = regs->r24;
|
|
|
|
env->regs[25] = regs->r25;
|
|
|
|
env->regs[26] = regs->r26;
|
|
|
|
env->regs[27] = regs->r27;
|
|
|
|
env->regs[28] = regs->r28;
|
|
|
|
env->regs[29] = regs->r29;
|
|
|
|
env->regs[30] = regs->r30;
|
|
|
|
env->regs[31] = regs->r31;
|
|
|
|
env->sregs[SR_PC] = regs->pc;
|
|
|
|
}
|
2005-11-26 19:47:20 +01:00
|
|
|
#elif defined(TARGET_MIPS)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < 32; i++) {
|
2008-06-27 12:02:35 +02:00
|
|
|
env->active_tc.gpr[i] = regs->regs[i];
|
2005-11-26 19:47:20 +01:00
|
|
|
}
|
2010-06-08 22:30:02 +02:00
|
|
|
env->active_tc.PC = regs->cp0_epc & ~(target_ulong)1;
|
|
|
|
if (regs->cp0_epc & 1) {
|
|
|
|
env->hflags |= MIPS_HFLAG_M16;
|
|
|
|
}
|
2005-11-26 19:47:20 +01:00
|
|
|
}
|
2006-04-27 23:07:38 +02:00
|
|
|
#elif defined(TARGET_SH4)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < 16; i++) {
|
|
|
|
env->gregs[i] = regs->regs[i];
|
|
|
|
}
|
|
|
|
env->pc = regs->pc;
|
|
|
|
}
|
2007-04-05 09:13:51 +02:00
|
|
|
#elif defined(TARGET_ALPHA)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < 28; i++) {
|
2007-10-14 18:27:31 +02:00
|
|
|
env->ir[i] = ((abi_ulong *)regs)[i];
|
2007-04-05 09:13:51 +02:00
|
|
|
}
|
2010-01-04 20:19:14 +01:00
|
|
|
env->ir[IR_SP] = regs->usp;
|
2007-04-05 09:13:51 +02:00
|
|
|
env->pc = regs->pc;
|
|
|
|
}
|
2007-10-08 15:36:46 +02:00
|
|
|
#elif defined(TARGET_CRIS)
|
|
|
|
{
|
|
|
|
env->regs[0] = regs->r0;
|
|
|
|
env->regs[1] = regs->r1;
|
|
|
|
env->regs[2] = regs->r2;
|
|
|
|
env->regs[3] = regs->r3;
|
|
|
|
env->regs[4] = regs->r4;
|
|
|
|
env->regs[5] = regs->r5;
|
|
|
|
env->regs[6] = regs->r6;
|
|
|
|
env->regs[7] = regs->r7;
|
|
|
|
env->regs[8] = regs->r8;
|
|
|
|
env->regs[9] = regs->r9;
|
|
|
|
env->regs[10] = regs->r10;
|
|
|
|
env->regs[11] = regs->r11;
|
|
|
|
env->regs[12] = regs->r12;
|
|
|
|
env->regs[13] = regs->r13;
|
|
|
|
env->regs[14] = info->start_stack;
|
|
|
|
env->regs[15] = regs->acr;
|
|
|
|
env->pc = regs->erp;
|
|
|
|
}
|
2009-07-24 16:57:31 +02:00
|
|
|
#elif defined(TARGET_S390X)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
env->regs[i] = regs->gprs[i];
|
|
|
|
}
|
|
|
|
env->psw.mask = regs->psw.mask;
|
|
|
|
env->psw.addr = regs->psw.addr;
|
|
|
|
}
|
2003-06-15 22:05:50 +02:00
|
|
|
#else
|
|
|
|
#error unsupported target CPU
|
|
|
|
#endif
|
2003-02-18 23:55:36 +01:00
|
|
|
|
2011-04-12 10:27:03 +02:00
|
|
|
#if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32)
|
2007-05-26 17:09:38 +02:00
|
|
|
ts->stack_base = info->start_stack;
|
|
|
|
ts->heap_base = info->brk;
|
|
|
|
/* This will be filled in on the first SYS_HEAPINFO call. */
|
|
|
|
ts->heap_limit = 0;
|
|
|
|
#endif
|
|
|
|
|
2005-10-30 22:01:05 +01:00
|
|
|
if (gdbstub_port) {
|
|
|
|
gdbserver_start (gdbstub_port);
|
2005-04-17 21:16:13 +02:00
|
|
|
gdb_handlesig(env, 0);
|
|
|
|
}
|
2003-03-22 18:31:38 +01:00
|
|
|
cpu_loop(env);
|
|
|
|
/* never exits */
|
2003-02-18 23:55:36 +01:00
|
|
|
return 0;
|
|
|
|
}
|