2003-02-19 01:55:36 +03:00
|
|
|
/*
|
2003-10-01 00:57:29 +04:00
|
|
|
* qemu user main
|
2007-09-17 01:08:06 +04:00
|
|
|
*
|
2008-01-06 20:21:48 +03:00
|
|
|
* Copyright (c) 2003-2008 Fabrice Bellard
|
2003-02-19 01:55:36 +03: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-17 00:47:01 +04:00
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
2003-02-19 01:55:36 +03:00
|
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdarg.h>
|
2003-03-21 01:33:23 +03:00
|
|
|
#include <string.h>
|
2003-02-19 01:55:36 +03:00
|
|
|
#include <errno.h>
|
2003-03-03 17:32:43 +03:00
|
|
|
#include <unistd.h>
|
2008-11-10 05:55:33 +03:00
|
|
|
#include <sys/mman.h>
|
2009-04-07 10:57:11 +04:00
|
|
|
#include <sys/syscall.h>
|
2010-03-20 00:21:13 +03:00
|
|
|
#include <sys/resource.h>
|
2003-02-19 01:55:36 +03:00
|
|
|
|
2003-03-23 23:17:16 +03:00
|
|
|
#include "qemu.h"
|
2008-04-12 01:35:42 +04:00
|
|
|
#include "qemu-common.h"
|
2011-06-20 00:38:22 +04:00
|
|
|
#include "cpu.h"
|
2010-05-06 19:50:41 +04:00
|
|
|
#include "tcg.h"
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/timer.h"
|
|
|
|
#include "qemu/envlist.h"
|
2012-03-30 21:02:50 +04:00
|
|
|
#include "elf.h"
|
2009-01-30 22:59:17 +03:00
|
|
|
|
2009-01-30 23:09:01 +03:00
|
|
|
char *exec_path;
|
|
|
|
|
2009-04-06 00:08:59 +04:00
|
|
|
int singlestep;
|
2015-08-29 10:29:52 +03:00
|
|
|
static const char *filename;
|
|
|
|
static const char *argv0;
|
|
|
|
static int gdbstub_port;
|
|
|
|
static envlist_t *envlist;
|
2013-07-02 20:26:11 +04:00
|
|
|
static const char *cpu_model;
|
2009-07-17 15:48:08 +04:00
|
|
|
unsigned long mmap_min_addr;
|
|
|
|
unsigned long guest_base;
|
|
|
|
int have_guest_base;
|
2011-12-14 03:33:28 +04:00
|
|
|
#if (TARGET_LONG_BITS == 32) && (HOST_LONG_BITS == 64)
|
|
|
|
/*
|
|
|
|
* When running 32-on-64 we should make sure we can fit all of the possible
|
|
|
|
* guest address space into a contiguous chunk of virtual host memory.
|
|
|
|
*
|
|
|
|
* This way we will never overlap with our own libraries or binaries or stack
|
|
|
|
* or anything else that QEMU maps.
|
|
|
|
*/
|
2013-01-03 17:17:18 +04:00
|
|
|
# ifdef TARGET_MIPS
|
|
|
|
/* MIPS only supports 31 bits of virtual address space for user space */
|
|
|
|
unsigned long reserved_va = 0x77000000;
|
|
|
|
# else
|
2011-12-14 03:33:28 +04:00
|
|
|
unsigned long reserved_va = 0xf7000000;
|
2013-01-03 17:17:18 +04:00
|
|
|
# endif
|
2011-12-14 03:33:28 +04:00
|
|
|
#else
|
2010-05-29 05:27:35 +04:00
|
|
|
unsigned long reserved_va;
|
2009-07-17 15:48:08 +04:00
|
|
|
#endif
|
2009-04-06 00:08:59 +04:00
|
|
|
|
2011-08-06 10:54:12 +04:00
|
|
|
static void usage(void);
|
|
|
|
|
2010-05-26 18:08:22 +04:00
|
|
|
static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX;
|
2014-03-04 06:28:43 +04:00
|
|
|
const char *qemu_uname_release;
|
2003-03-03 18:02:29 +03:00
|
|
|
|
2003-03-23 19:49:39 +03: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-20 00:21:13 +03:00
|
|
|
unsigned long guest_stack_size = 8 * 1024 * 1024UL;
|
2003-02-19 01:55:36 +03:00
|
|
|
|
|
|
|
void gemu_log(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vfprintf(stderr, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2008-08-18 00:26:25 +04:00
|
|
|
#if defined(TARGET_I386)
|
2012-02-25 06:37:53 +04:00
|
|
|
int cpu_get_pic_interrupt(CPUX86State *env)
|
2003-06-24 17:30:31 +04:00
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
2008-08-18 00:26:25 +04:00
|
|
|
#endif
|
2003-06-24 17:30:31 +04:00
|
|
|
|
2008-06-08 00:50:51 +04: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 18:24:59 +03:00
|
|
|
static pthread_mutex_t cpu_list_mutex = PTHREAD_MUTEX_INITIALIZER;
|
2008-06-08 00:50:51 +04: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)
|
|
|
|
{
|
2015-08-10 18:27:02 +03:00
|
|
|
qemu_mutex_lock(&tcg_ctx.tb_ctx.tb_lock);
|
2008-06-08 00:50:51 +04:00
|
|
|
pthread_mutex_lock(&exclusive_lock);
|
2009-12-04 16:16:31 +03:00
|
|
|
mmap_fork_start();
|
2008-06-08 00:50:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void fork_end(int child)
|
|
|
|
{
|
2009-12-04 16:16:31 +03:00
|
|
|
mmap_fork_end(child);
|
2008-06-08 00:50:51 +04:00
|
|
|
if (child) {
|
2013-06-25 01:50:24 +04:00
|
|
|
CPUState *cpu, *next_cpu;
|
2008-06-08 00:50:51 +04:00
|
|
|
/* Child processes created by fork() only have a single thread.
|
|
|
|
Discard information about the parent threads. */
|
2013-06-25 01:50:24 +04:00
|
|
|
CPU_FOREACH_SAFE(cpu, next_cpu) {
|
|
|
|
if (cpu != thread_cpu) {
|
|
|
|
QTAILQ_REMOVE(&cpus, thread_cpu, node);
|
|
|
|
}
|
|
|
|
}
|
2008-06-08 00:50:51 +04:00
|
|
|
pending_cpus = 0;
|
|
|
|
pthread_mutex_init(&exclusive_lock, NULL);
|
2009-03-07 18:24:59 +03:00
|
|
|
pthread_mutex_init(&cpu_list_mutex, NULL);
|
2008-06-08 00:50:51 +04:00
|
|
|
pthread_cond_init(&exclusive_cond, NULL);
|
|
|
|
pthread_cond_init(&exclusive_resume, NULL);
|
2015-08-10 18:27:02 +03:00
|
|
|
qemu_mutex_init(&tcg_ctx.tb_ctx.tb_lock);
|
2015-06-24 05:31:16 +03:00
|
|
|
gdbserver_fork(thread_cpu);
|
2008-06-08 00:50:51 +04:00
|
|
|
} else {
|
|
|
|
pthread_mutex_unlock(&exclusive_lock);
|
2015-08-10 18:27:02 +03:00
|
|
|
qemu_mutex_unlock(&tcg_ctx.tb_ctx.tb_lock);
|
2008-06-08 00:50:51 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
{
|
2012-12-17 10:34:52 +04:00
|
|
|
CPUState *other_cpu;
|
|
|
|
|
2008-06-08 00:50:51 +04:00
|
|
|
pthread_mutex_lock(&exclusive_lock);
|
|
|
|
exclusive_idle();
|
|
|
|
|
|
|
|
pending_cpus = 1;
|
|
|
|
/* Make all other cpus stop executing. */
|
2013-06-25 01:50:24 +04:00
|
|
|
CPU_FOREACH(other_cpu) {
|
2012-12-17 10:34:52 +04:00
|
|
|
if (other_cpu->running) {
|
2008-06-08 00:50:51 +04:00
|
|
|
pending_cpus++;
|
2013-05-17 20:26:54 +04:00
|
|
|
cpu_exit(other_cpu);
|
2008-06-08 00:50:51 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pending_cpus > 1) {
|
|
|
|
pthread_cond_wait(&exclusive_cond, &exclusive_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Finish an exclusive operation. */
|
2015-01-08 15:19:47 +03:00
|
|
|
static inline void __attribute__((unused)) end_exclusive(void)
|
2008-06-08 00:50:51 +04:00
|
|
|
{
|
|
|
|
pending_cpus = 0;
|
|
|
|
pthread_cond_broadcast(&exclusive_resume);
|
|
|
|
pthread_mutex_unlock(&exclusive_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Wait for exclusive ops to finish, and begin cpu execution. */
|
2012-12-17 10:34:52 +04:00
|
|
|
static inline void cpu_exec_start(CPUState *cpu)
|
2008-06-08 00:50:51 +04:00
|
|
|
{
|
|
|
|
pthread_mutex_lock(&exclusive_lock);
|
|
|
|
exclusive_idle();
|
2012-12-17 10:34:52 +04:00
|
|
|
cpu->running = true;
|
2008-06-08 00:50:51 +04:00
|
|
|
pthread_mutex_unlock(&exclusive_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark cpu as not executing, and release pending exclusive ops. */
|
2012-12-17 10:34:52 +04:00
|
|
|
static inline void cpu_exec_end(CPUState *cpu)
|
2008-06-08 00:50:51 +04:00
|
|
|
{
|
|
|
|
pthread_mutex_lock(&exclusive_lock);
|
2012-12-17 10:34:52 +04:00
|
|
|
cpu->running = false;
|
2008-06-08 00:50:51 +04:00
|
|
|
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 18:24:59 +03:00
|
|
|
|
|
|
|
void cpu_list_lock(void)
|
|
|
|
{
|
|
|
|
pthread_mutex_lock(&cpu_list_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cpu_list_unlock(void)
|
|
|
|
{
|
|
|
|
pthread_mutex_unlock(&cpu_list_mutex);
|
|
|
|
}
|
2008-06-08 00:50:51 +04:00
|
|
|
|
|
|
|
|
2004-04-13 00:39:29 +04:00
|
|
|
#ifdef TARGET_I386
|
|
|
|
/***********************************************************/
|
|
|
|
/* CPUX86 core interface */
|
|
|
|
|
2004-05-20 18:02:14 +04:00
|
|
|
uint64_t cpu_get_tsc(CPUX86State *env)
|
|
|
|
{
|
|
|
|
return cpu_get_real_ticks();
|
|
|
|
}
|
|
|
|
|
2007-09-17 01:08:06 +04:00
|
|
|
static void write_dt(void *ptr, unsigned long addr, unsigned long limit,
|
2003-05-28 03:28:08 +04:00
|
|
|
int flags)
|
2003-03-16 21:05:05 +03:00
|
|
|
{
|
2003-05-28 03:28:08 +04:00
|
|
|
unsigned int e1, e2;
|
2006-03-25 22:31:22 +03:00
|
|
|
uint32_t *p;
|
2003-03-16 21:05:05 +03:00
|
|
|
e1 = (addr << 16) | (limit & 0xffff);
|
|
|
|
e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
|
2003-05-28 03:28:08 +04:00
|
|
|
e2 |= flags;
|
2006-03-25 22:31:22 +03:00
|
|
|
p = ptr;
|
2008-08-21 02:39:26 +04:00
|
|
|
p[0] = tswap32(e1);
|
|
|
|
p[1] = tswap32(e2);
|
2003-05-28 03:28:08 +04:00
|
|
|
}
|
|
|
|
|
2008-11-10 05:55:33 +03:00
|
|
|
static uint64_t *idt_table;
|
2008-09-06 21:47:39 +04:00
|
|
|
#ifdef TARGET_X86_64
|
2007-11-14 21:08:56 +03:00
|
|
|
static void set_gate64(void *ptr, unsigned int type, unsigned int dpl,
|
|
|
|
uint64_t addr, unsigned int sel)
|
2003-05-28 03:28:08 +04:00
|
|
|
{
|
2007-11-15 18:27:03 +03:00
|
|
|
uint32_t *p, e1, e2;
|
2003-05-28 03:28:08 +04:00
|
|
|
e1 = (addr & 0xffff) | (sel << 16);
|
|
|
|
e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
|
2006-03-25 22:31:22 +03:00
|
|
|
p = ptr;
|
2007-11-15 18:27:03 +03:00
|
|
|
p[0] = tswap32(e1);
|
|
|
|
p[1] = tswap32(e2);
|
|
|
|
p[2] = tswap32(addr >> 32);
|
|
|
|
p[3] = 0;
|
2003-03-16 21:05:05 +03:00
|
|
|
}
|
2007-11-14 21:08:56 +03: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 18:27:03 +03:00
|
|
|
uint32_t *p, e1, e2;
|
2007-11-14 21:08:56 +03:00
|
|
|
e1 = (addr & 0xffff) | (sel << 16);
|
|
|
|
e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
|
|
|
|
p = ptr;
|
2007-11-15 18:27:03 +03:00
|
|
|
p[0] = tswap32(e1);
|
|
|
|
p[1] = tswap32(e2);
|
2007-11-14 21:08:56 +03:00
|
|
|
}
|
|
|
|
|
2003-05-28 03:28:08 +04: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 21:08:56 +03:00
|
|
|
#endif
|
2003-02-19 01:55:36 +03:00
|
|
|
|
2003-05-10 16:33:15 +04:00
|
|
|
void cpu_loop(CPUX86State *env)
|
2003-03-22 20:31:38 +03:00
|
|
|
{
|
2013-06-27 21:49:31 +04:00
|
|
|
CPUState *cs = CPU(x86_env_get_cpu(env));
|
2003-03-31 01:02:40 +04:00
|
|
|
int trapnr;
|
2007-10-14 20:27:31 +04:00
|
|
|
abi_ulong pc;
|
2009-10-02 01:12:16 +04:00
|
|
|
target_siginfo_t info;
|
2003-03-29 19:53:14 +03:00
|
|
|
|
2003-03-22 20:31:38 +03:00
|
|
|
for(;;) {
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_x86_exec(cs);
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_end(cs);
|
2003-03-31 01:02:40 +04:00
|
|
|
switch(trapnr) {
|
2003-05-28 03:28:08 +04:00
|
|
|
case 0x80:
|
2007-11-14 21:08:56 +03:00
|
|
|
/* linux syscall from int $0x80 */
|
2007-09-17 01:08:06 +04:00
|
|
|
env->regs[R_EAX] = do_syscall(env,
|
|
|
|
env->regs[R_EAX],
|
2003-05-28 03:28:08 +04:00
|
|
|
env->regs[R_EBX],
|
|
|
|
env->regs[R_ECX],
|
|
|
|
env->regs[R_EDX],
|
|
|
|
env->regs[R_ESI],
|
|
|
|
env->regs[R_EDI],
|
2011-06-16 20:37:13 +04:00
|
|
|
env->regs[R_EBP],
|
|
|
|
0, 0);
|
2003-05-28 03:28:08 +04:00
|
|
|
break;
|
2007-11-14 21:08:56 +03:00
|
|
|
#ifndef TARGET_ABI32
|
|
|
|
case EXCP_SYSCALL:
|
2011-05-08 00:20:03 +04:00
|
|
|
/* linux syscall from syscall instruction */
|
2007-11-14 21:08:56 +03: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 20:37:13 +04:00
|
|
|
env->regs[9],
|
|
|
|
0, 0);
|
2007-11-14 21:08:56 +03:00
|
|
|
break;
|
|
|
|
#endif
|
2003-05-28 03:28:08 +04:00
|
|
|
case EXCP0B_NOSEG:
|
|
|
|
case EXCP0C_STACK:
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGBUS;
|
2003-05-28 03:28:08 +04:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SI_KERNEL;
|
|
|
|
info._sifields._sigfault._addr = 0;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-05-28 03:28:08 +04:00
|
|
|
break;
|
2003-03-22 20:31:38 +03:00
|
|
|
case EXCP0D_GPF:
|
2007-11-14 21:08:56 +03:00
|
|
|
/* XXX: potential problem if ABI32 */
|
2007-04-06 12:56:50 +04:00
|
|
|
#ifndef TARGET_X86_64
|
2003-03-29 19:53:14 +03:00
|
|
|
if (env->eflags & VM_MASK) {
|
2003-05-10 16:33:15 +04:00
|
|
|
handle_vm86_fault(env);
|
2007-04-06 12:56:50 +04:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2003-05-28 03:28:08 +04:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SI_KERNEL;
|
|
|
|
info._sifields._sigfault._addr = 0;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-03-22 20:31:38 +03:00
|
|
|
}
|
|
|
|
break;
|
2003-05-08 19:33:33 +04:00
|
|
|
case EXCP0E_PAGE:
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2003-05-08 19:33:33 +04:00
|
|
|
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 17:13:25 +04:00
|
|
|
info._sifields._sigfault._addr = env->cr[2];
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-05-08 19:33:33 +04:00
|
|
|
break;
|
2003-03-23 19:49:39 +03:00
|
|
|
case EXCP00_DIVZ:
|
2007-04-06 12:56:50 +04:00
|
|
|
#ifndef TARGET_X86_64
|
2003-03-31 01:02:40 +04:00
|
|
|
if (env->eflags & VM_MASK) {
|
2003-05-10 19:10:36 +04:00
|
|
|
handle_vm86_trap(env, trapnr);
|
2007-04-06 12:56:50 +04:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2003-03-31 01:02:40 +04:00
|
|
|
/* division by zero */
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGFPE;
|
2003-03-31 01:02:40 +04:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_FPE_INTDIV;
|
|
|
|
info._sifields._sigfault._addr = env->eip;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-03-31 01:02:40 +04:00
|
|
|
}
|
2003-03-23 19:49:39 +03:00
|
|
|
break;
|
2008-11-19 00:08:15 +03:00
|
|
|
case EXCP01_DB:
|
2003-05-10 19:10:36 +04:00
|
|
|
case EXCP03_INT3:
|
2007-04-06 12:56:50 +04:00
|
|
|
#ifndef TARGET_X86_64
|
2003-05-10 19:10:36 +04:00
|
|
|
if (env->eflags & VM_MASK) {
|
|
|
|
handle_vm86_trap(env, trapnr);
|
2007-04-06 12:56:50 +04:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGTRAP;
|
2003-05-10 19:10:36 +04:00
|
|
|
info.si_errno = 0;
|
2008-11-19 00:08:15 +03:00
|
|
|
if (trapnr == EXCP01_DB) {
|
2003-05-10 19:10:36 +04: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 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-05-10 19:10:36 +04:00
|
|
|
}
|
|
|
|
break;
|
2003-03-23 19:49:39 +03:00
|
|
|
case EXCP04_INTO:
|
|
|
|
case EXCP05_BOUND:
|
2007-04-06 12:56:50 +04:00
|
|
|
#ifndef TARGET_X86_64
|
2003-03-31 01:02:40 +04:00
|
|
|
if (env->eflags & VM_MASK) {
|
2003-05-10 19:10:36 +04:00
|
|
|
handle_vm86_trap(env, trapnr);
|
2007-04-06 12:56:50 +04:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2003-03-31 01:02:40 +04:00
|
|
|
info.si_errno = 0;
|
2003-05-08 19:33:33 +04:00
|
|
|
info.si_code = TARGET_SI_KERNEL;
|
2003-03-31 01:02:40 +04:00
|
|
|
info._sifields._sigfault._addr = 0;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-03-31 01:02:40 +04:00
|
|
|
}
|
2003-03-23 19:49:39 +03:00
|
|
|
break;
|
|
|
|
case EXCP06_ILLOP:
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
2003-03-23 19:49:39 +03:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLOPN;
|
|
|
|
info._sifields._sigfault._addr = env->eip;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-03-23 19:49:39 +03:00
|
|
|
break;
|
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2005-04-17 23:16:13 +04:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2005-04-17 23:16:13 +04:00
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-04-17 23:16:13 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2003-03-22 20:31:38 +03:00
|
|
|
default:
|
2003-06-21 17:13:25 +04:00
|
|
|
pc = env->segs[R_CS].base + env->eip;
|
2007-09-17 01:08:06 +04:00
|
|
|
fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n",
|
2003-03-31 01:02:40 +04:00
|
|
|
(long)pc, trapnr);
|
2003-03-22 20:31:38 +03:00
|
|
|
abort();
|
|
|
|
}
|
2003-03-23 04:06:05 +03:00
|
|
|
process_pending_signals(env);
|
2003-03-22 20:31:38 +03:00
|
|
|
}
|
|
|
|
}
|
2003-06-16 00:05:50 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef TARGET_ARM
|
|
|
|
|
2012-03-30 21:02:50 +04:00
|
|
|
#define get_user_code_u32(x, gaddr, doswap) \
|
|
|
|
({ abi_long __r = get_user_u32((x), (gaddr)); \
|
|
|
|
if (!__r && (doswap)) { \
|
|
|
|
(x) = bswap32(x); \
|
|
|
|
} \
|
|
|
|
__r; \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define get_user_code_u16(x, gaddr, doswap) \
|
|
|
|
({ abi_long __r = get_user_u16((x), (gaddr)); \
|
|
|
|
if (!__r && (doswap)) { \
|
|
|
|
(x) = bswap16(x); \
|
|
|
|
} \
|
|
|
|
__r; \
|
|
|
|
})
|
|
|
|
|
2013-09-03 23:12:13 +04:00
|
|
|
#ifdef TARGET_ABI32
|
|
|
|
/* Commpage handling -- there is no commpage for AArch64 */
|
|
|
|
|
2011-08-31 20:24:34 +04:00
|
|
|
/*
|
|
|
|
* See the Linux kernel's Documentation/arm/kernel_user_helpers.txt
|
|
|
|
* Input:
|
|
|
|
* r0 = pointer to oldval
|
|
|
|
* r1 = pointer to newval
|
|
|
|
* r2 = pointer to target value
|
|
|
|
*
|
|
|
|
* Output:
|
|
|
|
* r0 = 0 if *ptr was changed, non-0 if no exchange happened
|
|
|
|
* C set if *ptr was changed, clear if no exchange happened
|
|
|
|
*
|
|
|
|
* Note segv's in kernel helpers are a bit tricky, we can set the
|
|
|
|
* data address sensibly but the PC address is just the entry point.
|
|
|
|
*/
|
|
|
|
static void arm_kernel_cmpxchg64_helper(CPUARMState *env)
|
|
|
|
{
|
|
|
|
uint64_t oldval, newval, val;
|
|
|
|
uint32_t addr, cpsr;
|
|
|
|
target_siginfo_t info;
|
|
|
|
|
|
|
|
/* Based on the 32 bit code in do_kernel_trap */
|
|
|
|
|
|
|
|
/* 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();
|
|
|
|
cpsr = cpsr_read(env);
|
|
|
|
addr = env->regs[2];
|
|
|
|
|
|
|
|
if (get_user_u64(oldval, env->regs[0])) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = env->regs[0];
|
2011-08-31 20:24:34 +04:00
|
|
|
goto segv;
|
|
|
|
};
|
|
|
|
|
|
|
|
if (get_user_u64(newval, env->regs[1])) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = env->regs[1];
|
2011-08-31 20:24:34 +04:00
|
|
|
goto segv;
|
|
|
|
};
|
|
|
|
|
|
|
|
if (get_user_u64(val, addr)) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = addr;
|
2011-08-31 20:24:34 +04:00
|
|
|
goto segv;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (val == oldval) {
|
|
|
|
val = newval;
|
|
|
|
|
|
|
|
if (put_user_u64(val, addr)) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = addr;
|
2011-08-31 20:24:34 +04:00
|
|
|
goto segv;
|
|
|
|
};
|
|
|
|
|
|
|
|
env->regs[0] = 0;
|
|
|
|
cpsr |= CPSR_C;
|
|
|
|
} else {
|
|
|
|
env->regs[0] = -1;
|
|
|
|
cpsr &= ~CPSR_C;
|
|
|
|
}
|
|
|
|
cpsr_write(env, cpsr, CPSR_C);
|
|
|
|
end_exclusive();
|
|
|
|
return;
|
|
|
|
|
|
|
|
segv:
|
|
|
|
end_exclusive();
|
|
|
|
/* We get the PC of the entry address - which is as good as anything,
|
|
|
|
on a real kernel what you get depends on which mode it uses. */
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2011-08-31 20:24:34 +04:00
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
info._sifields._sigfault._addr = env->exception.vaddress;
|
2011-08-31 20:24:34 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
|
2008-05-29 04:20:44 +04: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-08 00:50:51 +04: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 04:20:44 +04: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-08 00:50:51 +04:00
|
|
|
end_exclusive();
|
2008-05-29 04:20:44 +04:00
|
|
|
break;
|
|
|
|
case 0xffff0fe0: /* __kernel_get_tls */
|
2015-03-16 15:30:47 +03:00
|
|
|
env->regs[0] = cpu_get_tls(env);
|
2008-05-29 04:20:44 +04:00
|
|
|
break;
|
2011-08-31 20:24:34 +04:00
|
|
|
case 0xffff0f60: /* __kernel_cmpxchg64 */
|
|
|
|
arm_kernel_cmpxchg64_helper(env);
|
|
|
|
break;
|
|
|
|
|
2008-05-29 04:20:44 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-01-05 02:15:47 +04:00
|
|
|
/* Store exclusive handling for AArch32 */
|
2009-11-23 00:35:13 +03:00
|
|
|
static int do_strex(CPUARMState *env)
|
|
|
|
{
|
2014-01-05 02:15:47 +04:00
|
|
|
uint64_t val;
|
2009-11-23 00:35:13 +03:00
|
|
|
int size;
|
|
|
|
int rc = 1;
|
|
|
|
int segv = 0;
|
|
|
|
uint32_t addr;
|
|
|
|
start_exclusive();
|
2014-01-05 02:15:47 +04:00
|
|
|
if (env->exclusive_addr != env->exclusive_test) {
|
2009-11-23 00:35:13 +03:00
|
|
|
goto fail;
|
|
|
|
}
|
2014-01-05 02:15:47 +04:00
|
|
|
/* We know we're always AArch32 so the address is in uint32_t range
|
|
|
|
* unless it was the -1 exclusive-monitor-lost value (which won't
|
|
|
|
* match exclusive_test above).
|
|
|
|
*/
|
|
|
|
assert(extract64(env->exclusive_addr, 32, 32) == 0);
|
|
|
|
addr = env->exclusive_addr;
|
2009-11-23 00:35:13 +03:00
|
|
|
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 02:17:12 +03:00
|
|
|
default:
|
|
|
|
abort();
|
2009-11-23 00:35:13 +03:00
|
|
|
}
|
|
|
|
if (segv) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = addr;
|
2009-11-23 00:35:13 +03:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (size == 3) {
|
2014-01-05 02:15:47 +04:00
|
|
|
uint32_t valhi;
|
|
|
|
segv = get_user_u32(valhi, addr + 4);
|
2009-11-23 00:35:13 +03:00
|
|
|
if (segv) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = addr + 4;
|
2009-11-23 00:35:13 +03:00
|
|
|
goto done;
|
|
|
|
}
|
2014-01-05 02:15:47 +04:00
|
|
|
val = deposit64(val, 32, 32, valhi);
|
2009-11-23 00:35:13 +03:00
|
|
|
}
|
2014-01-05 02:15:47 +04:00
|
|
|
if (val != env->exclusive_val) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2009-11-23 00:35:13 +03:00
|
|
|
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) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = addr;
|
2009-11-23 00:35:13 +03:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (size == 3) {
|
|
|
|
val = env->regs[(env->exclusive_info >> 12) & 0xf];
|
2010-12-07 18:37:34 +03:00
|
|
|
segv = put_user_u32(val, addr + 4);
|
2009-11-23 00:35:13 +03:00
|
|
|
if (segv) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = addr + 4;
|
2009-11-23 00:35:13 +03:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rc = 0;
|
|
|
|
fail:
|
2009-12-11 18:38:10 +03:00
|
|
|
env->regs[15] += 4;
|
2009-11-23 00:35:13 +03:00
|
|
|
env->regs[(env->exclusive_info >> 4) & 0xf] = rc;
|
|
|
|
done:
|
|
|
|
end_exclusive();
|
|
|
|
return segv;
|
|
|
|
}
|
|
|
|
|
2003-06-16 00:05:50 +04:00
|
|
|
void cpu_loop(CPUARMState *env)
|
|
|
|
{
|
2012-12-17 10:34:52 +04:00
|
|
|
CPUState *cs = CPU(arm_env_get_cpu(env));
|
2003-06-16 00:05:50 +04:00
|
|
|
int trapnr;
|
|
|
|
unsigned int n, insn;
|
2009-10-02 01:12:16 +04:00
|
|
|
target_siginfo_t info;
|
2005-11-26 13:38:39 +03:00
|
|
|
uint32_t addr;
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2003-06-16 00:05:50 +04:00
|
|
|
for(;;) {
|
2012-12-17 10:34:52 +04:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_arm_exec(cs);
|
2012-12-17 10:34:52 +04:00
|
|
|
cpu_exec_end(cs);
|
2003-06-16 00:05:50 +04:00
|
|
|
switch(trapnr) {
|
|
|
|
case EXCP_UDEF:
|
2004-02-17 00:49:03 +03:00
|
|
|
{
|
2013-08-26 20:14:44 +04:00
|
|
|
TaskState *ts = cs->opaque;
|
2004-02-17 00:49:03 +03:00
|
|
|
uint32_t opcode;
|
2008-04-08 00:30:53 +04:00
|
|
|
int rc;
|
2004-02-17 00:49:03 +03:00
|
|
|
|
|
|
|
/* we handle the FPU emulation here, as Linux */
|
|
|
|
/* we get the opcode */
|
2007-11-16 13:46:05 +03:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
2012-03-30 21:02:50 +04:00
|
|
|
get_user_code_u32(opcode, env->regs[15], env->bswap_code);
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2008-04-08 00:30:53 +04:00
|
|
|
rc = EmulateAll(opcode, &ts->fpa, env);
|
|
|
|
if (rc == 0) { /* illegal instruction */
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
2004-02-17 00:49:03 +03:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLOPN;
|
|
|
|
info._sifields._sigfault._addr = env->regs[15];
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2008-04-08 00:30:53 +04: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? */
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGFPE;
|
2008-04-08 00:30:53 +04:00
|
|
|
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 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2008-04-08 00:30:53 +04: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-17 00:49:03 +03:00
|
|
|
/* increment PC */
|
|
|
|
env->regs[15] += 4;
|
|
|
|
}
|
|
|
|
}
|
2003-06-16 00:05:50 +04:00
|
|
|
break;
|
|
|
|
case EXCP_SWI:
|
2006-02-04 22:35:26 +03:00
|
|
|
case EXCP_BKPT:
|
2003-06-16 00:05:50 +04:00
|
|
|
{
|
2006-02-09 19:49:55 +03:00
|
|
|
env->eabi = 1;
|
2003-06-16 00:05:50 +04:00
|
|
|
/* system call */
|
2006-02-04 22:35:26 +03:00
|
|
|
if (trapnr == EXCP_BKPT) {
|
|
|
|
if (env->thumb) {
|
2007-11-16 13:46:05 +03:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
2012-03-30 21:02:50 +04:00
|
|
|
get_user_code_u16(insn, env->regs[15], env->bswap_code);
|
2006-02-04 22:35:26 +03:00
|
|
|
n = insn & 0xff;
|
|
|
|
env->regs[15] += 2;
|
|
|
|
} else {
|
2007-11-16 13:46:05 +03:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
2012-03-30 21:02:50 +04:00
|
|
|
get_user_code_u32(insn, env->regs[15], env->bswap_code);
|
2006-02-04 22:35:26 +03:00
|
|
|
n = (insn & 0xf) | ((insn >> 4) & 0xff0);
|
|
|
|
env->regs[15] += 4;
|
|
|
|
}
|
2005-04-28 00:11:21 +04:00
|
|
|
} else {
|
2006-02-04 22:35:26 +03:00
|
|
|
if (env->thumb) {
|
2007-11-16 13:46:05 +03:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
2012-03-30 21:02:50 +04:00
|
|
|
get_user_code_u16(insn, env->regs[15] - 2,
|
|
|
|
env->bswap_code);
|
2006-02-04 22:35:26 +03:00
|
|
|
n = insn & 0xff;
|
|
|
|
} else {
|
2007-11-16 13:46:05 +03:00
|
|
|
/* FIXME - what to do if get_user() fails? */
|
2012-03-30 21:02:50 +04:00
|
|
|
get_user_code_u32(insn, env->regs[15] - 4,
|
|
|
|
env->bswap_code);
|
2006-02-04 22:35:26 +03:00
|
|
|
n = insn & 0xffffff;
|
|
|
|
}
|
2005-04-28 00:11:21 +04:00
|
|
|
}
|
|
|
|
|
2004-04-25 22:00:45 +04:00
|
|
|
if (n == ARM_NR_cacheflush) {
|
2011-05-14 15:55:30 +04:00
|
|
|
/* nop */
|
2005-04-23 22:25:41 +04:00
|
|
|
} else if (n == ARM_NR_semihosting
|
|
|
|
|| n == ARM_NR_thumb_semihosting) {
|
|
|
|
env->regs[0] = do_arm_semihosting (env);
|
2012-05-29 09:30:26 +04:00
|
|
|
} else if (n == 0 || n >= ARM_SYSCALL_BASE || env->thumb) {
|
2003-06-16 00:05:50 +04:00
|
|
|
/* linux syscall */
|
2006-02-09 19:49:55 +03:00
|
|
|
if (env->thumb || n == 0) {
|
2005-04-28 00:11:21 +04:00
|
|
|
n = env->regs[7];
|
|
|
|
} else {
|
|
|
|
n -= ARM_SYSCALL_BASE;
|
2006-02-09 19:49:55 +03:00
|
|
|
env->eabi = 0;
|
2005-04-28 00:11:21 +04:00
|
|
|
}
|
2008-05-29 04:20:44 +04:00
|
|
|
if ( n > ARM_NR_BASE) {
|
|
|
|
switch (n) {
|
|
|
|
case ARM_NR_cacheflush:
|
2011-05-14 15:55:30 +04:00
|
|
|
/* nop */
|
2008-05-29 04:20:44 +04:00
|
|
|
break;
|
|
|
|
case ARM_NR_set_tls:
|
|
|
|
cpu_set_tls(env, env->regs[0]);
|
|
|
|
env->regs[0] = 0;
|
|
|
|
break;
|
2014-06-20 15:13:14 +04:00
|
|
|
case ARM_NR_breakpoint:
|
|
|
|
env->regs[15] -= env->thumb ? 2 : 4;
|
|
|
|
goto excp_debug;
|
2008-05-29 04:20:44 +04:00
|
|
|
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 20:37:13 +04:00
|
|
|
env->regs[5],
|
|
|
|
0, 0);
|
2008-05-29 04:20:44 +04:00
|
|
|
}
|
2003-06-16 00:05:50 +04:00
|
|
|
} else {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2003-07-09 23:31:39 +04:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
case EXCP_STREX:
|
|
|
|
if (!do_strex(env)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fall through for segv */
|
2005-02-08 02:12:27 +03:00
|
|
|
case EXCP_PREFETCH_ABORT:
|
|
|
|
case EXCP_DATA_ABORT:
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
addr = env->exception.vaddress;
|
2005-02-08 02:12:27 +03:00
|
|
|
{
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2005-02-08 02:12:27 +03:00
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
2005-11-26 13:38:39 +03:00
|
|
|
info._sifields._sigfault._addr = addr;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-02-08 02:12:27 +03:00
|
|
|
}
|
|
|
|
break;
|
2005-04-17 23:16:13 +04:00
|
|
|
case EXCP_DEBUG:
|
2014-06-20 15:13:14 +04:00
|
|
|
excp_debug:
|
2005-04-17 23:16:13 +04:00
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2005-04-17 23:16:13 +04:00
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-04-17 23:16:13 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2008-05-29 04:20:44 +04:00
|
|
|
case EXCP_KERNEL_TRAP:
|
|
|
|
if (do_kernel_trap(env))
|
|
|
|
goto error;
|
|
|
|
break;
|
2003-06-16 00:05:50 +04:00
|
|
|
default:
|
|
|
|
error:
|
2007-09-17 01:08:06 +04:00
|
|
|
fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
|
2003-06-16 00:05:50 +04:00
|
|
|
trapnr);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2003-06-16 00:05:50 +04:00
|
|
|
abort();
|
|
|
|
}
|
|
|
|
process_pending_signals(env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-03 23:12:13 +04:00
|
|
|
#else
|
|
|
|
|
2014-01-05 02:15:47 +04:00
|
|
|
/*
|
|
|
|
* Handle AArch64 store-release exclusive
|
|
|
|
*
|
|
|
|
* rs = gets the status result of store exclusive
|
|
|
|
* rt = is the register that is stored
|
|
|
|
* rt2 = is the second register store (in STP)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int do_strex_a64(CPUARMState *env)
|
|
|
|
{
|
|
|
|
uint64_t val;
|
|
|
|
int size;
|
|
|
|
bool is_pair;
|
|
|
|
int rc = 1;
|
|
|
|
int segv = 0;
|
|
|
|
uint64_t addr;
|
|
|
|
int rs, rt, rt2;
|
|
|
|
|
|
|
|
start_exclusive();
|
|
|
|
/* size | is_pair << 2 | (rs << 4) | (rt << 9) | (rt2 << 14)); */
|
|
|
|
size = extract32(env->exclusive_info, 0, 2);
|
|
|
|
is_pair = extract32(env->exclusive_info, 2, 1);
|
|
|
|
rs = extract32(env->exclusive_info, 4, 5);
|
|
|
|
rt = extract32(env->exclusive_info, 9, 5);
|
|
|
|
rt2 = extract32(env->exclusive_info, 14, 5);
|
|
|
|
|
|
|
|
addr = env->exclusive_addr;
|
|
|
|
|
|
|
|
if (addr != env->exclusive_test) {
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (size) {
|
|
|
|
case 0:
|
|
|
|
segv = get_user_u8(val, addr);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
segv = get_user_u16(val, addr);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
segv = get_user_u32(val, addr);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
segv = get_user_u64(val, addr);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
if (segv) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = addr;
|
2014-01-05 02:15:47 +04:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (val != env->exclusive_val) {
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
if (is_pair) {
|
|
|
|
if (size == 2) {
|
|
|
|
segv = get_user_u32(val, addr + 4);
|
|
|
|
} else {
|
|
|
|
segv = get_user_u64(val, addr + 8);
|
|
|
|
}
|
|
|
|
if (segv) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = addr + (size == 2 ? 4 : 8);
|
2014-01-05 02:15:47 +04:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (val != env->exclusive_high) {
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
}
|
2014-02-20 14:35:56 +04:00
|
|
|
/* handle the zero register */
|
|
|
|
val = rt == 31 ? 0 : env->xregs[rt];
|
2014-01-05 02:15:47 +04:00
|
|
|
switch (size) {
|
|
|
|
case 0:
|
|
|
|
segv = put_user_u8(val, addr);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
segv = put_user_u16(val, addr);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
segv = put_user_u32(val, addr);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
segv = put_user_u64(val, addr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (segv) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (is_pair) {
|
2014-02-20 14:35:56 +04:00
|
|
|
/* handle the zero register */
|
|
|
|
val = rt2 == 31 ? 0 : env->xregs[rt2];
|
2014-01-05 02:15:47 +04:00
|
|
|
if (size == 2) {
|
|
|
|
segv = put_user_u32(val, addr + 4);
|
|
|
|
} else {
|
|
|
|
segv = put_user_u64(val, addr + 8);
|
|
|
|
}
|
|
|
|
if (segv) {
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
env->exception.vaddress = addr + (size == 2 ? 4 : 8);
|
2014-01-05 02:15:47 +04:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rc = 0;
|
|
|
|
finish:
|
|
|
|
env->pc += 4;
|
|
|
|
/* rs == 31 encodes a write to the ZR, thus throwing away
|
|
|
|
* the status return. This is rather silly but valid.
|
|
|
|
*/
|
|
|
|
if (rs < 31) {
|
|
|
|
env->xregs[rs] = rc;
|
|
|
|
}
|
|
|
|
error:
|
|
|
|
/* instruction faulted, PC does not advance */
|
|
|
|
/* either way a strex releases any exclusive lock we have */
|
|
|
|
env->exclusive_addr = -1;
|
|
|
|
end_exclusive();
|
|
|
|
return segv;
|
|
|
|
}
|
|
|
|
|
2013-09-03 23:12:13 +04:00
|
|
|
/* AArch64 main loop */
|
|
|
|
void cpu_loop(CPUARMState *env)
|
|
|
|
{
|
|
|
|
CPUState *cs = CPU(arm_env_get_cpu(env));
|
|
|
|
int trapnr, sig;
|
|
|
|
target_siginfo_t info;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_arm_exec(cs);
|
2013-09-03 23:12:13 +04:00
|
|
|
cpu_exec_end(cs);
|
|
|
|
|
|
|
|
switch (trapnr) {
|
|
|
|
case EXCP_SWI:
|
|
|
|
env->xregs[0] = do_syscall(env,
|
|
|
|
env->xregs[8],
|
|
|
|
env->xregs[0],
|
|
|
|
env->xregs[1],
|
|
|
|
env->xregs[2],
|
|
|
|
env->xregs[3],
|
|
|
|
env->xregs[4],
|
|
|
|
env->xregs[5],
|
|
|
|
0, 0);
|
|
|
|
break;
|
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
|
|
|
case EXCP_UDEF:
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
2013-09-03 23:12:13 +04:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLOPN;
|
|
|
|
info._sifields._sigfault._addr = env->pc;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
target-arm: Define exception record for AArch64 exceptions
For AArch32 exceptions, the only information provided about
the cause of an exception is the individual exception type (data
abort, undef, etc), which we store in cs->exception_index. For
AArch64, the CPU provides much more detail about the cause of
the exception, which can be found in the syndrome register.
Create a set of fields in CPUARMState which must be filled in
whenever an exception is raised, so that exception entry can
correctly fill in the syndrome register for the guest.
This includes the information which in AArch32 appears in
the DFAR and IFAR (fault address registers) and the DFSR
and IFSR (fault status registers) for data aborts and
prefetch aborts, since if we end up taking the MMU fault
to AArch64 rather than AArch32 this will need to end up
in different system registers.
This patch does a refactoring which moves the setting of the
AArch32 DFAR/DFSR/IFAR/IFSR from the point where the exception
is raised to the point where it is taken. (This is no change
for cores with an MMU, retains the existing clearly incorrect
behaviour for ARM946 of trashing the MP access permissions
registers which share the c5_data and c5_insn state fields,
and has no effect for v7M because we don't implement its
MPU fault status or address registers.)
As a side effect of the cleanup we fix a bug in the AArch64
linux-user mode code where we were passing a 64 bit fault
address through the 32 bit c6_data/c6_insn fields: it now
goes via the always-64-bit exception.vaddress.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
2014-04-15 22:18:38 +04:00
|
|
|
case EXCP_STREX:
|
|
|
|
if (!do_strex_a64(env)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fall through for segv */
|
2013-09-03 23:12:13 +04:00
|
|
|
case EXCP_PREFETCH_ABORT:
|
|
|
|
case EXCP_DATA_ABORT:
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2013-09-03 23:12:13 +04:00
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
2014-10-23 12:27:40 +04:00
|
|
|
info._sifields._sigfault._addr = env->exception.vaddress;
|
2013-09-03 23:12:13 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
|
|
|
case EXCP_DEBUG:
|
|
|
|
case EXCP_BKPT:
|
|
|
|
sig = gdb_handlesig(cs, 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;
|
2015-09-07 12:39:28 +03:00
|
|
|
case EXCP_SEMIHOST:
|
|
|
|
env->xregs[0] = do_arm_semihosting(env);
|
|
|
|
break;
|
2013-09-03 23:12:13 +04:00
|
|
|
default:
|
|
|
|
fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
|
|
|
|
trapnr);
|
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
process_pending_signals(env);
|
2014-01-05 02:15:47 +04:00
|
|
|
/* Exception return on AArch64 always clears the exclusive monitor,
|
|
|
|
* so any return to running guest code implies this.
|
|
|
|
* A strex (successful or otherwise) also clears the monitor, so
|
|
|
|
* we don't need to specialcase EXCP_STREX.
|
|
|
|
*/
|
|
|
|
env->exclusive_addr = -1;
|
2013-09-03 23:12:13 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* ndef TARGET_ABI32 */
|
|
|
|
|
2003-06-16 00:05:50 +04:00
|
|
|
#endif
|
2003-03-22 20:31:38 +03:00
|
|
|
|
2011-04-12 12:27:03 +04:00
|
|
|
#ifdef TARGET_UNICORE32
|
|
|
|
|
2012-02-25 06:37:53 +04:00
|
|
|
void cpu_loop(CPUUniCore32State *env)
|
2011-04-12 12:27:03 +04:00
|
|
|
{
|
2012-12-17 10:34:52 +04:00
|
|
|
CPUState *cs = CPU(uc32_env_get_cpu(env));
|
2011-04-12 12:27:03 +04:00
|
|
|
int trapnr;
|
|
|
|
unsigned int n, insn;
|
|
|
|
target_siginfo_t info;
|
|
|
|
|
|
|
|
for (;;) {
|
2012-12-17 10:34:52 +04:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = uc32_cpu_exec(cs);
|
2012-12-17 10:34:52 +04:00
|
|
|
cpu_exec_end(cs);
|
2011-04-12 12:27:03 +04:00
|
|
|
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 20:37:13 +04:00
|
|
|
env->regs[5],
|
|
|
|
0, 0);
|
2011-04-12 12:27:03 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2012-08-10 10:42:23 +04:00
|
|
|
case UC32_EXCP_DTRAP:
|
|
|
|
case UC32_EXCP_ITRAP:
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2011-04-12 12:27:03 +04:00
|
|
|
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;
|
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2011-04-12 12:27:03 +04:00
|
|
|
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);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2011-04-12 12:27:03 +04:00
|
|
|
abort();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2003-10-01 00:57:29 +04:00
|
|
|
#ifdef TARGET_SPARC
|
2008-08-30 13:20:21 +04:00
|
|
|
#define SPARC64_STACK_BIAS 2047
|
2003-10-01 00:57:29 +04:00
|
|
|
|
2004-01-04 18:50:01 +03:00
|
|
|
//#define DEBUG_WIN
|
|
|
|
|
2005-02-19 20:25:31 +03:00
|
|
|
/* WARNING: dealing with register windows _is_ complicated. More info
|
|
|
|
can be found at http://www.sics.se/~psm/sparcstack.html */
|
2004-01-04 18:50:01 +03:00
|
|
|
static inline int get_reg_index(CPUSPARCState *env, int cwp, int index)
|
|
|
|
{
|
2008-06-07 12:07:37 +04:00
|
|
|
index = (index + cwp * 16) % (16 * env->nwindows);
|
2004-01-04 18:50:01 +03:00
|
|
|
/* wrap handling : if cwp is on the last window, then we use the
|
|
|
|
registers 'after' the end */
|
2008-06-07 12:07:37 +04:00
|
|
|
if (index < 8 && env->cwp == env->nwindows - 1)
|
|
|
|
index += 16 * env->nwindows;
|
2004-01-04 18:50:01 +03:00
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
2005-02-19 20:25:31 +03:00
|
|
|
/* save the register window 'cwp1' */
|
|
|
|
static inline void save_window_offset(CPUSPARCState *env, int cwp1)
|
2004-01-04 18:50:01 +03:00
|
|
|
{
|
2005-02-19 20:25:31 +03:00
|
|
|
unsigned int i;
|
2007-10-14 20:27:31 +04:00
|
|
|
abi_ulong sp_ptr;
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2006-03-25 22:31:22 +03:00
|
|
|
sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
|
2008-08-30 13:20:21 +04:00
|
|
|
#ifdef TARGET_SPARC64
|
|
|
|
if (sp_ptr & 3)
|
|
|
|
sp_ptr += SPARC64_STACK_BIAS;
|
|
|
|
#endif
|
2004-01-04 18:50:01 +03:00
|
|
|
#if defined(DEBUG_WIN)
|
2008-06-15 22:02:48 +04:00
|
|
|
printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n",
|
|
|
|
sp_ptr, cwp1);
|
2004-01-04 18:50:01 +03:00
|
|
|
#endif
|
2005-02-19 20:25:31 +03:00
|
|
|
for(i = 0; i < 16; i++) {
|
2007-11-16 13:46:05 +03: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 20:27:31 +04:00
|
|
|
sp_ptr += sizeof(abi_ulong);
|
2005-02-19 20:25:31 +03:00
|
|
|
}
|
2004-01-04 18:50:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void save_window(CPUSPARCState *env)
|
|
|
|
{
|
2006-07-19 01:14:09 +04:00
|
|
|
#ifndef TARGET_SPARC64
|
2005-02-19 20:25:31 +03:00
|
|
|
unsigned int new_wim;
|
2008-06-07 12:07:37 +04: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 20:25:31 +03:00
|
|
|
env->wim = new_wim;
|
2006-07-19 01:14:09 +04:00
|
|
|
#else
|
2008-06-07 12:07:37 +04:00
|
|
|
save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
|
2006-07-19 01:14:09 +04:00
|
|
|
env->cansave++;
|
|
|
|
env->canrestore--;
|
|
|
|
#endif
|
2004-01-04 18:50:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void restore_window(CPUSPARCState *env)
|
|
|
|
{
|
2008-08-27 23:19:44 +04:00
|
|
|
#ifndef TARGET_SPARC64
|
|
|
|
unsigned int new_wim;
|
|
|
|
#endif
|
|
|
|
unsigned int i, cwp1;
|
2007-10-14 20:27:31 +04:00
|
|
|
abi_ulong sp_ptr;
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2008-08-27 23:19:44 +04:00
|
|
|
#ifndef TARGET_SPARC64
|
2008-06-07 12:07:37 +04:00
|
|
|
new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) &
|
|
|
|
((1LL << env->nwindows) - 1);
|
2008-08-27 23:19:44 +04:00
|
|
|
#endif
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2004-01-04 18:50:01 +03:00
|
|
|
/* restore the invalid window */
|
2008-06-07 12:07:37 +04:00
|
|
|
cwp1 = cpu_cwp_inc(env, env->cwp + 1);
|
2006-03-25 22:31:22 +03:00
|
|
|
sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
|
2008-08-30 13:20:21 +04:00
|
|
|
#ifdef TARGET_SPARC64
|
|
|
|
if (sp_ptr & 3)
|
|
|
|
sp_ptr += SPARC64_STACK_BIAS;
|
|
|
|
#endif
|
2004-01-04 18:50:01 +03:00
|
|
|
#if defined(DEBUG_WIN)
|
2008-06-15 22:02:48 +04:00
|
|
|
printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n",
|
|
|
|
sp_ptr, cwp1);
|
2004-01-04 18:50:01 +03:00
|
|
|
#endif
|
2005-02-19 20:25:31 +03:00
|
|
|
for(i = 0; i < 16; i++) {
|
2007-11-16 13:46:05 +03: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 20:27:31 +04:00
|
|
|
sp_ptr += sizeof(abi_ulong);
|
2005-02-19 20:25:31 +03:00
|
|
|
}
|
2006-07-19 01:14:09 +04:00
|
|
|
#ifdef TARGET_SPARC64
|
|
|
|
env->canrestore++;
|
2008-06-07 12:07:37 +04:00
|
|
|
if (env->cleanwin < env->nwindows - 1)
|
|
|
|
env->cleanwin++;
|
2006-07-19 01:14:09 +04:00
|
|
|
env->cansave--;
|
2008-08-27 23:19:44 +04:00
|
|
|
#else
|
|
|
|
env->wim = new_wim;
|
2006-07-19 01:14:09 +04:00
|
|
|
#endif
|
2004-01-04 18:50:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void flush_windows(CPUSPARCState *env)
|
|
|
|
{
|
|
|
|
int offset, cwp1;
|
2005-02-19 20:25:31 +03:00
|
|
|
|
|
|
|
offset = 1;
|
2004-01-04 18:50:01 +03:00
|
|
|
for(;;) {
|
|
|
|
/* if restore would invoke restore_window(), then we can stop */
|
2008-06-07 12:07:37 +04:00
|
|
|
cwp1 = cpu_cwp_inc(env, env->cwp + offset);
|
2008-08-27 23:19:44 +04:00
|
|
|
#ifndef TARGET_SPARC64
|
2004-01-04 18:50:01 +03:00
|
|
|
if (env->wim & (1 << cwp1))
|
|
|
|
break;
|
2008-08-27 23:19:44 +04:00
|
|
|
#else
|
|
|
|
if (env->canrestore == 0)
|
|
|
|
break;
|
|
|
|
env->cansave++;
|
|
|
|
env->canrestore--;
|
|
|
|
#endif
|
2005-02-19 20:25:31 +03:00
|
|
|
save_window_offset(env, cwp1);
|
2004-01-04 18:50:01 +03:00
|
|
|
offset++;
|
|
|
|
}
|
2008-06-07 12:07:37 +04:00
|
|
|
cwp1 = cpu_cwp_inc(env, env->cwp + 1);
|
2008-08-27 23:19:44 +04:00
|
|
|
#ifndef TARGET_SPARC64
|
|
|
|
/* set wim so that restore will reload the registers */
|
2005-02-19 20:25:31 +03:00
|
|
|
env->wim = 1 << cwp1;
|
2008-08-27 23:19:44 +04:00
|
|
|
#endif
|
2005-02-19 20:25:31 +03:00
|
|
|
#if defined(DEBUG_WIN)
|
|
|
|
printf("flush_windows: nb=%d\n", offset - 1);
|
2005-01-04 02:31:27 +03:00
|
|
|
#endif
|
2005-02-19 20:25:31 +03:00
|
|
|
}
|
2004-01-04 18:50:01 +03:00
|
|
|
|
2003-10-01 00:57:29 +04:00
|
|
|
void cpu_loop (CPUSPARCState *env)
|
|
|
|
{
|
2013-05-27 03:33:50 +04:00
|
|
|
CPUState *cs = CPU(sparc_env_get_cpu(env));
|
2010-04-25 22:01:25 +04:00
|
|
|
int trapnr;
|
|
|
|
abi_long ret;
|
2009-10-02 01:12:16 +04:00
|
|
|
target_siginfo_t info;
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2004-01-04 18:50:01 +03:00
|
|
|
while (1) {
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_sparc_exec(cs);
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_end(cs);
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2012-10-10 01:50:00 +04:00
|
|
|
/* Compute PSR before exposing state. */
|
|
|
|
if (env->cc_op != CC_OP_FLAGS) {
|
|
|
|
cpu_get_psr(env);
|
|
|
|
}
|
|
|
|
|
2004-01-04 18:50:01 +03:00
|
|
|
switch (trapnr) {
|
2006-07-19 01:14:09 +04:00
|
|
|
#ifndef TARGET_SPARC64
|
2007-09-17 01:08:06 +04:00
|
|
|
case 0x88:
|
2004-01-04 18:50:01 +03:00
|
|
|
case 0x90:
|
2006-07-19 01:14:09 +04:00
|
|
|
#else
|
2007-10-09 20:34:29 +04:00
|
|
|
case 0x110:
|
2006-07-19 01:14:09 +04:00
|
|
|
case 0x16d:
|
|
|
|
#endif
|
2004-01-04 18:50:01 +03:00
|
|
|
ret = do_syscall (env, env->gregs[1],
|
2007-09-17 01:08:06 +04:00
|
|
|
env->regwptr[0], env->regwptr[1],
|
|
|
|
env->regwptr[2], env->regwptr[3],
|
2011-06-16 20:37:13 +04:00
|
|
|
env->regwptr[4], env->regwptr[5],
|
|
|
|
0, 0);
|
2010-04-25 22:01:25 +04:00
|
|
|
if ((abi_ulong)ret >= (abi_ulong)(-515)) {
|
2007-10-14 20:27:31 +04:00
|
|
|
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
|
2006-10-24 01:31:01 +04:00
|
|
|
env->xcc |= PSR_CARRY;
|
|
|
|
#else
|
2004-01-04 18:50:01 +03:00
|
|
|
env->psr |= PSR_CARRY;
|
2006-10-24 01:31:01 +04:00
|
|
|
#endif
|
2004-01-04 18:50:01 +03:00
|
|
|
ret = -ret;
|
|
|
|
} else {
|
2007-10-14 20:27:31 +04:00
|
|
|
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
|
2006-10-24 01:31:01 +04:00
|
|
|
env->xcc &= ~PSR_CARRY;
|
|
|
|
#else
|
2004-01-04 18:50:01 +03:00
|
|
|
env->psr &= ~PSR_CARRY;
|
2006-10-24 01:31:01 +04:00
|
|
|
#endif
|
2004-01-04 18:50:01 +03:00
|
|
|
}
|
|
|
|
env->regwptr[0] = ret;
|
|
|
|
/* next instruction */
|
|
|
|
env->pc = env->npc;
|
|
|
|
env->npc = env->npc + 4;
|
|
|
|
break;
|
|
|
|
case 0x83: /* flush windows */
|
2007-10-14 20:27:31 +04:00
|
|
|
#ifdef TARGET_ABI32
|
|
|
|
case 0x103:
|
|
|
|
#endif
|
2005-02-19 20:25:31 +03:00
|
|
|
flush_windows(env);
|
2004-01-04 18:50:01 +03:00
|
|
|
/* next instruction */
|
|
|
|
env->pc = env->npc;
|
|
|
|
env->npc = env->npc + 4;
|
|
|
|
break;
|
2005-07-02 18:31:34 +04:00
|
|
|
#ifndef TARGET_SPARC64
|
2004-01-04 18:50:01 +03:00
|
|
|
case TT_WIN_OVF: /* window overflow */
|
|
|
|
save_window(env);
|
|
|
|
break;
|
|
|
|
case TT_WIN_UNF: /* window underflow */
|
|
|
|
restore_window(env);
|
|
|
|
break;
|
2005-02-16 01:54:53 +03:00
|
|
|
case TT_TFAULT:
|
|
|
|
case TT_DFAULT:
|
|
|
|
{
|
2011-10-25 21:34:07 +04:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2005-02-16 01:54:53 +03:00
|
|
|
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 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-02-16 01:54:53 +03:00
|
|
|
}
|
|
|
|
break;
|
2005-07-02 18:31:34 +04:00
|
|
|
#else
|
2006-07-19 01:14:09 +04:00
|
|
|
case TT_SPILL: /* window overflow */
|
|
|
|
save_window(env);
|
|
|
|
break;
|
|
|
|
case TT_FILL: /* window underflow */
|
|
|
|
restore_window(env);
|
|
|
|
break;
|
2007-07-08 00:46:41 +04:00
|
|
|
case TT_TFAULT:
|
|
|
|
case TT_DFAULT:
|
|
|
|
{
|
2011-10-25 21:34:07 +04:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2007-07-08 00:46:41 +04:00
|
|
|
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 23:15:02 +04:00
|
|
|
info._sifields._sigfault._addr = cpu_tsptr(env)->tpc;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-07-08 00:46:41 +04:00
|
|
|
}
|
|
|
|
break;
|
2007-11-11 22:32:52 +03:00
|
|
|
#ifndef TARGET_ABI32
|
2007-10-05 21:01:51 +04:00
|
|
|
case 0x16e:
|
|
|
|
flush_windows(env);
|
|
|
|
sparc64_get_context(env);
|
|
|
|
break;
|
|
|
|
case 0x16f:
|
|
|
|
flush_windows(env);
|
|
|
|
sparc64_set_context(env);
|
|
|
|
break;
|
2007-11-11 22:32:52 +03:00
|
|
|
#endif
|
2005-07-02 18:31:34 +04:00
|
|
|
#endif
|
2006-06-21 22:15:50 +04:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2011-10-25 21:34:06 +04:00
|
|
|
case TT_ILL_INSN:
|
|
|
|
{
|
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLOPC;
|
|
|
|
info._sifields._sigfault._addr = env->pc;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
}
|
|
|
|
break;
|
2005-04-17 23:16:13 +04:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2005-04-17 23:16:13 +04:00
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-04-17 23:16:13 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2004-01-04 18:50:01 +03:00
|
|
|
default:
|
|
|
|
printf ("Unhandled trap: 0x%x\n", trapnr);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2004-01-04 18:50:01 +03:00
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
2003-10-01 00:57:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2003-11-23 20:05:30 +03:00
|
|
|
#ifdef TARGET_PPC
|
2012-02-25 06:37:53 +04:00
|
|
|
static inline uint64_t cpu_ppc_get_tb(CPUPPCState *env)
|
2004-05-21 16:59:32 +04:00
|
|
|
{
|
linux-user, ppc: mftbl can be used by user application
In qemu-linux-user, when calling gethostbyname2(),
it was hanging in .__res_nmkquery.
(gdb) bt
0 in .__res_nmkquery () from /lib64/libresolv.so.2
1 in .__libc_res_nquery () from /lib64/libresolv.so.2
2 in .__libc_res_nsearch () from /lib64/libresolv.so.2
3 in ._nss_dns_gethostbyname3_r () from /lib64/libnss_dns.so.2
4 in ._nss_dns_gethostbyname2_r () from /lib64/libnss_dns.so.2
5 in .gethostbyname2_r () from /lib64/libc.so.6
6 in .gethostbyname2 () from /lib64/libc.so.6
.__res_nmkquery() is:
...
do { RANDOM_BITS (randombits); } while ((randombits & 0xffff) == 0);
...
<.__res_nmkquery+112>: mftbl r11
<.__res_nmkquery+116>: clrlwi r10,r11,16
<.__res_nmkquery+120>: cmpwi cr7,r10,0
<.__res_nmkquery+124>: beq cr7,<.__res_nmkquery+112>
but as mftbl (Move From Time Base Lower) is not implemented,
r11 is always 0, so we have an infinite loop.
This patch fills the Time Base register with cpu_get_real_ticks().
Signed-off-by: Laurent Vivier <laurent@vivier.eu>
Signed-off-by: Alexander Graf <agraf@suse.de>
2015-06-30 12:49:54 +03:00
|
|
|
return cpu_get_real_ticks();
|
2004-05-21 16:59:32 +04:00
|
|
|
}
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2012-02-25 06:37:53 +04:00
|
|
|
uint64_t cpu_ppc_load_tbl(CPUPPCState *env)
|
2004-05-21 16:59:32 +04:00
|
|
|
{
|
2009-12-21 14:24:17 +03:00
|
|
|
return cpu_ppc_get_tb(env);
|
2004-05-21 16:59:32 +04:00
|
|
|
}
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2012-02-25 06:37:53 +04:00
|
|
|
uint32_t cpu_ppc_load_tbu(CPUPPCState *env)
|
2004-05-21 16:59:32 +04:00
|
|
|
{
|
|
|
|
return cpu_ppc_get_tb(env) >> 32;
|
|
|
|
}
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2012-02-25 06:37:53 +04:00
|
|
|
uint64_t cpu_ppc_load_atbl(CPUPPCState *env)
|
2004-05-21 16:59:32 +04:00
|
|
|
{
|
2009-12-21 15:52:08 +03:00
|
|
|
return cpu_ppc_get_tb(env);
|
2004-05-21 16:59:32 +04:00
|
|
|
}
|
2007-09-17 01:08:06 +04:00
|
|
|
|
2012-02-25 06:37:53 +04:00
|
|
|
uint32_t cpu_ppc_load_atbu(CPUPPCState *env)
|
2004-05-21 16:59:32 +04:00
|
|
|
{
|
2007-09-30 04:38:38 +04:00
|
|
|
return cpu_ppc_get_tb(env) >> 32;
|
2004-05-21 16:59:32 +04:00
|
|
|
}
|
2007-03-07 11:32:30 +03:00
|
|
|
|
2012-02-25 06:37:53 +04:00
|
|
|
uint32_t cpu_ppc601_load_rtcu(CPUPPCState *env)
|
2007-03-07 11:32:30 +03:00
|
|
|
__attribute__ (( alias ("cpu_ppc_load_tbu") ));
|
|
|
|
|
2012-02-25 06:37:53 +04:00
|
|
|
uint32_t cpu_ppc601_load_rtcl(CPUPPCState *env)
|
2004-05-21 16:59:32 +04:00
|
|
|
{
|
2007-03-07 11:32:30 +03:00
|
|
|
return cpu_ppc_load_tbl(env) & 0x3FFFFF80;
|
2004-05-21 16:59:32 +04:00
|
|
|
}
|
2007-03-07 11:32:30 +03: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 03:54:22 +04:00
|
|
|
/* XXX: to be fixed */
|
2009-12-21 16:02:39 +03: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 03:54:22 +04:00
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-12-21 16:02:39 +03: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 03:54:22 +04:00
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-05-13 21:53:17 +04:00
|
|
|
#define EXCP_DUMP(env, fmt, ...) \
|
|
|
|
do { \
|
2013-06-16 09:28:50 +04:00
|
|
|
CPUState *cs = ENV_GET_CPU(env); \
|
2009-05-13 21:53:17 +04:00
|
|
|
fprintf(stderr, fmt , ## __VA_ARGS__); \
|
2013-06-16 09:28:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0); \
|
2009-05-13 21:53:17 +04:00
|
|
|
qemu_log(fmt, ## __VA_ARGS__); \
|
2012-06-03 20:35:32 +04:00
|
|
|
if (qemu_log_enabled()) { \
|
2013-06-16 09:28:50 +04:00
|
|
|
log_cpu_state(cs, 0); \
|
2012-06-03 20:35:32 +04:00
|
|
|
} \
|
2007-09-29 17:06:16 +04:00
|
|
|
} while (0)
|
|
|
|
|
2009-08-03 19:43:27 +04:00
|
|
|
static int do_store_exclusive(CPUPPCState *env)
|
|
|
|
{
|
|
|
|
target_ulong addr;
|
|
|
|
target_ulong page_addr;
|
2014-05-29 18:12:20 +04:00
|
|
|
target_ulong val, val2 __attribute__((unused)) = 0;
|
2009-08-03 19:43:27 +04:00
|
|
|
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;
|
2014-05-29 18:12:24 +04:00
|
|
|
int size = env->reserve_info >> 5;
|
2009-08-03 19:43:27 +04:00
|
|
|
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;
|
2014-02-10 21:27:01 +04:00
|
|
|
case 16: {
|
|
|
|
segv = get_user_u64(val, addr);
|
|
|
|
if (!segv) {
|
|
|
|
segv = get_user_u64(val2, addr + 8);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2009-08-03 19:43:27 +04:00
|
|
|
#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;
|
2014-02-10 21:27:01 +04:00
|
|
|
case 16: {
|
|
|
|
if (val2 == env->reserve_val2) {
|
2014-05-29 18:12:20 +04:00
|
|
|
if (msr_le) {
|
|
|
|
val2 = val;
|
|
|
|
val = env->gpr[reg+1];
|
|
|
|
} else {
|
|
|
|
val2 = env->gpr[reg+1];
|
|
|
|
}
|
2014-02-10 21:27:01 +04:00
|
|
|
segv = put_user_u64(val, addr);
|
|
|
|
if (!segv) {
|
|
|
|
segv = put_user_u64(val2, addr + 8);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2009-08-03 19:43:27 +04:00
|
|
|
#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 20:05:30 +03:00
|
|
|
void cpu_loop(CPUPPCState *env)
|
|
|
|
{
|
2012-12-17 10:34:52 +04:00
|
|
|
CPUState *cs = CPU(ppc_env_get_cpu(env));
|
2009-10-02 01:12:16 +04:00
|
|
|
target_siginfo_t info;
|
2004-01-05 02:54:31 +03:00
|
|
|
int trapnr;
|
2011-10-26 20:59:18 +04:00
|
|
|
target_ulong ret;
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2003-11-23 20:05:30 +03:00
|
|
|
for(;;) {
|
2012-12-17 10:34:52 +04:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_ppc_exec(cs);
|
2012-12-17 10:34:52 +04:00
|
|
|
cpu_exec_end(cs);
|
2003-11-23 20:05:30 +03:00
|
|
|
switch(trapnr) {
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_NONE:
|
|
|
|
/* Just go on */
|
2003-11-23 20:05:30 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_CRITICAL: /* Critical input */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Critical interrupt while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
2004-01-05 02:54:31 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_MCHECK: /* Machine check exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Machine check exception while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DSI: /* Data storage exception */
|
2009-08-16 15:13:18 +04:00
|
|
|
EXCP_DUMP(env, "Invalid data memory access: 0x" TARGET_FMT_lx "\n",
|
2007-09-29 17:06:16 +04:00
|
|
|
env->spr[SPR_DAR]);
|
|
|
|
/* XXX: check this. Seems bugged */
|
2005-07-03 02:09:27 +04:00
|
|
|
switch (env->error_code & 0xFF000000) {
|
|
|
|
case 0x40000000:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
break;
|
2005-07-03 02:09:27 +04:00
|
|
|
case 0x04000000:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLADR;
|
|
|
|
break;
|
2005-07-03 02:09:27 +04:00
|
|
|
case 0x08000000:
|
2004-01-05 02:54:31 +03: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 17:06:16 +04:00
|
|
|
EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
|
|
|
|
env->error_code);
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
break;
|
|
|
|
}
|
2003-11-23 20:05:30 +03:00
|
|
|
info._sifields._sigfault._addr = env->nip;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-11-23 20:05:30 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_ISI: /* Instruction storage exception */
|
2009-08-16 15:13:18 +04:00
|
|
|
EXCP_DUMP(env, "Invalid instruction fetch: 0x\n" TARGET_FMT_lx
|
|
|
|
"\n", env->spr[SPR_SRR0]);
|
2007-09-29 17:06:16 +04:00
|
|
|
/* XXX: check this */
|
2005-07-03 02:09:27 +04:00
|
|
|
switch (env->error_code & 0xFF000000) {
|
|
|
|
case 0x40000000:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2003-11-23 20:05:30 +03:00
|
|
|
info.si_errno = 0;
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
break;
|
2005-07-03 02:09:27 +04:00
|
|
|
case 0x10000000:
|
|
|
|
case 0x08000000:
|
2004-01-05 02:54:31 +03: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 17:06:16 +04:00
|
|
|
EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
|
|
|
|
env->error_code);
|
2004-01-05 02:54:31 +03: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 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-11-23 20:05:30 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_EXTERNAL: /* External input */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "External interrupt while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_ALIGN: /* Alignment exception */
|
|
|
|
EXCP_DUMP(env, "Unaligned memory access\n");
|
|
|
|
/* XXX: check this */
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_signo = TARGET_SIGBUS;
|
2003-11-23 20:05:30 +03:00
|
|
|
info.si_errno = 0;
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_BUS_ADRALN;
|
|
|
|
info._sifields._sigfault._addr = env->nip - 4;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-11-23 20:05:30 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_PROGRAM: /* Program exception */
|
|
|
|
/* XXX: check this */
|
2004-01-05 02:54:31 +03:00
|
|
|
switch (env->error_code & ~0xF) {
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_FP:
|
|
|
|
EXCP_DUMP(env, "Floating point program exception\n");
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_signo = TARGET_SIGFPE;
|
|
|
|
info.si_errno = 0;
|
|
|
|
switch (env->error_code & 0xF) {
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_FP_OX:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_FPE_FLTOVF;
|
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_FP_UX:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_FPE_FLTUND;
|
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_FP_ZX:
|
|
|
|
case POWERPC_EXCP_FP_VXZDZ:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_FPE_FLTDIV;
|
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_FP_XX:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_FPE_FLTRES;
|
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_FP_VXSOFT:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_FPE_FLTINV;
|
|
|
|
break;
|
2007-10-27 21:54:30 +04:00
|
|
|
case POWERPC_EXCP_FP_VXSNAN:
|
2007-09-29 17:06:16 +04: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 02:54:31 +03:00
|
|
|
info.si_code = TARGET_FPE_FLTSUB;
|
|
|
|
break;
|
|
|
|
default:
|
2007-09-29 17:06:16 +04:00
|
|
|
EXCP_DUMP(env, "Unknown floating point exception (%02x)\n",
|
|
|
|
env->error_code);
|
|
|
|
break;
|
2004-01-05 02:54:31 +03:00
|
|
|
}
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_INVAL:
|
|
|
|
EXCP_DUMP(env, "Invalid instruction\n");
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
switch (env->error_code & 0xF) {
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_INVAL_INVAL:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_ILL_ILLOPC;
|
|
|
|
break;
|
2007-09-29 17:06:16 +04: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 03:54:22 +04:00
|
|
|
info.si_code = TARGET_ILL_ILLOPN;
|
2004-01-05 02:54:31 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_INVAL_SPR:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_ILL_PRVREG;
|
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_INVAL_FP:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_ILL_COPROC;
|
|
|
|
break;
|
|
|
|
default:
|
2007-09-29 17:06:16 +04:00
|
|
|
EXCP_DUMP(env, "Unknown invalid operation (%02x)\n",
|
|
|
|
env->error_code & 0xF);
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_ILL_ILLADR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_PRIV:
|
|
|
|
EXCP_DUMP(env, "Privilege violation\n");
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
switch (env->error_code & 0xF) {
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_PRIV_OPC:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_ILL_PRVOPC;
|
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_PRIV_REG:
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_ILL_PRVREG;
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
2004-01-05 02:54:31 +03:00
|
|
|
default:
|
2007-09-29 17:06:16 +04:00
|
|
|
EXCP_DUMP(env, "Unknown privilege violation (%02x)\n",
|
|
|
|
env->error_code & 0xF);
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_ILL_PRVOPC;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_TRAP:
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Tried to call a TRAP\n");
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
2004-01-05 02:54:31 +03:00
|
|
|
default:
|
|
|
|
/* Should not happen ! */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Unknown program exception (%02x)\n",
|
2007-09-29 17:06:16 +04:00
|
|
|
env->error_code);
|
|
|
|
break;
|
2004-01-05 02:54:31 +03:00
|
|
|
}
|
|
|
|
info._sifields._sigfault._addr = env->nip - 4;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-11-23 20:05:30 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */
|
|
|
|
EXCP_DUMP(env, "No floating point allowed\n");
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
2003-11-23 20:05:30 +03:00
|
|
|
info.si_errno = 0;
|
2004-01-05 02:54:31 +03:00
|
|
|
info.si_code = TARGET_ILL_COPROC;
|
|
|
|
info._sifields._sigfault._addr = env->nip - 4;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2003-11-23 20:05:30 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_SYSCALL: /* System call exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Syscall exception while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
2004-01-05 02:54:31 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04: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 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2004-01-05 02:54:31 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_DECR: /* Decrementer exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Decrementer interrupt while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
2004-01-05 02:54:31 +03:00
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_FIT: /* Fixed-interval timer interrupt */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Fix interval timer interrupt while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_WDT: /* Watchdog timer interrupt */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Watchdog timer interrupt while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DTLB: /* Data TLB error */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Data TLB exception while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_ITLB: /* Instruction TLB error */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Instruction TLB exception while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"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 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_EFPDI: /* Embedded floating-point data IRQ */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Embedded floating-point data IRQ not handled\n");
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_EFPRI: /* Embedded floating-point round IRQ */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Embedded floating-point round IRQ not handled\n");
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_EPERFM: /* Embedded performance monitor IRQ */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Performance monitor exception not handled\n");
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DOORI: /* Embedded doorbell interrupt */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Doorbell interrupt while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DOORCI: /* Embedded doorbell critical interrupt */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Doorbell critical interrupt while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_RESET: /* System reset exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Reset interrupt while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DSEG: /* Data segment exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Data segment exception while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_ISEG: /* Instruction segment exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Instruction segment exception "
|
2007-09-29 17:06:16 +04:00
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
2007-10-18 23:59:49 +04:00
|
|
|
/* PowerPC 64 with hypervisor mode support */
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_HDECR: /* Hypervisor decrementer exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Hypervisor decrementer interrupt "
|
2007-09-29 17:06:16 +04:00
|
|
|
"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 23:59:49 +04:00
|
|
|
/* PowerPC 64 with hypervisor mode support */
|
2007-09-29 17:06:16 +04:00
|
|
|
case POWERPC_EXCP_HDSI: /* Hypervisor data storage exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Hypervisor data storage exception "
|
2007-09-29 17:06:16 +04:00
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_HISI: /* Hypervisor instruction storage excp */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Hypervisor instruction storage exception "
|
2007-09-29 17:06:16 +04:00
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_HDSEG: /* Hypervisor data segment exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Hypervisor data segment exception "
|
2007-09-29 17:06:16 +04:00
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_HISEG: /* Hypervisor instruction segment excp */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Hypervisor instruction segment exception "
|
2007-09-29 17:06:16 +04:00
|
|
|
"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 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_PIT: /* Programmable interval timer IRQ */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Programmable interval timer interrupt "
|
2007-09-29 17:06:16 +04:00
|
|
|
"while in user mode. Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_IO: /* IO error exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "IO error exception while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_RUNM: /* Run mode exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Run mode exception while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_EMUL: /* Emulation trap exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Emulation trap exception not handled\n");
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_IFTLB: /* Instruction fetch TLB error */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Instruction fetch TLB exception "
|
2007-09-29 17:06:16 +04:00
|
|
|
"while in user-mode. Aborting");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DLTLB: /* Data load TLB miss */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Data load TLB exception while in user-mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_DSTLB: /* Data store TLB miss */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Data store TLB exception while in user-mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_FPA: /* Floating-point assist exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Floating-point assist exception not handled\n");
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_IABR: /* Instruction address breakpoint */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Instruction address breakpoint exception "
|
2007-09-29 17:06:16 +04:00
|
|
|
"not handled\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_SMI: /* System management interrupt */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "System management interrupt while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_THERM: /* Thermal interrupt */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Thermal interrupt interrupt while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"Aborting\n");
|
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_PERFM: /* Embedded performance monitor IRQ */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Performance monitor exception not handled\n");
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_VPUA: /* Vector assist exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Vector assist exception not handled\n");
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_SOFTP: /* Soft patch exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Soft patch exception not handled\n");
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
|
|
|
case POWERPC_EXCP_MAINT: /* Maintenance exception */
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Maintenance exception while in user mode. "
|
2007-09-29 17:06:16 +04:00
|
|
|
"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.
|
|
|
|
*/
|
|
|
|
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 20:37:13 +04:00
|
|
|
env->gpr[8], 0, 0);
|
2011-10-26 20:59:18 +04:00
|
|
|
if (ret == (target_ulong)(-TARGET_QEMU_ESIGRETURN)) {
|
2009-05-13 06:13:18 +04:00
|
|
|
/* Returning from a successful sigreturn syscall.
|
|
|
|
Avoid corrupting register state. */
|
|
|
|
break;
|
|
|
|
}
|
2011-10-26 20:59:18 +04:00
|
|
|
if (ret > (target_ulong)(-515)) {
|
2007-09-29 17:06:16 +04:00
|
|
|
env->crf[0] |= 0x1;
|
|
|
|
ret = -ret;
|
2004-01-05 02:54:31 +03:00
|
|
|
}
|
2007-09-29 17:06:16 +04:00
|
|
|
env->gpr[3] = ret;
|
|
|
|
break;
|
2009-08-03 19:43:27 +04: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 20:05:54 +03:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2008-11-14 20:05:54 +03:00
|
|
|
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 19:15:18 +04:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2007-09-29 17:06:16 +04:00
|
|
|
default:
|
2013-09-03 19:38:47 +04:00
|
|
|
cpu_abort(cs, "Unknown exception 0x%d. Aborting\n", trapnr);
|
2007-09-29 17:06:16 +04:00
|
|
|
break;
|
2003-11-23 20:05:30 +03:00
|
|
|
}
|
|
|
|
process_pending_signals(env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-11-26 21:47:20 +03:00
|
|
|
#ifdef TARGET_MIPS
|
|
|
|
|
2013-02-10 22:30:45 +04:00
|
|
|
# ifdef TARGET_ABI_MIPSO32
|
|
|
|
# define MIPS_SYS(name, args) args,
|
2005-11-26 21:47:20 +03:00
|
|
|
static const uint8_t mips_syscall_args[] = {
|
2011-08-09 23:31:41 +04:00
|
|
|
MIPS_SYS(sys_syscall , 8) /* 4000 */
|
2005-11-26 21:47:20 +03:00
|
|
|
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)
|
2013-07-24 23:50:01 +04:00
|
|
|
MIPS_SYS(sys_umount , 1)
|
2005-11-26 21:47:20 +03:00
|
|
|
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)
|
2013-07-24 23:50:01 +04:00
|
|
|
MIPS_SYS(sys_umount2 , 2)
|
2005-11-26 21:47:20 +03:00
|
|
|
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 16:11:52 +04:00
|
|
|
MIPS_SYS(sys_clone , 6) /* 4120 */
|
2005-11-26 21:47:20 +03: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)
|
2013-07-23 21:00:10 +04:00
|
|
|
MIPS_SYS(sys_mremap , 5)
|
2005-11-26 21:47:20 +03:00
|
|
|
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 15:32:31 +04:00
|
|
|
MIPS_SYS(sys_sigaltstack , 2)
|
2005-11-26 21:47:20 +03: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)
|
2013-07-15 17:17:40 +04:00
|
|
|
MIPS_SYS(sys_futex , 6)
|
2005-11-26 21:47:20 +03:00
|
|
|
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 17:58:00 +04:00
|
|
|
MIPS_SYS(sys_request_key, 4)
|
2005-11-26 21:47:20 +03:00
|
|
|
MIPS_SYS(sys_keyctl , 5)
|
2007-03-02 23:48:00 +03:00
|
|
|
MIPS_SYS(sys_set_thread_area, 1)
|
2007-05-13 17:58:00 +04: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)
|
2013-07-23 21:00:10 +04:00
|
|
|
MIPS_SYS(sys_splice, 6)
|
2007-05-13 17:58:00 +04:00
|
|
|
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 20:44:51 +04: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 21:47:20 +03:00
|
|
|
};
|
2013-02-10 22:30:45 +04:00
|
|
|
# undef MIPS_SYS
|
|
|
|
# endif /* O32 */
|
2005-11-26 21:47:20 +03:00
|
|
|
|
2009-07-09 20:45:17 +04: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 15:08:14 +03:00
|
|
|
addr = env->lladdr;
|
2009-07-09 20:45:17 +04: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 15:08:14 +03:00
|
|
|
env->lladdr = -1;
|
2009-07-09 20:45:17 +04:00
|
|
|
if (!segv) {
|
|
|
|
env->active_tc.PC += 4;
|
|
|
|
}
|
|
|
|
mmap_unlock();
|
|
|
|
end_exclusive();
|
|
|
|
return segv;
|
|
|
|
}
|
|
|
|
|
2013-01-11 02:50:22 +04:00
|
|
|
/* Break codes */
|
|
|
|
enum {
|
|
|
|
BRK_OVERFLOW = 6,
|
|
|
|
BRK_DIVZERO = 7
|
|
|
|
};
|
|
|
|
|
|
|
|
static int do_break(CPUMIPSState *env, target_siginfo_t *info,
|
|
|
|
unsigned int code)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
switch (code) {
|
|
|
|
case BRK_OVERFLOW:
|
|
|
|
case BRK_DIVZERO:
|
|
|
|
info->si_signo = TARGET_SIGFPE;
|
|
|
|
info->si_errno = 0;
|
|
|
|
info->si_code = (code == BRK_OVERFLOW) ? FPE_INTOVF : FPE_INTDIV;
|
|
|
|
queue_signal(env, info->si_signo, &*info);
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
default:
|
2014-02-28 18:25:32 +04:00
|
|
|
info->si_signo = TARGET_SIGTRAP;
|
|
|
|
info->si_errno = 0;
|
|
|
|
queue_signal(env, info->si_signo, &*info);
|
|
|
|
ret = 0;
|
2013-01-11 02:50:22 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-11-26 21:47:20 +03:00
|
|
|
void cpu_loop(CPUMIPSState *env)
|
|
|
|
{
|
2012-12-17 10:34:52 +04:00
|
|
|
CPUState *cs = CPU(mips_env_get_cpu(env));
|
2009-10-02 01:12:16 +04:00
|
|
|
target_siginfo_t info;
|
2013-02-10 22:30:45 +04:00
|
|
|
int trapnr;
|
|
|
|
abi_long ret;
|
|
|
|
# ifdef TARGET_ABI_MIPSO32
|
2005-11-26 21:47:20 +03:00
|
|
|
unsigned int syscall_num;
|
2013-02-10 22:30:45 +04:00
|
|
|
# endif
|
2005-11-26 21:47:20 +03:00
|
|
|
|
|
|
|
for(;;) {
|
2012-12-17 10:34:52 +04:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_mips_exec(cs);
|
2012-12-17 10:34:52 +04:00
|
|
|
cpu_exec_end(cs);
|
2005-11-26 21:47:20 +03:00
|
|
|
switch(trapnr) {
|
|
|
|
case EXCP_SYSCALL:
|
2008-06-27 14:02:35 +04:00
|
|
|
env->active_tc.PC += 4;
|
2013-02-10 22:30:45 +04:00
|
|
|
# ifdef TARGET_ABI_MIPSO32
|
|
|
|
syscall_num = env->active_tc.gpr[2] - 4000;
|
2007-05-13 17:58:00 +04:00
|
|
|
if (syscall_num >= sizeof(mips_syscall_args)) {
|
2011-07-12 15:33:23 +04:00
|
|
|
ret = -TARGET_ENOSYS;
|
2007-05-13 17:58:00 +04:00
|
|
|
} else {
|
|
|
|
int nb_args;
|
2007-10-14 20:27:31 +04:00
|
|
|
abi_ulong sp_reg;
|
|
|
|
abi_ulong arg5 = 0, arg6 = 0, arg7 = 0, arg8 = 0;
|
2007-05-13 17:58:00 +04:00
|
|
|
|
|
|
|
nb_args = mips_syscall_args[syscall_num];
|
2008-06-27 14:02:35 +04:00
|
|
|
sp_reg = env->active_tc.gpr[29];
|
2007-05-13 17:58:00 +04:00
|
|
|
switch (nb_args) {
|
|
|
|
/* these arguments are taken from the stack */
|
2011-08-09 23:32:38 +04:00
|
|
|
case 8:
|
|
|
|
if ((ret = get_user_ual(arg8, sp_reg + 28)) != 0) {
|
|
|
|
goto done_syscall;
|
|
|
|
}
|
|
|
|
case 7:
|
|
|
|
if ((ret = get_user_ual(arg7, sp_reg + 24)) != 0) {
|
|
|
|
goto done_syscall;
|
|
|
|
}
|
|
|
|
case 6:
|
|
|
|
if ((ret = get_user_ual(arg6, sp_reg + 20)) != 0) {
|
|
|
|
goto done_syscall;
|
|
|
|
}
|
|
|
|
case 5:
|
|
|
|
if ((ret = get_user_ual(arg5, sp_reg + 16)) != 0) {
|
|
|
|
goto done_syscall;
|
|
|
|
}
|
2007-05-13 17:58:00 +04:00
|
|
|
default:
|
|
|
|
break;
|
2005-11-26 21:47:20 +03:00
|
|
|
}
|
2008-06-27 14:02:35 +04: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 20:37:13 +04:00
|
|
|
arg5, arg6, arg7, arg8);
|
2007-05-13 17:58:00 +04:00
|
|
|
}
|
2011-08-09 23:32:38 +04:00
|
|
|
done_syscall:
|
2013-02-10 22:30:45 +04:00
|
|
|
# else
|
|
|
|
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],
|
|
|
|
env->active_tc.gpr[8], env->active_tc.gpr[9],
|
|
|
|
env->active_tc.gpr[10], env->active_tc.gpr[11]);
|
|
|
|
# endif /* O32 */
|
2009-04-21 05:41:10 +04:00
|
|
|
if (ret == -TARGET_QEMU_ESIGRETURN) {
|
|
|
|
/* Returning from a successful sigreturn syscall.
|
|
|
|
Avoid clobbering register state. */
|
|
|
|
break;
|
|
|
|
}
|
2013-02-10 22:30:45 +04:00
|
|
|
if ((abi_ulong)ret >= (abi_ulong)-1133) {
|
2008-06-27 14:02:35 +04:00
|
|
|
env->active_tc.gpr[7] = 1; /* error flag */
|
2007-05-13 17:58:00 +04:00
|
|
|
ret = -ret;
|
|
|
|
} else {
|
2008-06-27 14:02:35 +04:00
|
|
|
env->active_tc.gpr[7] = 0; /* error flag */
|
2005-11-26 21:47:20 +03:00
|
|
|
}
|
2008-06-27 14:02:35 +04:00
|
|
|
env->active_tc.gpr[2] = ret;
|
2005-11-26 21:47:20 +03:00
|
|
|
break;
|
2006-12-11 01:08:10 +03:00
|
|
|
case EXCP_TLBL:
|
|
|
|
case EXCP_TLBS:
|
2011-07-12 15:34:23 +04:00
|
|
|
case EXCP_AdEL:
|
|
|
|
case EXCP_AdES:
|
2009-04-21 05:03:10 +04: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-06 00:04:24 +03:00
|
|
|
case EXCP_CpU:
|
2005-11-26 21:47:20 +03:00
|
|
|
case EXCP_RI:
|
2006-06-14 17:37:55 +04:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = 0;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2005-11-26 21:47:20 +03:00
|
|
|
break;
|
2006-06-28 01:08:10 +04:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2006-11-04 19:46:29 +03:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2006-11-04 19:46:29 +03:00
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2006-11-04 19:46:29 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2009-07-09 20:45:17 +04: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;
|
2012-10-24 18:17:02 +04:00
|
|
|
case EXCP_DSPDIS:
|
|
|
|
info.si_signo = TARGET_SIGILL;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLOPC;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
2013-01-11 02:50:22 +04:00
|
|
|
/* The code below was inspired by the MIPS Linux kernel trap
|
|
|
|
* handling code in arch/mips/kernel/traps.c.
|
|
|
|
*/
|
|
|
|
case EXCP_BREAK:
|
|
|
|
{
|
|
|
|
abi_ulong trap_instr;
|
|
|
|
unsigned int code;
|
|
|
|
|
2013-07-19 20:21:44 +04:00
|
|
|
if (env->hflags & MIPS_HFLAG_M16) {
|
|
|
|
if (env->insn_flags & ASE_MICROMIPS) {
|
|
|
|
/* microMIPS mode */
|
2013-09-10 04:36:40 +04:00
|
|
|
ret = get_user_u16(trap_instr, env->active_tc.PC);
|
|
|
|
if (ret != 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
2013-07-19 20:21:44 +04:00
|
|
|
|
2013-09-10 04:36:40 +04:00
|
|
|
if ((trap_instr >> 10) == 0x11) {
|
|
|
|
/* 16-bit instruction */
|
|
|
|
code = trap_instr & 0xf;
|
|
|
|
} else {
|
|
|
|
/* 32-bit instruction */
|
|
|
|
abi_ulong instr_lo;
|
|
|
|
|
|
|
|
ret = get_user_u16(instr_lo,
|
|
|
|
env->active_tc.PC + 2);
|
|
|
|
if (ret != 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
trap_instr = (trap_instr << 16) | instr_lo;
|
|
|
|
code = ((trap_instr >> 6) & ((1 << 20) - 1));
|
|
|
|
/* Unfortunately, microMIPS also suffers from
|
|
|
|
the old assembler bug... */
|
|
|
|
if (code >= (1 << 10)) {
|
|
|
|
code >>= 10;
|
|
|
|
}
|
|
|
|
}
|
2013-07-19 20:21:44 +04:00
|
|
|
} else {
|
|
|
|
/* MIPS16e mode */
|
|
|
|
ret = get_user_u16(trap_instr, env->active_tc.PC);
|
|
|
|
if (ret != 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
code = (trap_instr >> 6) & 0x3f;
|
|
|
|
}
|
|
|
|
} else {
|
2015-06-29 13:20:07 +03:00
|
|
|
ret = get_user_u32(trap_instr, env->active_tc.PC);
|
2013-09-10 04:36:40 +04:00
|
|
|
if (ret != 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
2013-01-11 02:50:22 +04:00
|
|
|
|
2013-09-10 04:36:40 +04:00
|
|
|
/* As described in the original Linux kernel code, the
|
|
|
|
* below checks on 'code' are to work around an old
|
|
|
|
* assembly bug.
|
|
|
|
*/
|
|
|
|
code = ((trap_instr >> 6) & ((1 << 20) - 1));
|
|
|
|
if (code >= (1 << 10)) {
|
|
|
|
code >>= 10;
|
|
|
|
}
|
2013-01-11 02:50:22 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (do_break(env, &info, code) != 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EXCP_TRAP:
|
|
|
|
{
|
|
|
|
abi_ulong trap_instr;
|
|
|
|
unsigned int code = 0;
|
|
|
|
|
2013-07-19 20:21:44 +04:00
|
|
|
if (env->hflags & MIPS_HFLAG_M16) {
|
|
|
|
/* microMIPS mode */
|
|
|
|
abi_ulong instr[2];
|
|
|
|
|
|
|
|
ret = get_user_u16(instr[0], env->active_tc.PC) ||
|
|
|
|
get_user_u16(instr[1], env->active_tc.PC + 2);
|
|
|
|
|
|
|
|
trap_instr = (instr[0] << 16) | instr[1];
|
|
|
|
} else {
|
2015-06-29 13:20:07 +03:00
|
|
|
ret = get_user_u32(trap_instr, env->active_tc.PC);
|
2013-07-19 20:21:44 +04:00
|
|
|
}
|
|
|
|
|
2013-01-11 02:50:22 +04:00
|
|
|
if (ret != 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The immediate versions don't provide a code. */
|
|
|
|
if (!(trap_instr & 0xFC000000)) {
|
2013-07-19 20:21:44 +04:00
|
|
|
if (env->hflags & MIPS_HFLAG_M16) {
|
|
|
|
/* microMIPS mode */
|
|
|
|
code = ((trap_instr >> 12) & ((1 << 4) - 1));
|
|
|
|
} else {
|
|
|
|
code = ((trap_instr >> 6) & ((1 << 10) - 1));
|
|
|
|
}
|
2013-01-11 02:50:22 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (do_break(env, &info, code) != 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2005-11-26 21:47:20 +03:00
|
|
|
default:
|
2013-01-11 02:50:22 +04:00
|
|
|
error:
|
2007-09-17 01:08:06 +04:00
|
|
|
fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
|
2005-11-26 21:47:20 +03:00
|
|
|
trapnr);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2005-11-26 21:47:20 +03:00
|
|
|
abort();
|
|
|
|
}
|
|
|
|
process_pending_signals(env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-07-20 11:50:52 +04:00
|
|
|
#ifdef TARGET_OPENRISC
|
|
|
|
|
|
|
|
void cpu_loop(CPUOpenRISCState *env)
|
|
|
|
{
|
2013-05-27 03:33:50 +04:00
|
|
|
CPUState *cs = CPU(openrisc_env_get_cpu(env));
|
2012-07-20 11:50:52 +04:00
|
|
|
int trapnr, gdbsig;
|
|
|
|
|
|
|
|
for (;;) {
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_openrisc_exec(cs);
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_end(cs);
|
2012-07-20 11:50:52 +04:00
|
|
|
gdbsig = 0;
|
|
|
|
|
|
|
|
switch (trapnr) {
|
|
|
|
case EXCP_RESET:
|
|
|
|
qemu_log("\nReset request, exit, pc is %#x\n", env->pc);
|
|
|
|
exit(1);
|
|
|
|
break;
|
|
|
|
case EXCP_BUSERR:
|
|
|
|
qemu_log("\nBus error, exit, pc is %#x\n", env->pc);
|
2015-01-25 14:35:58 +03:00
|
|
|
gdbsig = TARGET_SIGBUS;
|
2012-07-20 11:50:52 +04:00
|
|
|
break;
|
|
|
|
case EXCP_DPF:
|
|
|
|
case EXCP_IPF:
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2012-07-20 11:50:52 +04:00
|
|
|
gdbsig = TARGET_SIGSEGV;
|
|
|
|
break;
|
|
|
|
case EXCP_TICK:
|
|
|
|
qemu_log("\nTick time interrupt pc is %#x\n", env->pc);
|
|
|
|
break;
|
|
|
|
case EXCP_ALIGN:
|
|
|
|
qemu_log("\nAlignment pc is %#x\n", env->pc);
|
2015-01-25 14:35:58 +03:00
|
|
|
gdbsig = TARGET_SIGBUS;
|
2012-07-20 11:50:52 +04:00
|
|
|
break;
|
|
|
|
case EXCP_ILLEGAL:
|
|
|
|
qemu_log("\nIllegal instructionpc is %#x\n", env->pc);
|
2015-01-25 14:35:58 +03:00
|
|
|
gdbsig = TARGET_SIGILL;
|
2012-07-20 11:50:52 +04:00
|
|
|
break;
|
|
|
|
case EXCP_INT:
|
|
|
|
qemu_log("\nExternal interruptpc is %#x\n", env->pc);
|
|
|
|
break;
|
|
|
|
case EXCP_DTLBMISS:
|
|
|
|
case EXCP_ITLBMISS:
|
|
|
|
qemu_log("\nTLB miss\n");
|
|
|
|
break;
|
|
|
|
case EXCP_RANGE:
|
|
|
|
qemu_log("\nRange\n");
|
2015-01-25 14:35:58 +03:00
|
|
|
gdbsig = TARGET_SIGSEGV;
|
2012-07-20 11:50:52 +04:00
|
|
|
break;
|
|
|
|
case EXCP_SYSCALL:
|
|
|
|
env->pc += 4; /* 0xc00; */
|
|
|
|
env->gpr[11] = do_syscall(env,
|
|
|
|
env->gpr[11], /* return value */
|
|
|
|
env->gpr[3], /* r3 - r7 are params */
|
|
|
|
env->gpr[4],
|
|
|
|
env->gpr[5],
|
|
|
|
env->gpr[6],
|
|
|
|
env->gpr[7],
|
|
|
|
env->gpr[8], 0, 0);
|
|
|
|
break;
|
|
|
|
case EXCP_FPE:
|
|
|
|
qemu_log("\nFloating point error\n");
|
|
|
|
break;
|
|
|
|
case EXCP_TRAP:
|
|
|
|
qemu_log("\nTrap\n");
|
2015-01-25 14:35:58 +03:00
|
|
|
gdbsig = TARGET_SIGTRAP;
|
2012-07-20 11:50:52 +04:00
|
|
|
break;
|
|
|
|
case EXCP_NR:
|
|
|
|
qemu_log("\nNR\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
qemu_log("\nqemu: unhandled CPU exception %#x - aborting\n",
|
|
|
|
trapnr);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2012-07-20 11:50:52 +04:00
|
|
|
gdbsig = TARGET_SIGILL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (gdbsig) {
|
2013-06-27 21:49:31 +04:00
|
|
|
gdb_handlesig(cs, gdbsig);
|
2012-07-20 11:50:52 +04:00
|
|
|
if (gdbsig != TARGET_SIGTRAP) {
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
process_pending_signals(env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* TARGET_OPENRISC */
|
|
|
|
|
2006-04-28 01:07:38 +04:00
|
|
|
#ifdef TARGET_SH4
|
2012-02-25 06:37:53 +04:00
|
|
|
void cpu_loop(CPUSH4State *env)
|
2006-04-28 01:07:38 +04:00
|
|
|
{
|
2013-05-27 03:33:50 +04:00
|
|
|
CPUState *cs = CPU(sh_env_get_cpu(env));
|
2006-04-28 01:07:38 +04:00
|
|
|
int trapnr, ret;
|
2009-10-02 01:12:16 +04:00
|
|
|
target_siginfo_t info;
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2006-04-28 01:07:38 +04:00
|
|
|
while (1) {
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_sh4_exec(cs);
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_end(cs);
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2006-04-28 01:07:38 +04:00
|
|
|
switch (trapnr) {
|
|
|
|
case 0x160:
|
2008-09-15 11:43:43 +04:00
|
|
|
env->pc += 2;
|
2007-09-17 01:08:06 +04: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 20:37:13 +04:00
|
|
|
env->gregs[1],
|
|
|
|
0, 0);
|
2006-06-18 23:12:54 +04:00
|
|
|
env->gregs[0] = ret;
|
2006-04-28 01:07:38 +04:00
|
|
|
break;
|
2007-12-02 09:31:25 +03:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2006-06-17 23:58:25 +04:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2006-06-17 23:58:25 +04:00
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2006-06-17 23:58:25 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2007-12-02 09:31:25 +03:00
|
|
|
case 0xa0:
|
|
|
|
case 0xc0:
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2007-12-02 09:31:25 +03:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
|
|
|
info._sifields._sigfault._addr = env->tea;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-12-02 09:31:25 +03:00
|
|
|
break;
|
|
|
|
|
2006-04-28 01:07:38 +04:00
|
|
|
default:
|
|
|
|
printf ("Unhandled trap: 0x%x\n", trapnr);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2006-04-28 01:07:38 +04:00
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-10-08 17:36:46 +04:00
|
|
|
#ifdef TARGET_CRIS
|
2012-02-25 06:37:53 +04:00
|
|
|
void cpu_loop(CPUCRISState *env)
|
2007-10-08 17:36:46 +04:00
|
|
|
{
|
2013-05-27 03:33:50 +04:00
|
|
|
CPUState *cs = CPU(cris_env_get_cpu(env));
|
2007-10-08 17:36:46 +04:00
|
|
|
int trapnr, ret;
|
2009-10-02 01:12:16 +04:00
|
|
|
target_siginfo_t info;
|
2007-10-08 17:36:46 +04:00
|
|
|
|
|
|
|
while (1) {
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_cris_exec(cs);
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_end(cs);
|
2007-10-08 17:36:46 +04:00
|
|
|
switch (trapnr) {
|
|
|
|
case 0xaa:
|
|
|
|
{
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2007-10-08 17:36:46 +04:00
|
|
|
info.si_errno = 0;
|
|
|
|
/* XXX: check env->error_code */
|
|
|
|
info.si_code = TARGET_SEGV_MAPERR;
|
2008-05-28 01:12:09 +04:00
|
|
|
info._sifields._sigfault._addr = env->pregs[PR_EDA];
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-10-08 17:36:46 +04:00
|
|
|
}
|
|
|
|
break;
|
2008-02-28 14:29:27 +03:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
2007-10-08 17:36:46 +04: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 20:37:13 +04:00
|
|
|
env->pregs[11],
|
|
|
|
0, 0);
|
2007-10-08 17:36:46 +04:00
|
|
|
env->regs[10] = ret;
|
|
|
|
break;
|
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2007-10-08 17:36:46 +04:00
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-10-08 17:36:46 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf ("Unhandled trap: 0x%x\n", trapnr);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2007-10-08 17:36:46 +04:00
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-05-20 23:31:33 +04:00
|
|
|
#ifdef TARGET_MICROBLAZE
|
2012-02-25 06:37:53 +04:00
|
|
|
void cpu_loop(CPUMBState *env)
|
2009-05-20 23:31:33 +04:00
|
|
|
{
|
2013-05-27 03:33:50 +04:00
|
|
|
CPUState *cs = CPU(mb_env_get_cpu(env));
|
2009-05-20 23:31:33 +04:00
|
|
|
int trapnr, ret;
|
2009-10-02 01:12:16 +04:00
|
|
|
target_siginfo_t info;
|
2009-05-20 23:31:33 +04:00
|
|
|
|
|
|
|
while (1) {
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_mb_exec(cs);
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_end(cs);
|
2009-05-20 23:31:33 +04:00
|
|
|
switch (trapnr) {
|
|
|
|
case 0xaa:
|
|
|
|
{
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2009-05-20 23:31:33 +04:00
|
|
|
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;
|
2012-04-26 16:18:25 +04:00
|
|
|
env->sregs[SR_PC] = env->regs[14];
|
2009-05-20 23:31:33 +04:00
|
|
|
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 20:37:13 +04:00
|
|
|
env->regs[10],
|
|
|
|
0, 0);
|
2009-05-20 23:31:33 +04:00
|
|
|
env->regs[3] = ret;
|
|
|
|
break;
|
2010-09-09 12:24:01 +04: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;
|
2011-11-22 14:06:17 +04:00
|
|
|
/* FIXME: if branch was immed, replay the imm as well. */
|
2010-09-09 12:24:01 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
env->iflags &= ~(IMM_FLAG | D_FLAG);
|
|
|
|
|
|
|
|
switch (env->sregs[SR_ESR] & 31) {
|
2011-08-22 20:42:54 +04:00
|
|
|
case ESR_EC_DIVZERO:
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGFPE;
|
2011-08-22 20:42:54 +04:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_FPE_FLTDIV;
|
|
|
|
info._sifields._sigfault._addr = 0;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
|
|
|
break;
|
2010-09-09 12:24:01 +04:00
|
|
|
case ESR_EC_FPU:
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGFPE;
|
2010-09-09 12:24:01 +04:00
|
|
|
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-12 01:57:07 +04:00
|
|
|
env->sregs[SR_ESR] & ESR_EC_MASK);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2010-09-09 12:24:01 +04:00
|
|
|
exit (1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2009-05-20 23:31:33 +04:00
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2009-05-20 23:31:33 +04:00
|
|
|
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);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2009-05-20 23:31:33 +04:00
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-10-22 04:18:54 +04:00
|
|
|
#ifdef TARGET_M68K
|
|
|
|
|
|
|
|
void cpu_loop(CPUM68KState *env)
|
|
|
|
{
|
2013-05-27 03:33:50 +04:00
|
|
|
CPUState *cs = CPU(m68k_env_get_cpu(env));
|
2006-10-22 04:18:54 +04:00
|
|
|
int trapnr;
|
|
|
|
unsigned int n;
|
2009-10-02 01:12:16 +04:00
|
|
|
target_siginfo_t info;
|
2013-08-26 20:14:44 +04:00
|
|
|
TaskState *ts = cs->opaque;
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2006-10-22 04:18:54 +04:00
|
|
|
for(;;) {
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_m68k_exec(cs);
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_end(cs);
|
2006-10-22 04:18:54 +04:00
|
|
|
switch(trapnr) {
|
|
|
|
case EXCP_ILLEGAL:
|
|
|
|
{
|
|
|
|
if (ts->sim_syscalls) {
|
|
|
|
uint16_t nr;
|
2015-01-20 18:19:33 +03:00
|
|
|
get_user_u16(nr, env->pc + 2);
|
2006-10-22 04:18:54 +04:00
|
|
|
env->pc += 4;
|
|
|
|
do_m68k_simcall(env, nr);
|
|
|
|
} else {
|
|
|
|
goto do_sigill;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2007-05-26 19:09:38 +04:00
|
|
|
case EXCP_HALT_INSN:
|
2006-10-22 04:18:54 +04:00
|
|
|
/* Semihosing syscall. */
|
2007-05-26 19:09:38 +04:00
|
|
|
env->pc += 4;
|
2006-10-22 04:18:54 +04:00
|
|
|
do_m68k_semihosting(env, env->dregs[0]);
|
|
|
|
break;
|
|
|
|
case EXCP_LINEA:
|
|
|
|
case EXCP_LINEF:
|
|
|
|
case EXCP_UNSUPPORTED:
|
|
|
|
do_sigill:
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGILL;
|
2006-10-22 04:18:54 +04:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_ILL_ILLOPN;
|
|
|
|
info._sifields._sigfault._addr = env->pc;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2006-10-22 04:18:54 +04:00
|
|
|
break;
|
|
|
|
case EXCP_TRAP0:
|
|
|
|
{
|
|
|
|
ts->sim_syscalls = 0;
|
|
|
|
n = env->dregs[0];
|
|
|
|
env->pc += 2;
|
2007-09-17 01:08:06 +04:00
|
|
|
env->dregs[0] = do_syscall(env,
|
|
|
|
n,
|
2006-10-22 04:18:54 +04:00
|
|
|
env->dregs[1],
|
|
|
|
env->dregs[2],
|
|
|
|
env->dregs[3],
|
|
|
|
env->dregs[4],
|
|
|
|
env->dregs[5],
|
2011-06-16 20:37:13 +04:00
|
|
|
env->aregs[0],
|
|
|
|
0, 0);
|
2006-10-22 04:18:54 +04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* just indicate that signals should be handled asap */
|
|
|
|
break;
|
|
|
|
case EXCP_ACCESS:
|
|
|
|
{
|
2015-01-25 14:35:58 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
2006-10-22 04:18:54 +04:00
|
|
|
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 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2006-10-22 04:18:54 +04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EXCP_DEBUG:
|
|
|
|
{
|
|
|
|
int sig;
|
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2006-10-22 04:18:54 +04:00
|
|
|
if (sig)
|
|
|
|
{
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
2008-05-31 20:11:38 +04:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2006-10-22 04:18:54 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2007-09-17 01:08:06 +04:00
|
|
|
fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
|
2006-10-22 04:18:54 +04:00
|
|
|
trapnr);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2006-10-22 04:18:54 +04:00
|
|
|
abort();
|
|
|
|
}
|
|
|
|
process_pending_signals(env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* TARGET_M68K */
|
|
|
|
|
2007-04-05 11:13:51 +04:00
|
|
|
#ifdef TARGET_ALPHA
|
2010-04-08 02:42:26 +04: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);
|
|
|
|
}
|
|
|
|
|
2012-02-25 06:37:53 +04:00
|
|
|
void cpu_loop(CPUAlphaState *env)
|
2007-04-05 11:13:51 +04:00
|
|
|
{
|
2013-05-27 03:33:50 +04:00
|
|
|
CPUState *cs = CPU(alpha_env_get_cpu(env));
|
2007-04-14 16:17:09 +04:00
|
|
|
int trapnr;
|
2009-10-02 01:12:16 +04:00
|
|
|
target_siginfo_t info;
|
2009-12-28 05:30:03 +03:00
|
|
|
abi_long sysret;
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2007-04-05 11:13:51 +04:00
|
|
|
while (1) {
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_alpha_exec(cs);
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_end(cs);
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2010-04-13 03:14:54 +04: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 11:13:51 +04: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-21 01:04:57 +04:00
|
|
|
case EXCP_SMP_INTERRUPT:
|
|
|
|
case EXCP_CLK_INTERRUPT:
|
|
|
|
case EXCP_DEV_INTERRUPT:
|
2007-09-17 01:08:06 +04:00
|
|
|
fprintf(stderr, "External interrupt. Exit\n");
|
2007-04-05 11:13:51 +04:00
|
|
|
exit(1);
|
|
|
|
break;
|
2011-05-21 01:04:57 +04:00
|
|
|
case EXCP_MMFAULT:
|
2010-04-08 02:42:26 +04:00
|
|
|
env->lock_addr = -1;
|
2009-12-28 05:30:03 +03:00
|
|
|
info.si_signo = TARGET_SIGSEGV;
|
|
|
|
info.si_errno = 0;
|
2011-05-21 00:30:00 +04:00
|
|
|
info.si_code = (page_get_flags(env->trap_arg0) & PAGE_VALID
|
2010-05-21 21:03:33 +04:00
|
|
|
? TARGET_SEGV_ACCERR : TARGET_SEGV_MAPERR);
|
2011-05-21 00:30:00 +04:00
|
|
|
info._sifields._sigfault._addr = env->trap_arg0;
|
2009-12-28 05:30:03 +03:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-04-05 11:13:51 +04:00
|
|
|
break;
|
|
|
|
case EXCP_UNALIGN:
|
2010-04-08 02:42:26 +04:00
|
|
|
env->lock_addr = -1;
|
2009-12-28 05:30:03 +03:00
|
|
|
info.si_signo = TARGET_SIGBUS;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_BUS_ADRALN;
|
2011-05-21 00:30:00 +04:00
|
|
|
info._sifields._sigfault._addr = env->trap_arg0;
|
2009-12-28 05:30:03 +03:00
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-04-05 11:13:51 +04:00
|
|
|
break;
|
|
|
|
case EXCP_OPCDEC:
|
2009-12-28 05:30:03 +03:00
|
|
|
do_sigill:
|
2010-04-08 02:42:26 +04:00
|
|
|
env->lock_addr = -1;
|
2009-12-28 05:30:03 +03: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 11:13:51 +04:00
|
|
|
break;
|
2011-05-21 01:04:57 +04: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 11:13:51 +04:00
|
|
|
case EXCP_FEN:
|
2009-12-28 05:30:03 +03:00
|
|
|
/* No-op. Linux simply re-enables the FPU. */
|
2007-04-05 11:13:51 +04:00
|
|
|
break;
|
2011-05-21 01:04:57 +04:00
|
|
|
case EXCP_CALL_PAL:
|
2010-04-08 02:42:26 +04:00
|
|
|
env->lock_addr = -1;
|
2011-05-21 01:04:57 +04:00
|
|
|
switch (env->error_code) {
|
2009-12-28 05:30:03 +03: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 20:37:13 +04:00
|
|
|
env->ir[IR_A4], env->ir[IR_A5],
|
|
|
|
0, 0);
|
2010-05-03 21:07:55 +04:00
|
|
|
if (trapnr == TARGET_NR_sigreturn
|
|
|
|
|| trapnr == TARGET_NR_rt_sigreturn) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Syscall writes 0 to V0 to bypass error check, similar
|
2012-06-08 01:47:41 +04:00
|
|
|
to how this is handled internal to Linux kernel.
|
|
|
|
(Ab)use trapnr temporarily as boolean indicating error. */
|
|
|
|
trapnr = (env->ir[IR_V0] != 0 && sysret < 0);
|
|
|
|
env->ir[IR_V0] = (trapnr ? -sysret : sysret);
|
|
|
|
env->ir[IR_A3] = trapnr;
|
2009-12-28 05:30:03 +03:00
|
|
|
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 11:13:51 +04:00
|
|
|
break;
|
|
|
|
case EXCP_DEBUG:
|
2013-06-27 21:49:31 +04:00
|
|
|
info.si_signo = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2009-12-28 05:30:03 +03:00
|
|
|
if (info.si_signo) {
|
2010-04-08 02:42:26 +04:00
|
|
|
env->lock_addr = -1;
|
2009-12-28 05:30:03 +03:00
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = TARGET_TRAP_BRKPT;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
2007-04-05 11:13:51 +04:00
|
|
|
}
|
|
|
|
break;
|
2010-04-08 02:42:26 +04:00
|
|
|
case EXCP_STL_C:
|
|
|
|
case EXCP_STQ_C:
|
|
|
|
do_store_exclusive(env, env->error_code, trapnr - EXCP_STL_C);
|
|
|
|
break;
|
2012-05-31 23:05:23 +04:00
|
|
|
case EXCP_INTERRUPT:
|
|
|
|
/* Just indicate that signals should be handled asap. */
|
|
|
|
break;
|
2007-04-05 11:13:51 +04:00
|
|
|
default:
|
|
|
|
printf ("Unhandled trap: 0x%x\n", trapnr);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2007-04-05 11:13:51 +04:00
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* TARGET_ALPHA */
|
|
|
|
|
2009-07-24 18:57:31 +04:00
|
|
|
#ifdef TARGET_S390X
|
|
|
|
void cpu_loop(CPUS390XState *env)
|
|
|
|
{
|
2013-05-27 03:33:50 +04:00
|
|
|
CPUState *cs = CPU(s390_env_get_cpu(env));
|
2012-09-15 06:31:57 +04:00
|
|
|
int trapnr, n, sig;
|
2009-07-24 18:57:31 +04:00
|
|
|
target_siginfo_t info;
|
2012-09-15 06:31:57 +04:00
|
|
|
target_ulong addr;
|
2009-07-24 18:57:31 +04:00
|
|
|
|
|
|
|
while (1) {
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_start(cs);
|
2015-06-18 20:24:55 +03:00
|
|
|
trapnr = cpu_s390x_exec(cs);
|
2015-01-08 15:19:46 +03:00
|
|
|
cpu_exec_end(cs);
|
2009-07-24 18:57:31 +04:00
|
|
|
switch (trapnr) {
|
|
|
|
case EXCP_INTERRUPT:
|
2012-09-15 06:31:57 +04:00
|
|
|
/* Just indicate that signals should be handled asap. */
|
2009-07-24 18:57:31 +04:00
|
|
|
break;
|
|
|
|
|
2012-09-15 06:31:57 +04:00
|
|
|
case EXCP_SVC:
|
|
|
|
n = env->int_svc_code;
|
|
|
|
if (!n) {
|
|
|
|
/* syscalls > 255 */
|
|
|
|
n = env->regs[1];
|
2009-07-24 18:57:31 +04:00
|
|
|
}
|
2012-09-15 06:31:57 +04:00
|
|
|
env->psw.addr += env->int_svc_ilen;
|
|
|
|
env->regs[2] = do_syscall(env, n, env->regs[2], env->regs[3],
|
|
|
|
env->regs[4], env->regs[5],
|
|
|
|
env->regs[6], env->regs[7], 0, 0);
|
2009-07-24 18:57:31 +04:00
|
|
|
break;
|
2012-09-15 06:31:57 +04:00
|
|
|
|
|
|
|
case EXCP_DEBUG:
|
2013-06-27 21:49:31 +04:00
|
|
|
sig = gdb_handlesig(cs, TARGET_SIGTRAP);
|
2012-09-15 06:31:57 +04:00
|
|
|
if (sig) {
|
|
|
|
n = TARGET_TRAP_BRKPT;
|
|
|
|
goto do_signal_pc;
|
2009-07-24 18:57:31 +04:00
|
|
|
}
|
|
|
|
break;
|
2012-09-15 06:31:57 +04:00
|
|
|
case EXCP_PGM:
|
|
|
|
n = env->int_pgm_code;
|
|
|
|
switch (n) {
|
|
|
|
case PGM_OPERATION:
|
|
|
|
case PGM_PRIVILEGED:
|
2015-01-25 14:35:58 +03:00
|
|
|
sig = TARGET_SIGILL;
|
2012-09-15 06:31:57 +04:00
|
|
|
n = TARGET_ILL_ILLOPC;
|
|
|
|
goto do_signal_pc;
|
|
|
|
case PGM_PROTECTION:
|
|
|
|
case PGM_ADDRESSING:
|
2015-01-25 14:35:58 +03:00
|
|
|
sig = TARGET_SIGSEGV;
|
2009-07-24 18:57:31 +04:00
|
|
|
/* XXX: check env->error_code */
|
2012-09-15 06:31:57 +04:00
|
|
|
n = TARGET_SEGV_MAPERR;
|
|
|
|
addr = env->__excp_addr;
|
|
|
|
goto do_signal;
|
|
|
|
case PGM_EXECUTE:
|
|
|
|
case PGM_SPECIFICATION:
|
|
|
|
case PGM_SPECIAL_OP:
|
|
|
|
case PGM_OPERAND:
|
|
|
|
do_sigill_opn:
|
2015-01-25 14:35:58 +03:00
|
|
|
sig = TARGET_SIGILL;
|
2012-09-15 06:31:57 +04:00
|
|
|
n = TARGET_ILL_ILLOPN;
|
|
|
|
goto do_signal_pc;
|
|
|
|
|
|
|
|
case PGM_FIXPT_OVERFLOW:
|
2015-01-25 14:35:58 +03:00
|
|
|
sig = TARGET_SIGFPE;
|
2012-09-15 06:31:57 +04:00
|
|
|
n = TARGET_FPE_INTOVF;
|
|
|
|
goto do_signal_pc;
|
|
|
|
case PGM_FIXPT_DIVIDE:
|
2015-01-25 14:35:58 +03:00
|
|
|
sig = TARGET_SIGFPE;
|
2012-09-15 06:31:57 +04:00
|
|
|
n = TARGET_FPE_INTDIV;
|
|
|
|
goto do_signal_pc;
|
|
|
|
|
|
|
|
case PGM_DATA:
|
|
|
|
n = (env->fpc >> 8) & 0xff;
|
|
|
|
if (n == 0xff) {
|
|
|
|
/* compare-and-trap */
|
|
|
|
goto do_sigill_opn;
|
|
|
|
} else {
|
|
|
|
/* An IEEE exception, simulated or otherwise. */
|
|
|
|
if (n & 0x80) {
|
|
|
|
n = TARGET_FPE_FLTINV;
|
|
|
|
} else if (n & 0x40) {
|
|
|
|
n = TARGET_FPE_FLTDIV;
|
|
|
|
} else if (n & 0x20) {
|
|
|
|
n = TARGET_FPE_FLTOVF;
|
|
|
|
} else if (n & 0x10) {
|
|
|
|
n = TARGET_FPE_FLTUND;
|
|
|
|
} else if (n & 0x08) {
|
|
|
|
n = TARGET_FPE_FLTRES;
|
|
|
|
} else {
|
|
|
|
/* ??? Quantum exception; BFP, DFP error. */
|
|
|
|
goto do_sigill_opn;
|
|
|
|
}
|
2015-01-25 14:35:58 +03:00
|
|
|
sig = TARGET_SIGFPE;
|
2012-09-15 06:31:57 +04:00
|
|
|
goto do_signal_pc;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "Unhandled program exception: %#x\n", n);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2012-09-15 06:31:57 +04:00
|
|
|
exit(1);
|
2009-07-24 18:57:31 +04:00
|
|
|
}
|
|
|
|
break;
|
2012-09-15 06:31:57 +04:00
|
|
|
|
|
|
|
do_signal_pc:
|
|
|
|
addr = env->psw.addr;
|
|
|
|
do_signal:
|
|
|
|
info.si_signo = sig;
|
|
|
|
info.si_errno = 0;
|
|
|
|
info.si_code = n;
|
|
|
|
info._sifields._sigfault._addr = addr;
|
|
|
|
queue_signal(env, info.si_signo, &info);
|
2009-07-24 18:57:31 +04:00
|
|
|
break;
|
2012-09-15 06:31:57 +04:00
|
|
|
|
2009-07-24 18:57:31 +04:00
|
|
|
default:
|
2012-09-15 06:31:57 +04:00
|
|
|
fprintf(stderr, "Unhandled trap: 0x%x\n", trapnr);
|
2013-05-27 03:33:50 +04:00
|
|
|
cpu_dump_state(cs, stderr, fprintf, 0);
|
2012-09-15 06:31:57 +04:00
|
|
|
exit(1);
|
2009-07-24 18:57:31 +04:00
|
|
|
}
|
|
|
|
process_pending_signals (env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* TARGET_S390X */
|
|
|
|
|
2013-06-09 21:47:04 +04:00
|
|
|
THREAD CPUState *thread_cpu;
|
2003-06-25 20:18:50 +04:00
|
|
|
|
2009-04-07 10:57:11 +04:00
|
|
|
void task_settid(TaskState *ts)
|
|
|
|
{
|
|
|
|
if (ts->ts_tid == 0) {
|
|
|
|
ts->ts_tid = (pid_t)syscall(SYS_gettid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void stop_all_tasks(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We trust that when using NPTL, start_exclusive()
|
|
|
|
* handles thread stopping correctly.
|
|
|
|
*/
|
|
|
|
start_exclusive();
|
|
|
|
}
|
|
|
|
|
2008-06-09 18:02:50 +04:00
|
|
|
/* Assumes contents are already zeroed. */
|
2008-05-31 20:11:38 +04: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;
|
|
|
|
}
|
2011-08-06 10:54:12 +04:00
|
|
|
|
2013-07-02 19:43:21 +04:00
|
|
|
CPUArchState *cpu_copy(CPUArchState *env)
|
|
|
|
{
|
2013-08-26 20:23:18 +04:00
|
|
|
CPUState *cpu = ENV_GET_CPU(env);
|
2015-02-26 23:37:49 +03:00
|
|
|
CPUState *new_cpu = cpu_init(cpu_model);
|
2015-03-23 15:55:52 +03:00
|
|
|
CPUArchState *new_env = new_cpu->env_ptr;
|
2013-07-02 19:43:21 +04:00
|
|
|
CPUBreakpoint *bp;
|
|
|
|
CPUWatchpoint *wp;
|
|
|
|
|
|
|
|
/* Reset non arch specific state */
|
2013-09-02 18:57:02 +04:00
|
|
|
cpu_reset(new_cpu);
|
2013-07-02 19:43:21 +04:00
|
|
|
|
|
|
|
memcpy(new_env, env, sizeof(CPUArchState));
|
|
|
|
|
|
|
|
/* Clone all break/watchpoints.
|
|
|
|
Note: Once we support ptrace with hw-debug register access, make sure
|
|
|
|
BP_CPU break/watchpoints are handled correctly on clone. */
|
2015-06-12 12:24:10 +03:00
|
|
|
QTAILQ_INIT(&new_cpu->breakpoints);
|
|
|
|
QTAILQ_INIT(&new_cpu->watchpoints);
|
2013-08-26 23:22:53 +04:00
|
|
|
QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) {
|
2013-09-02 19:26:20 +04:00
|
|
|
cpu_breakpoint_insert(new_cpu, bp->pc, bp->flags, NULL);
|
2013-07-02 19:43:21 +04:00
|
|
|
}
|
2013-08-26 20:23:18 +04:00
|
|
|
QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {
|
2014-09-12 17:06:48 +04:00
|
|
|
cpu_watchpoint_insert(new_cpu, wp->vaddr, wp->len, wp->flags, NULL);
|
2013-07-02 19:43:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return new_env;
|
|
|
|
}
|
|
|
|
|
2011-08-06 10:54:12 +04:00
|
|
|
static void handle_arg_help(const char *arg)
|
|
|
|
{
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_log(const char *arg)
|
|
|
|
{
|
|
|
|
int mask;
|
|
|
|
|
2013-02-11 20:41:22 +04:00
|
|
|
mask = qemu_str_to_log_mask(arg);
|
2011-08-06 10:54:12 +04:00
|
|
|
if (!mask) {
|
2013-02-11 20:41:21 +04:00
|
|
|
qemu_print_log_usage(stdout);
|
2011-08-06 10:54:12 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2013-02-11 20:41:23 +04:00
|
|
|
qemu_set_log(mask);
|
2011-08-06 10:54:12 +04:00
|
|
|
}
|
|
|
|
|
2011-11-08 13:46:44 +04:00
|
|
|
static void handle_arg_log_filename(const char *arg)
|
|
|
|
{
|
2013-02-11 20:41:20 +04:00
|
|
|
qemu_set_log_filename(arg);
|
2011-11-08 13:46:44 +04:00
|
|
|
}
|
|
|
|
|
2011-08-06 10:54:12 +04:00
|
|
|
static void handle_arg_set_env(const char *arg)
|
|
|
|
{
|
|
|
|
char *r, *p, *token;
|
|
|
|
r = p = strdup(arg);
|
|
|
|
while ((token = strsep(&p, ",")) != NULL) {
|
|
|
|
if (envlist_setenv(envlist, token) != 0) {
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_unset_env(const char *arg)
|
|
|
|
{
|
|
|
|
char *r, *p, *token;
|
|
|
|
r = p = strdup(arg);
|
|
|
|
while ((token = strsep(&p, ",")) != NULL) {
|
|
|
|
if (envlist_unsetenv(envlist, token) != 0) {
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_argv0(const char *arg)
|
|
|
|
{
|
|
|
|
argv0 = strdup(arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_stack_size(const char *arg)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
guest_stack_size = strtoul(arg, &p, 0);
|
|
|
|
if (guest_stack_size == 0) {
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*p == 'M') {
|
|
|
|
guest_stack_size *= 1024 * 1024;
|
|
|
|
} else if (*p == 'k' || *p == 'K') {
|
|
|
|
guest_stack_size *= 1024;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_ld_prefix(const char *arg)
|
|
|
|
{
|
|
|
|
interp_prefix = strdup(arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_pagesize(const char *arg)
|
|
|
|
{
|
|
|
|
qemu_host_page_size = atoi(arg);
|
|
|
|
if (qemu_host_page_size == 0 ||
|
|
|
|
(qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
|
|
|
|
fprintf(stderr, "page size must be a power of two\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-14 19:18:17 +04:00
|
|
|
static void handle_arg_randseed(const char *arg)
|
|
|
|
{
|
|
|
|
unsigned long long seed;
|
|
|
|
|
|
|
|
if (parse_uint_full(arg, &seed, 0) != 0 || seed > UINT_MAX) {
|
|
|
|
fprintf(stderr, "Invalid seed number: %s\n", arg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
srand(seed);
|
|
|
|
}
|
|
|
|
|
2011-08-06 10:54:12 +04:00
|
|
|
static void handle_arg_gdb(const char *arg)
|
|
|
|
{
|
|
|
|
gdbstub_port = atoi(arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_uname(const char *arg)
|
|
|
|
{
|
|
|
|
qemu_uname_release = strdup(arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_cpu(const char *arg)
|
|
|
|
{
|
|
|
|
cpu_model = strdup(arg);
|
2012-08-02 16:45:54 +04:00
|
|
|
if (cpu_model == NULL || is_help_option(cpu_model)) {
|
2011-08-06 10:54:12 +04:00
|
|
|
/* XXX: implement xxx_cpu_list for targets that still miss it */
|
2012-09-06 00:41:08 +04:00
|
|
|
#if defined(cpu_list)
|
|
|
|
cpu_list(stdout, &fprintf);
|
2011-08-06 10:54:12 +04:00
|
|
|
#endif
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_guest_base(const char *arg)
|
|
|
|
{
|
|
|
|
guest_base = strtol(arg, NULL, 0);
|
|
|
|
have_guest_base = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_reserved_va(const char *arg)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int shift = 0;
|
|
|
|
reserved_va = strtoul(arg, &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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_singlestep(const char *arg)
|
|
|
|
{
|
|
|
|
singlestep = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_strace(const char *arg)
|
|
|
|
{
|
|
|
|
do_strace = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_arg_version(const char *arg)
|
|
|
|
{
|
2013-06-04 16:45:27 +04:00
|
|
|
printf("qemu-" TARGET_NAME " version " QEMU_VERSION QEMU_PKGVERSION
|
2011-08-06 10:54:12 +04:00
|
|
|
", Copyright (c) 2003-2008 Fabrice Bellard\n");
|
2011-09-29 18:48:12 +04:00
|
|
|
exit(0);
|
2011-08-06 10:54:12 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
struct qemu_argument {
|
|
|
|
const char *argv;
|
|
|
|
const char *env;
|
|
|
|
bool has_arg;
|
|
|
|
void (*handle_opt)(const char *arg);
|
|
|
|
const char *example;
|
|
|
|
const char *help;
|
|
|
|
};
|
|
|
|
|
2012-05-21 23:56:19 +04:00
|
|
|
static const struct qemu_argument arg_table[] = {
|
2011-08-06 10:54:12 +04:00
|
|
|
{"h", "", false, handle_arg_help,
|
|
|
|
"", "print this help"},
|
|
|
|
{"g", "QEMU_GDB", true, handle_arg_gdb,
|
|
|
|
"port", "wait gdb connection to 'port'"},
|
|
|
|
{"L", "QEMU_LD_PREFIX", true, handle_arg_ld_prefix,
|
|
|
|
"path", "set the elf interpreter prefix to 'path'"},
|
|
|
|
{"s", "QEMU_STACK_SIZE", true, handle_arg_stack_size,
|
|
|
|
"size", "set the stack size to 'size' bytes"},
|
|
|
|
{"cpu", "QEMU_CPU", true, handle_arg_cpu,
|
2012-08-02 16:45:54 +04:00
|
|
|
"model", "select CPU (-cpu help for list)"},
|
2011-08-06 10:54:12 +04:00
|
|
|
{"E", "QEMU_SET_ENV", true, handle_arg_set_env,
|
|
|
|
"var=value", "sets targets environment variable (see below)"},
|
|
|
|
{"U", "QEMU_UNSET_ENV", true, handle_arg_unset_env,
|
|
|
|
"var", "unsets targets environment variable (see below)"},
|
|
|
|
{"0", "QEMU_ARGV0", true, handle_arg_argv0,
|
|
|
|
"argv0", "forces target process argv[0] to be 'argv0'"},
|
|
|
|
{"r", "QEMU_UNAME", true, handle_arg_uname,
|
|
|
|
"uname", "set qemu uname release string to 'uname'"},
|
|
|
|
{"B", "QEMU_GUEST_BASE", true, handle_arg_guest_base,
|
|
|
|
"address", "set guest_base address to 'address'"},
|
|
|
|
{"R", "QEMU_RESERVED_VA", true, handle_arg_reserved_va,
|
|
|
|
"size", "reserve 'size' bytes for guest virtual address space"},
|
|
|
|
{"d", "QEMU_LOG", true, handle_arg_log,
|
2013-02-26 21:52:40 +04:00
|
|
|
"item[,...]", "enable logging of specified items "
|
|
|
|
"(use '-d help' for a list of items)"},
|
2011-11-08 13:46:44 +04:00
|
|
|
{"D", "QEMU_LOG_FILENAME", true, handle_arg_log_filename,
|
2013-02-26 21:52:40 +04:00
|
|
|
"logfile", "write logs to 'logfile' (default stderr)"},
|
2011-08-06 10:54:12 +04:00
|
|
|
{"p", "QEMU_PAGESIZE", true, handle_arg_pagesize,
|
|
|
|
"pagesize", "set the host page size to 'pagesize'"},
|
|
|
|
{"singlestep", "QEMU_SINGLESTEP", false, handle_arg_singlestep,
|
|
|
|
"", "run in singlestep mode"},
|
|
|
|
{"strace", "QEMU_STRACE", false, handle_arg_strace,
|
|
|
|
"", "log system calls"},
|
2014-10-14 19:18:17 +04:00
|
|
|
{"seed", "QEMU_RAND_SEED", true, handle_arg_randseed,
|
|
|
|
"", "Seed for pseudo-random number generator"},
|
2011-08-06 10:54:12 +04:00
|
|
|
{"version", "QEMU_VERSION", false, handle_arg_version,
|
2011-09-29 18:48:12 +04:00
|
|
|
"", "display version information and exit"},
|
2011-08-06 10:54:12 +04:00
|
|
|
{NULL, NULL, false, NULL, NULL, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
static void usage(void)
|
|
|
|
{
|
2012-05-21 23:56:19 +04:00
|
|
|
const struct qemu_argument *arginfo;
|
2011-08-06 10:54:12 +04:00
|
|
|
int maxarglen;
|
|
|
|
int maxenvlen;
|
|
|
|
|
2013-06-04 16:45:27 +04:00
|
|
|
printf("usage: qemu-" TARGET_NAME " [options] program [arguments...]\n"
|
|
|
|
"Linux CPU emulator (compiled for " TARGET_NAME " emulation)\n"
|
2011-08-06 10:54:12 +04:00
|
|
|
"\n"
|
|
|
|
"Options and associated environment variables:\n"
|
|
|
|
"\n");
|
|
|
|
|
2013-02-14 12:46:43 +04:00
|
|
|
/* Calculate column widths. We must always have at least enough space
|
|
|
|
* for the column header.
|
|
|
|
*/
|
|
|
|
maxarglen = strlen("Argument");
|
|
|
|
maxenvlen = strlen("Env-variable");
|
2011-08-06 10:54:12 +04:00
|
|
|
|
|
|
|
for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
|
2013-02-14 12:46:43 +04:00
|
|
|
int arglen = strlen(arginfo->argv);
|
|
|
|
if (arginfo->has_arg) {
|
|
|
|
arglen += strlen(arginfo->example) + 1;
|
|
|
|
}
|
2011-08-06 10:54:12 +04:00
|
|
|
if (strlen(arginfo->env) > maxenvlen) {
|
|
|
|
maxenvlen = strlen(arginfo->env);
|
|
|
|
}
|
2013-02-14 12:46:43 +04:00
|
|
|
if (arglen > maxarglen) {
|
|
|
|
maxarglen = arglen;
|
2011-08-06 10:54:12 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-14 12:46:43 +04:00
|
|
|
printf("%-*s %-*s Description\n", maxarglen+1, "Argument",
|
|
|
|
maxenvlen, "Env-variable");
|
2011-08-06 10:54:12 +04:00
|
|
|
|
|
|
|
for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
|
|
|
|
if (arginfo->has_arg) {
|
|
|
|
printf("-%s %-*s %-*s %s\n", arginfo->argv,
|
2013-02-14 12:46:43 +04:00
|
|
|
(int)(maxarglen - strlen(arginfo->argv) - 1),
|
|
|
|
arginfo->example, maxenvlen, arginfo->env, arginfo->help);
|
2011-08-06 10:54:12 +04:00
|
|
|
} else {
|
2013-02-14 12:46:43 +04:00
|
|
|
printf("-%-*s %-*s %s\n", maxarglen, arginfo->argv,
|
2011-08-06 10:54:12 +04:00
|
|
|
maxenvlen, arginfo->env,
|
|
|
|
arginfo->help);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("\n"
|
|
|
|
"Defaults:\n"
|
|
|
|
"QEMU_LD_PREFIX = %s\n"
|
2013-02-26 21:52:40 +04:00
|
|
|
"QEMU_STACK_SIZE = %ld byte\n",
|
2011-08-06 10:54:12 +04:00
|
|
|
interp_prefix,
|
2013-02-26 21:52:40 +04:00
|
|
|
guest_stack_size);
|
2011-08-06 10:54:12 +04:00
|
|
|
|
|
|
|
printf("\n"
|
|
|
|
"You can use -E and -U options or the QEMU_SET_ENV and\n"
|
|
|
|
"QEMU_UNSET_ENV environment variables to set and unset\n"
|
|
|
|
"environment variables for the target process.\n"
|
|
|
|
"It is possible to provide several variables by separating them\n"
|
|
|
|
"by commas in getsubopt(3) style. Additionally it is possible to\n"
|
|
|
|
"provide the -E and -U options multiple times.\n"
|
|
|
|
"The following lines are equivalent:\n"
|
|
|
|
" -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n"
|
|
|
|
" -E var1=val2,var2=val2 -U LD_PRELOAD,LD_DEBUG\n"
|
|
|
|
" QEMU_SET_ENV=var1=val2,var2=val2 QEMU_UNSET_ENV=LD_PRELOAD,LD_DEBUG\n"
|
|
|
|
"Note that if you provide several changes to a single variable\n"
|
|
|
|
"the last change will stay in effect.\n");
|
|
|
|
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int parse_args(int argc, char **argv)
|
|
|
|
{
|
|
|
|
const char *r;
|
|
|
|
int optind;
|
2012-05-21 23:56:19 +04:00
|
|
|
const struct qemu_argument *arginfo;
|
2011-08-06 10:54:12 +04:00
|
|
|
|
|
|
|
for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
|
|
|
|
if (arginfo->env == NULL) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = getenv(arginfo->env);
|
|
|
|
if (r != NULL) {
|
|
|
|
arginfo->handle_opt(r);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
optind = 1;
|
|
|
|
for (;;) {
|
|
|
|
if (optind >= argc) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
r = argv[optind];
|
|
|
|
if (r[0] != '-') {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
optind++;
|
|
|
|
r++;
|
|
|
|
if (!strcmp(r, "-")) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
|
|
|
|
if (!strcmp(r, arginfo->argv)) {
|
|
|
|
if (arginfo->has_arg) {
|
2011-09-29 18:48:12 +04:00
|
|
|
if (optind >= argc) {
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
arginfo->handle_opt(argv[optind]);
|
2011-08-06 10:54:12 +04:00
|
|
|
optind++;
|
2011-09-29 18:48:12 +04:00
|
|
|
} else {
|
|
|
|
arginfo->handle_opt(NULL);
|
2011-08-06 10:54:12 +04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* no option matched the current argv */
|
|
|
|
if (arginfo->handle_opt == NULL) {
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (optind >= argc) {
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
|
|
|
|
filename = argv[optind];
|
|
|
|
exec_path = argv[optind];
|
|
|
|
|
|
|
|
return optind;
|
|
|
|
}
|
|
|
|
|
2008-12-10 22:18:40 +03:00
|
|
|
int main(int argc, char **argv, char **envp)
|
2003-02-19 01:55:36 +03:00
|
|
|
{
|
2003-02-19 02:00:51 +03:00
|
|
|
struct target_pt_regs regs1, *regs = ®s1;
|
2003-02-19 01:55:36 +03:00
|
|
|
struct image_info info1, *info = &info1;
|
2009-04-07 10:57:11 +04: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 18:48:57 +04:00
|
|
|
TaskState *ts;
|
2012-03-14 04:38:32 +04:00
|
|
|
CPUArchState *env;
|
2013-06-27 21:49:31 +04:00
|
|
|
CPUState *cpu;
|
2003-03-03 18:02:29 +03:00
|
|
|
int optind;
|
2009-01-30 22:59:17 +03:00
|
|
|
char **target_environ, **wrk;
|
2009-04-15 20:11:52 +04:00
|
|
|
char **target_argv;
|
|
|
|
int target_argc;
|
|
|
|
int i;
|
2009-06-19 11:39:36 +04:00
|
|
|
int ret;
|
2013-08-30 03:46:44 +04:00
|
|
|
int execfd;
|
2007-06-17 20:38:39 +04:00
|
|
|
|
2012-03-05 00:32:36 +04:00
|
|
|
module_call_init(MODULE_INIT_QOM);
|
|
|
|
|
2009-01-30 22:59:17 +03: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-20 00:21:13 +03: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 23:07:35 +04:00
|
|
|
&& lim.rlim_cur != RLIM_INFINITY
|
|
|
|
&& lim.rlim_cur == (target_long)lim.rlim_cur) {
|
2010-03-20 00:21:13 +03:00
|
|
|
guest_stack_size = lim.rlim_cur;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-03-19 11:08:28 +03:00
|
|
|
cpu_model = NULL;
|
2010-02-20 20:14:59 +03:00
|
|
|
#if defined(cpudef_setup)
|
|
|
|
cpudef_setup(); /* parse cpu definitions in target config file (TBD) */
|
|
|
|
#endif
|
|
|
|
|
2014-10-14 19:18:17 +04:00
|
|
|
srand(time(NULL));
|
|
|
|
|
2011-08-06 10:54:12 +04:00
|
|
|
optind = parse_args(argc, argv);
|
2003-03-03 18:02:29 +03:00
|
|
|
|
2003-02-19 01:55:36 +03:00
|
|
|
/* Zero out regs */
|
2003-02-19 02:00:51 +03:00
|
|
|
memset(regs, 0, sizeof(struct target_pt_regs));
|
2003-02-19 01:55:36 +03:00
|
|
|
|
|
|
|
/* Zero out image_info */
|
|
|
|
memset(info, 0, sizeof(struct image_info));
|
|
|
|
|
2009-04-07 10:57:11 +04:00
|
|
|
memset(&bprm, 0, sizeof (bprm));
|
|
|
|
|
2003-04-11 04:13:41 +04:00
|
|
|
/* Scan interp_prefix dir for replacement files. */
|
|
|
|
init_paths(interp_prefix);
|
|
|
|
|
2013-09-03 23:12:20 +04:00
|
|
|
init_qemu_uname_release();
|
|
|
|
|
2007-11-08 16:56:19 +03:00
|
|
|
if (cpu_model == NULL) {
|
2007-11-10 18:15:54 +03:00
|
|
|
#if defined(TARGET_I386)
|
2007-11-08 16:56:19 +03:00
|
|
|
#ifdef TARGET_X86_64
|
|
|
|
cpu_model = "qemu64";
|
|
|
|
#else
|
|
|
|
cpu_model = "qemu32";
|
|
|
|
#endif
|
2007-11-10 18:15:54 +03:00
|
|
|
#elif defined(TARGET_ARM)
|
2009-04-09 19:20:50 +04:00
|
|
|
cpu_model = "any";
|
2011-04-12 12:27:03 +04:00
|
|
|
#elif defined(TARGET_UNICORE32)
|
|
|
|
cpu_model = "any";
|
2007-11-10 18:15:54 +03: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 16:56:19 +03:00
|
|
|
#endif
|
2007-11-10 18:15:54 +03:00
|
|
|
#elif defined(TARGET_MIPS)
|
|
|
|
#if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)
|
2014-11-20 19:00:54 +03:00
|
|
|
cpu_model = "5KEf";
|
2007-11-10 18:15:54 +03:00
|
|
|
#else
|
|
|
|
cpu_model = "24Kf";
|
|
|
|
#endif
|
2012-07-20 11:50:52 +04:00
|
|
|
#elif defined TARGET_OPENRISC
|
|
|
|
cpu_model = "or1200";
|
2007-11-10 18:15:54 +03:00
|
|
|
#elif defined(TARGET_PPC)
|
2014-06-28 20:45:27 +04:00
|
|
|
# ifdef TARGET_PPC64
|
|
|
|
cpu_model = "POWER7";
|
|
|
|
# else
|
2007-11-10 18:15:54 +03:00
|
|
|
cpu_model = "750";
|
2014-06-28 20:45:27 +04:00
|
|
|
# endif
|
2015-05-24 01:06:53 +03:00
|
|
|
#elif defined TARGET_SH4
|
|
|
|
cpu_model = TYPE_SH7785_CPU;
|
2007-11-10 18:15:54 +03:00
|
|
|
#else
|
|
|
|
cpu_model = "any";
|
|
|
|
#endif
|
|
|
|
}
|
2011-08-02 18:10:21 +04:00
|
|
|
tcg_exec_init(0);
|
2004-07-06 01:25:26 +04:00
|
|
|
/* NOTE: we need to init the CPU at this stage to get
|
|
|
|
qemu_host_page_size */
|
2015-02-26 23:37:49 +03:00
|
|
|
cpu = cpu_init(cpu_model);
|
|
|
|
if (!cpu) {
|
2007-11-10 18:15:54 +03:00
|
|
|
fprintf(stderr, "Unable to find CPU definition\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2015-02-26 23:37:49 +03:00
|
|
|
env = cpu->env_ptr;
|
2013-07-26 18:42:25 +04:00
|
|
|
cpu_reset(cpu);
|
2009-11-07 13:37:06 +03:00
|
|
|
|
2013-06-27 21:49:31 +04:00
|
|
|
thread_cpu = cpu;
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2007-11-11 17:46:06 +03:00
|
|
|
if (getenv("QEMU_STRACE")) {
|
|
|
|
do_strace = 1;
|
2007-11-01 03:07:38 +03:00
|
|
|
}
|
|
|
|
|
2014-10-14 19:18:17 +04:00
|
|
|
if (getenv("QEMU_RAND_SEED")) {
|
|
|
|
handle_arg_randseed(getenv("QEMU_RAND_SEED"));
|
|
|
|
}
|
|
|
|
|
2009-01-30 22:59:17 +03:00
|
|
|
target_environ = envlist_to_environ(envlist, NULL);
|
|
|
|
envlist_free(envlist);
|
2007-06-17 20:38:39 +04:00
|
|
|
|
2009-07-17 15:48:08 +04:00
|
|
|
/*
|
|
|
|
* 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 05:27:35 +04:00
|
|
|
|
2012-07-26 20:50:02 +04:00
|
|
|
if (reserved_va || have_guest_base) {
|
|
|
|
guest_base = init_guest_space(guest_base, reserved_va, 0,
|
|
|
|
have_guest_base);
|
|
|
|
if (guest_base == (unsigned long)-1) {
|
2012-08-20 14:36:32 +04:00
|
|
|
fprintf(stderr, "Unable to reserve 0x%lx bytes of virtual address "
|
|
|
|
"space for use as guest address space (check your virtual "
|
|
|
|
"memory ulimit setting or reserve less using -R option)\n",
|
|
|
|
reserved_va);
|
2010-05-29 05:27:35 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
2011-08-31 20:24:34 +04:00
|
|
|
|
2012-07-26 20:50:02 +04:00
|
|
|
if (reserved_va) {
|
|
|
|
mmap_next_start = reserved_va;
|
2011-08-31 20:24:34 +04:00
|
|
|
}
|
|
|
|
}
|
2009-07-17 15:48:08 +04: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 02:39:07 +03:00
|
|
|
* is needed. It is also used in mmap_find_vma.
|
2009-07-17 15:48:08 +04:00
|
|
|
*/
|
2010-03-11 02:39:07 +03:00
|
|
|
{
|
2009-07-17 15:48:08 +04: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 20:11:52 +04: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;
|
|
|
|
|
2011-08-21 07:09:37 +04:00
|
|
|
ts = g_malloc0 (sizeof(TaskState));
|
2009-04-07 10:57:11 +04:00
|
|
|
init_task_state(ts);
|
|
|
|
/* build Task State */
|
|
|
|
ts->info = info;
|
|
|
|
ts->bprm = &bprm;
|
2013-08-26 20:14:44 +04:00
|
|
|
cpu->opaque = ts;
|
2009-04-07 10:57:11 +04:00
|
|
|
task_settid(ts);
|
|
|
|
|
2013-10-16 02:00:36 +04:00
|
|
|
execfd = qemu_getauxval(AT_EXECFD);
|
|
|
|
if (execfd == 0) {
|
2013-08-30 03:46:44 +04:00
|
|
|
execfd = open(filename, O_RDONLY);
|
2013-10-16 02:00:36 +04:00
|
|
|
if (execfd < 0) {
|
|
|
|
printf("Error while loading %s: %s\n", filename, strerror(errno));
|
|
|
|
_exit(1);
|
|
|
|
}
|
2013-08-30 03:46:44 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = loader_exec(execfd, filename, target_argv, target_environ, regs,
|
2009-06-19 11:39:36 +04:00
|
|
|
info, &bprm);
|
|
|
|
if (ret != 0) {
|
2012-08-24 10:55:53 +04:00
|
|
|
printf("Error while loading %s: %s\n", filename, strerror(-ret));
|
2007-06-17 20:38:39 +04:00
|
|
|
_exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (wrk = target_environ; *wrk; wrk++) {
|
|
|
|
free(*wrk);
|
2003-02-19 01:55:36 +03:00
|
|
|
}
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2007-06-17 20:38:39 +04:00
|
|
|
free(target_environ);
|
|
|
|
|
2009-01-20 19:57:34 +03:00
|
|
|
if (qemu_log_enabled()) {
|
2009-07-17 15:48:08 +04:00
|
|
|
qemu_log("guest_base 0x%lx\n", guest_base);
|
2009-01-20 19:57:34 +03: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-19 01:55:36 +03:00
|
|
|
|
2006-03-25 22:31:22 +03:00
|
|
|
target_set_brk(info->brk);
|
2003-02-19 01:55:36 +03:00
|
|
|
syscall_init();
|
2003-03-23 04:06:05 +03:00
|
|
|
signal_init();
|
2003-02-19 01:55:36 +03:00
|
|
|
|
2010-05-06 19:50:41 +04:00
|
|
|
/* 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);
|
|
|
|
|
2003-06-16 00:05:50 +04:00
|
|
|
#if defined(TARGET_I386)
|
2003-07-26 22:02:28 +04:00
|
|
|
env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK;
|
2014-05-15 18:07:04 +04:00
|
|
|
env->hflags |= HF_PE_MASK | HF_CPL_MASK;
|
2013-04-22 23:00:15 +04:00
|
|
|
if (env->features[FEAT_1_EDX] & CPUID_SSE) {
|
2005-01-13 01:34:47 +03:00
|
|
|
env->cr[4] |= CR4_OSFXSR_MASK;
|
|
|
|
env->hflags |= HF_OSFXSR_MASK;
|
|
|
|
}
|
2007-11-14 21:08:56 +03:00
|
|
|
#ifndef TARGET_ABI32
|
2007-11-15 18:27:03 +03:00
|
|
|
/* enable 64 bit mode if possible */
|
2013-04-22 23:00:15 +04:00
|
|
|
if (!(env->features[FEAT_8000_0001_EDX] & CPUID_EXT2_LM)) {
|
2007-11-15 18:27:03 +03:00
|
|
|
fprintf(stderr, "The selected x86 CPU does not support 64 bit mode\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2007-11-14 21:08:56 +03:00
|
|
|
env->cr[4] |= CR4_PAE_MASK;
|
2007-11-15 18:27:03 +03:00
|
|
|
env->efer |= MSR_EFER_LMA | MSR_EFER_LME;
|
2007-11-14 21:08:56 +03:00
|
|
|
env->hflags |= HF_LMA_MASK;
|
|
|
|
#endif
|
2005-01-13 01:34:47 +03:00
|
|
|
|
2004-02-04 02:37:12 +03:00
|
|
|
/* flags setup : we activate the IRQs by default as in user mode */
|
|
|
|
env->eflags |= IF_MASK;
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2003-03-16 21:05:05 +03:00
|
|
|
/* linux register setup */
|
2007-11-14 21:08:56 +03:00
|
|
|
#ifndef TARGET_ABI32
|
2007-04-06 12:56:50 +04: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 17:32:43 +03: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 18:23:14 +03:00
|
|
|
env->eip = regs->eip;
|
2007-04-06 12:56:50 +04:00
|
|
|
#endif
|
2003-02-19 01:55:36 +03:00
|
|
|
|
2003-05-28 03:28:08 +04:00
|
|
|
/* linux interrupt setup */
|
2008-11-10 05:55:33 +03: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 03:28:08 +04:00
|
|
|
set_idt(0, 0);
|
|
|
|
set_idt(1, 0);
|
|
|
|
set_idt(2, 0);
|
|
|
|
set_idt(3, 3);
|
|
|
|
set_idt(4, 3);
|
2008-05-12 16:23:31 +04:00
|
|
|
set_idt(5, 0);
|
2003-05-28 03:28:08 +04: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 21:05:05 +03:00
|
|
|
/* linux segment setup */
|
2007-11-14 18:18:40 +03:00
|
|
|
{
|
|
|
|
uint64_t *gdt_table;
|
2008-11-10 05:55:33 +03: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 18:18:40 +03:00
|
|
|
env->gdt.limit = sizeof(uint64_t) * TARGET_GDT_ENTRIES - 1;
|
2008-11-10 05:55:33 +03:00
|
|
|
gdt_table = g2h(env->gdt.base);
|
2007-11-14 21:08:56 +03:00
|
|
|
#ifdef TARGET_ABI32
|
2007-11-14 18:18:40 +03: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 21:08:56 +03: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 18:18:40 +03: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 21:05:05 +03:00
|
|
|
cpu_x86_load_seg(env, R_CS, __USER_CS);
|
2007-11-14 21:08:56 +03:00
|
|
|
cpu_x86_load_seg(env, R_SS, __USER_DS);
|
|
|
|
#ifdef TARGET_ABI32
|
2003-03-16 21:05:05 +03: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 02:55:02 +04:00
|
|
|
/* This hack makes Wine work... */
|
|
|
|
env->segs[R_FS].selector = 0;
|
2007-11-14 21:08:56 +03: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
|
2013-09-03 23:12:21 +04:00
|
|
|
#elif defined(TARGET_AARCH64)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!(arm_feature(env, ARM_FEATURE_AARCH64))) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"The selected ARM CPU does not support 64 bit mode\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < 31; i++) {
|
|
|
|
env->xregs[i] = regs->regs[i];
|
|
|
|
}
|
|
|
|
env->pc = regs->pc;
|
|
|
|
env->xregs[31] = regs->sp;
|
|
|
|
}
|
2003-06-16 00:05:50 +04:00
|
|
|
#elif defined(TARGET_ARM)
|
|
|
|
{
|
|
|
|
int i;
|
2005-11-26 13:38:39 +03:00
|
|
|
cpsr_write(env, regs->uregs[16], 0xffffffff);
|
2003-06-16 00:05:50 +04:00
|
|
|
for(i = 0; i < 16; i++) {
|
|
|
|
env->regs[i] = regs->uregs[i];
|
|
|
|
}
|
2012-03-30 21:02:50 +04:00
|
|
|
/* Enable BE8. */
|
|
|
|
if (EF_ARM_EABI_VERSION(info->elf_flags) >= EF_ARM_EABI_VER4
|
|
|
|
&& (info->elf_flags & EF_ARM_BE8)) {
|
|
|
|
env->bswap_code = 1;
|
|
|
|
}
|
2003-06-16 00:05:50 +04:00
|
|
|
}
|
2011-04-12 12:27:03 +04: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-10-01 00:57:29 +04:00
|
|
|
#elif defined(TARGET_SPARC)
|
2004-01-04 18:50:01 +03: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 20:05:30 +03:00
|
|
|
#elif defined(TARGET_PPC)
|
|
|
|
{
|
|
|
|
int i;
|
2005-07-03 00:59:34 +04:00
|
|
|
|
2007-10-26 01:35:50 +04:00
|
|
|
#if defined(TARGET_PPC64)
|
|
|
|
#if defined(TARGET_ABI32)
|
|
|
|
env->msr &= ~((target_ulong)1 << MSR_SF);
|
2007-10-18 23:59:49 +04:00
|
|
|
#else
|
2007-10-26 01:35:50 +04:00
|
|
|
env->msr |= (target_ulong)1 << MSR_SF;
|
|
|
|
#endif
|
2007-04-06 12:56:50 +04:00
|
|
|
#endif
|
2003-11-23 20:05:30 +03:00
|
|
|
env->nip = regs->nip;
|
|
|
|
for(i = 0; i < 32; i++) {
|
|
|
|
env->gpr[i] = regs->gpr[i];
|
|
|
|
}
|
|
|
|
}
|
2006-10-22 04:18:54 +04: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 23:31:33 +04: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 21:47:20 +03:00
|
|
|
#elif defined(TARGET_MIPS)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < 32; i++) {
|
2008-06-27 14:02:35 +04:00
|
|
|
env->active_tc.gpr[i] = regs->regs[i];
|
2005-11-26 21:47:20 +03:00
|
|
|
}
|
2010-06-09 00:30:02 +04:00
|
|
|
env->active_tc.PC = regs->cp0_epc & ~(target_ulong)1;
|
|
|
|
if (regs->cp0_epc & 1) {
|
|
|
|
env->hflags |= MIPS_HFLAG_M16;
|
|
|
|
}
|
2005-11-26 21:47:20 +03:00
|
|
|
}
|
2012-07-20 11:50:52 +04:00
|
|
|
#elif defined(TARGET_OPENRISC)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
|
|
env->gpr[i] = regs->gpr[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
env->sr = regs->sr;
|
|
|
|
env->pc = regs->pc;
|
|
|
|
}
|
2006-04-28 01:07:38 +04: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 11:13:51 +04:00
|
|
|
#elif defined(TARGET_ALPHA)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < 28; i++) {
|
2007-10-14 20:27:31 +04:00
|
|
|
env->ir[i] = ((abi_ulong *)regs)[i];
|
2007-04-05 11:13:51 +04:00
|
|
|
}
|
2010-01-04 22:19:14 +03:00
|
|
|
env->ir[IR_SP] = regs->usp;
|
2007-04-05 11:13:51 +04:00
|
|
|
env->pc = regs->pc;
|
|
|
|
}
|
2007-10-08 17:36:46 +04: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 18:57:31 +04: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-16 00:05:50 +04:00
|
|
|
#else
|
|
|
|
#error unsupported target CPU
|
|
|
|
#endif
|
2003-02-19 01:55:36 +03:00
|
|
|
|
2011-04-12 12:27:03 +04:00
|
|
|
#if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32)
|
2007-05-26 19:09:38 +04: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-31 00:01:05 +03:00
|
|
|
if (gdbstub_port) {
|
2011-09-06 17:15:50 +04:00
|
|
|
if (gdbserver_start(gdbstub_port) < 0) {
|
|
|
|
fprintf(stderr, "qemu: could not open gdbserver on port %d\n",
|
|
|
|
gdbstub_port);
|
|
|
|
exit(1);
|
|
|
|
}
|
2013-06-27 21:49:31 +04:00
|
|
|
gdb_handlesig(cpu, 0);
|
2005-04-17 23:16:13 +04:00
|
|
|
}
|
2003-03-22 20:31:38 +03:00
|
|
|
cpu_loop(env);
|
|
|
|
/* never exits */
|
2003-02-19 01:55:36 +03:00
|
|
|
return 0;
|
|
|
|
}
|