Commit a87295e8 authored by pbrook's avatar pbrook
Browse files

M68k system mode semihosting.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@2861 c046a42c-6fe2-441c-8c8c-71466251a162
parent 20c9f095
......@@ -468,6 +468,7 @@ VL_OBJS+= shix.o sh7750.o sh7750_regnames.o tc58128.o
endif
ifeq ($(TARGET_BASE_ARCH), m68k)
VL_OBJS+= an5206.o mcf5206.o ptimer.o
VL_OBJS+= m68k-semi.o
endif
ifdef CONFIG_GDBSTUB
VL_OBJS+=gdbstub.o
......
......@@ -112,57 +112,7 @@ static inline uint32_t set_swi_errno(CPUState *env, uint32_t code)
return code;
}
static uint32_t softmmu_tget32(CPUState *env, uint32_t addr)
{
uint32_t val;
cpu_memory_rw_debug(env, addr, (uint8_t *)&val, 4, 0);
return tswap32(val);
}
static uint32_t softmmu_tget8(CPUState *env, uint32_t addr)
{
uint8_t val;
cpu_memory_rw_debug(env, addr, &val, 1, 0);
return val;
}
#define tget32(p) softmmu_tget32(env, p)
#define tget8(p) softmmu_tget8(env, p)
static void *softmmu_lock_user(CPUState *env, uint32_t addr, uint32_t len,
int copy)
{
char *p;
/* TODO: Make this something that isn't fixed size. */
p = malloc(len);
if (copy)
cpu_memory_rw_debug(env, addr, p, len, 0);
return p;
}
#define lock_user(p, len, copy) softmmu_lock_user(env, p, len, copy)
static char *softmmu_lock_user_string(CPUState *env, uint32_t addr)
{
char *p;
char *s;
uint8_t c;
/* TODO: Make this something that isn't fixed size. */
s = p = malloc(1024);
do {
cpu_memory_rw_debug(env, addr, &c, 1, 0);
addr++;
*(p++) = c;
} while (c);
return s;
}
#define lock_user_string(p) softmmu_lock_user_string(env, p)
static void softmmu_unlock_user(CPUState *env, void *p, target_ulong addr,
target_ulong len)
{
if (len)
cpu_memory_rw_debug(env, addr, p, len, 1);
free(p);
}
#define unlock_user(s, args, len) softmmu_unlock_user(env, s, args, len)
#include "softmmu-semi.h"
#endif
static target_ulong arm_semi_syscall_len;
......
......@@ -963,14 +963,16 @@ static void gdb_vm_stopped(void *opaque, int reason)
/* Send a gdb syscall request.
This accepts limited printf-style format specifiers, specifically:
%x - target_ulong argument printed in hex.
%s - string pointer (target_ulong) and length (int) pair. */
%x - target_ulong argument printed in hex.
%lx - 64-bit argument printed in hex.
%s - string pointer (target_ulong) and length (int) pair. */
void gdb_do_syscall(gdb_syscall_complete_cb cb, char *fmt, ...)
{
va_list va;
char buf[256];
char *p;
target_ulong addr;
uint64_t i64;
GDBState *s;
s = gdb_syscall_state;
......@@ -993,11 +995,18 @@ void gdb_do_syscall(gdb_syscall_complete_cb cb, char *fmt, ...)
addr = va_arg(va, target_ulong);
p += sprintf(p, TARGET_FMT_lx, addr);
break;
case 'l':
if (*(fmt++) != 'x')
goto bad_format;
i64 = va_arg(va, uint64_t);
p += sprintf(p, "%" PRIx64, i64);
break;
case 's':
addr = va_arg(va, target_ulong);
p += sprintf(p, TARGET_FMT_lx "/%x", addr, va_arg(va, int));
break;
default:
bad_format:
fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
fmt - 1);
break;
......
......@@ -1502,9 +1502,9 @@ void cpu_loop(CPUM68KState *env)
}
}
break;
case EXCP_HALTED:
case EXCP_HALT_INSN:
/* Semihosing syscall. */
env->pc += 2;
env->pc += 4;
do_m68k_semihosting(env, env->dregs[0]);
break;
case EXCP_LINEA:
......@@ -1918,10 +1918,6 @@ int main(int argc, char **argv)
for(i = 0; i < 16; i++) {
env->regs[i] = regs->uregs[i];
}
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;
}
#elif defined(TARGET_SPARC)
{
......@@ -2049,6 +2045,13 @@ int main(int argc, char **argv)
#error unsupported target CPU
#endif
#if defined(TARGET_ARM) || defined(TARGET_M68K)
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
if (gdbstub_port) {
gdbserver_start (gdbstub_port);
gdb_handlesig(env, 0);
......
......@@ -62,10 +62,6 @@ typedef struct TaskState {
#ifdef TARGET_ARM
/* FPA state */
FPA11 fpa;
/* Extra fields for semihosted binaries. */
uint32_t stack_base;
uint32_t heap_base;
uint32_t heap_limit;
int swi_errno;
#endif
#if defined(TARGET_I386) && !defined(TARGET_X86_64)
......@@ -77,6 +73,12 @@ typedef struct TaskState {
#endif
#ifdef TARGET_M68K
int sim_syscalls;
#endif
#if defined(TARGET_ARM) || defined(TARGET_M68K)
/* Extra fields for semihosted binaries. */
uint32_t stack_base;
uint32_t heap_base;
uint32_t heap_limit;
#endif
int used; /* non zero if used */
struct image_info *info;
......
/*
* m68k/ColdFire Semihosting ssycall interface
* m68k/ColdFire Semihosting syscall interface
*
* Copyright (c) 2005 CodeSourcery, LLC. Written by Paul Brook.
* Copyright (c) 2005-2007 CodeSourcery.
*
* 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
......@@ -28,10 +28,17 @@
#include <sys/time.h>
#include <time.h>
#include "cpu.h"
#if defined(CONFIG_USER_ONLY)
#include "qemu.h"
#define SEMIHOSTING_HEAP_SIZE (128 * 1024 * 1024)
#else
#include "vl.h"
#include "softmmu-semi.h"
#endif
#define HOSTED_EXIT 0
#define HOSTED_PUTCHAR 1 /* Obsolete */
#define HOSTED_INIT_SIM 1
#define HOSTED_OPEN 2
#define HOSTED_CLOSE 3
#define HOSTED_READ 4
......@@ -62,12 +69,12 @@ struct m68k_gdb_stat {
gdb_time_t gdb_st_atime; /* time of last access */
gdb_time_t gdb_st_mtime; /* time of last modification */
gdb_time_t gdb_st_ctime; /* time of last change */
};
} __attribute__((packed));
struct gdb_timeval {
gdb_time_t tv_sec; /* second */
uint64_t tv_usec; /* microsecond */
};
} __attribute__((packed));
#define GDB_O_RDONLY 0x0
#define GDB_O_WRONLY 0x1
......@@ -96,121 +103,251 @@ static int translate_openflags(int flags)
return hf;
}
static void translate_stat(struct m68k_gdb_stat *p, struct stat *s)
static void translate_stat(CPUState *env, target_ulong addr, struct stat *s)
{
p->gdb_st_dev = tswap16(s->st_dev);
p->gdb_st_ino = tswap16(s->st_ino);
p->gdb_st_mode = tswap32(s->st_mode);
p->gdb_st_nlink = tswap16(s->st_nlink);
p->gdb_st_uid = tswap16(s->st_uid);
p->gdb_st_gid = tswap16(s->st_gid);
p->gdb_st_rdev = tswap16(s->st_rdev);
p->gdb_st_size = tswap32(s->st_size);
p->gdb_st_atime = tswap32(s->st_atime);
p->gdb_st_mtime = tswap32(s->st_mtime);
p->gdb_st_ctime = tswap32(s->st_ctime);
p->gdb_st_blksize = tswap32(s->st_blksize);
p->gdb_st_blocks = tswap32(s->st_blocks);
struct m68k_gdb_stat *p;
p = lock_user(addr, sizeof(struct m68k_gdb_stat), 0);
p->gdb_st_dev = cpu_to_be32(s->st_dev);
p->gdb_st_ino = cpu_to_be32(s->st_ino);
p->gdb_st_mode = cpu_to_be32(s->st_mode);
p->gdb_st_nlink = cpu_to_be32(s->st_nlink);
p->gdb_st_uid = cpu_to_be32(s->st_uid);
p->gdb_st_gid = cpu_to_be32(s->st_gid);
p->gdb_st_rdev = cpu_to_be32(s->st_rdev);
p->gdb_st_size = cpu_to_be64(s->st_size);
p->gdb_st_blksize = cpu_to_be64(s->st_blksize);
p->gdb_st_blocks = cpu_to_be64(s->st_blocks);
p->gdb_st_atime = cpu_to_be32(s->st_atime);
p->gdb_st_mtime = cpu_to_be32(s->st_mtime);
p->gdb_st_ctime = cpu_to_be32(s->st_ctime);
unlock_user(p, addr, sizeof(struct m68k_gdb_stat));
}
static inline uint32_t check_err(CPUM68KState *env, uint32_t code)
static int m68k_semi_is_fseek;
static void m68k_semi_cb(CPUState *env, target_ulong ret, target_ulong err)
{
if (code == (uint32_t)-1) {
env->sr |= CCF_C;
} else {
env->sr &= ~CCF_C;
env->dregs[0] = code;
}
return code;
target_ulong args;
args = env->dregs[1];
if (m68k_semi_is_fseek) {
/* FIXME: We've already lost the high bits of the fseek
return value. */
tput32(args, 0);
args += 4;
m68k_semi_is_fseek = 0;
}
tput32(args, ret);
tput32(args + 4, errno);
}
#define ARG(x) tswap32(args[x])
#define ARG(x) tget32(args + (x) * 4)
#define PARG(x) ((unsigned long)ARG(x))
void do_m68k_semihosting(CPUM68KState *env, int nr)
{
uint32_t *args;
uint32_t args;
void *p;
void *q;
uint32_t len;
uint32_t result;
args = (uint32_t *)env->dregs[1];
args = env->dregs[1];
switch (nr) {
case HOSTED_EXIT:
exit(env->dregs[0]);
case HOSTED_OPEN:
/* Assume name is NULL terminated. */
check_err(env, open((char *)ARG(0), translate_openflags(ARG(2)),
ARG(3)));
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "open,%s,%x,%x", ARG(0), (int)ARG(1),
ARG(2), ARG(3));
return;
} else {
p = lock_user_string(ARG(0));
result = open(p, translate_openflags(ARG(2)), ARG(3));
unlock_user(p, ARG(0), 0);
}
break;
case HOSTED_CLOSE:
{
/* Ignore attempts to close stdin/out/err. */
int fd = ARG(0);
if (fd > 2)
check_err(env, close(fd));
else
check_err(env, 0);
if (fd > 2) {
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "close,%x", ARG(0));
return;
} else {
result = close(fd);
}
} else {
result = 0;
}
break;
}
case HOSTED_READ:
check_err(env, read(ARG(0), (void *)ARG(1), ARG(2)));
len = ARG(2);
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "read,%x,%x,%x",
ARG(0), ARG(1), len);
return;
} else {
p = lock_user(ARG(1), len, 0);
result = read(ARG(0), p, len);
unlock_user(p, ARG(1), len);
}
break;
case HOSTED_WRITE:
check_err(env, write(ARG(0), (void *)ARG(1), ARG(2)));
len = ARG(2);
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "write,%x,%x,%x",
ARG(0), ARG(1), len);
return;
} else {
p = lock_user(ARG(1), len, 1);
result = write(ARG(0), p, len);
unlock_user(p, ARG(0), 0);
}
break;
case HOSTED_LSEEK:
{
uint64_t off;
off = (uint32_t)ARG(2) | ((uint64_t)ARG(1) << 32);
check_err(env, lseek(ARG(0), off, ARG(3)));
if (use_gdb_syscalls()) {
m68k_semi_is_fseek = 1;
gdb_do_syscall(m68k_semi_cb, "fseek,%x,%lx,%x",
ARG(0), off, ARG(3));
} else {
off = lseek(ARG(0), off, ARG(3));
tput32(args, off >> 32);
tput32(args + 4, off);
tput32(args + 8, errno);
}
return;
}
break;
case HOSTED_RENAME:
/* Assume names are NULL terminated. */
check_err(env, rename((char *)ARG(0), (char *)ARG(2)));
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "rename,%s,%s",
ARG(0), (int)ARG(1), ARG(2), (int)ARG(3));
return;
} else {
p = lock_user_string(ARG(0));
q = lock_user_string(ARG(2));
result = rename(p, q);
unlock_user(p, ARG(0), 0);
unlock_user(q, ARG(2), 0);
}
break;
case HOSTED_UNLINK:
/* Assume name is NULL terminated. */
check_err(env, unlink((char *)ARG(0)));
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "unlink,%s",
ARG(0), (int)ARG(1));
return;
} else {
p = lock_user_string(ARG(0));
result = unlink(p);
unlock_user(p, ARG(0), 0);
}
break;
case HOSTED_STAT:
/* Assume name is NULL terminated. */
{
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "stat,%s,%x",
ARG(0), (int)ARG(1), ARG(2));
return;
} else {
struct stat s;
int rc;
rc = check_err(env, stat((char *)ARG(0), &s));
if (rc == 0) {
translate_stat((struct m68k_gdb_stat *)ARG(2), &s);
p = lock_user_string(ARG(0));
result = stat(p, &s);
unlock_user(p, ARG(0), 0);
if (result == 0) {
translate_stat(env, ARG(2), &s);
}
}
break;
case HOSTED_FSTAT:
{
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "fstat,%x,%x",
ARG(0), ARG(1));
return;
} else {
struct stat s;
int rc;
rc = check_err(env, fstat(ARG(0), &s));
if (rc == 0) {
translate_stat((struct m68k_gdb_stat *)ARG(1), &s);
result = fstat(ARG(0), &s);
if (result == 0) {
translate_stat(env, ARG(1), &s);
}
}
break;
case HOSTED_GETTIMEOFDAY:
{
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "gettimeofday,%x,%x",
ARG(0), ARG(1));
return;
} else {
struct timeval tv;
struct gdb_timeval *p;
int rc;
rc = check_err(env, gettimeofday(&tv, NULL));
if (rc != 0) {
p = (struct gdb_timeval *)ARG(0);
p->tv_sec = tswap32(tv.tv_sec);
p->tv_usec = tswap64(tv.tv_usec);
result = gettimeofday(&tv, NULL);
if (result != 0) {
p = lock_user(ARG(0), sizeof(struct gdb_timeval), 0);
p->tv_sec = cpu_to_be32(tv.tv_sec);
p->tv_usec = cpu_to_be64(tv.tv_usec);
unlock_user(p, ARG(0), sizeof(struct gdb_timeval));
}
}
break;
case HOSTED_ISATTY:
check_err(env, isatty(ARG(0)));
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "isatty,%x", ARG(0));
return;
} else {
result = isatty(ARG(0));
}
break;
case HOSTED_SYSTEM:
/* Assume name is NULL terminated. */
check_err(env, system((char *)ARG(0)));
if (use_gdb_syscalls()) {
gdb_do_syscall(m68k_semi_cb, "system,%s",
ARG(0), (int)ARG(1));
return;
} else {
p = lock_user_string(ARG(0));
result = system(p);
unlock_user(p, ARG(0), 0);
}
break;
case HOSTED_INIT_SIM:
#if defined(CONFIG_USER_ONLY)
{
TaskState *ts = env->opaque;
/* Allocate the heap using sbrk. */
if (!ts->heap_limit) {
long ret;
uint32_t size;
uint32_t base;
base = do_brk(0);
size = SEMIHOSTING_HEAP_SIZE;
/* Try a big heap, and reduce the size if that fails. */
for (;;) {
ret = do_brk(base + size);
if (ret != -1)
break;
size >>= 1;
}
ts->heap_limit = base + size;
}
/* This call may happen before we have writable memory, so return
values directly in registers. */
env->dregs[1] = ts->heap_limit;
env->aregs[7] = ts->stack_base;
}
#else
/* FIXME: This is wrong for boards where RAM does not start at
address zero. */
env->dregs[1] = ram_size;
env->aregs[7] = ram_size;
#endif
return;
default:
cpu_abort(env, "Unsupported semihosting syscall %d\n", nr);
result = 0;
}
tput32(args, result);
tput32(args + 4, errno);
}
......@@ -715,7 +715,11 @@ Exit instead of rebooting.
Start right away with a saved state (@code{loadvm} in monitor)
@item -semihosting
Enable "Angel" semihosting interface (ARM target machines only).
Enable semihosting syscall emulation (ARM and M68K target machines only).
On ARM this implements the "Angel" interface.
On M68K this implements the "ColdFire GDB" interface used by libgloss.
Note that this allows guest direct access to the host filesystem,
so should only be used with trusted guest OS.
@end table
......
......@@ -51,6 +51,7 @@
#define EXCP_ICE 13
#define EXCP_RTE 0x100
#define EXCP_HALT_INSN 0x101
typedef struct CPUM68KState {
uint32_t dregs[8];
......@@ -148,6 +149,8 @@ void m68k_set_irq_level(CPUM68KState *env, int level, uint8_t vector);
#define M68K_FPCR_PREC (1 << 6)
void do_m68k_semihosting(CPUM68KState *env, int nr);
#ifdef CONFIG_USER_ONLY
/* Linux uses 8k pages. */
#define TARGET_PAGE_BITS 13
......
......@@ -383,7 +383,14 @@ OP(divs)
FORCE_RET();
}
/* Halt is special because it may be a semihosting call. */
OP(halt)
{
RAISE_EXCEPTION(EXCP_HALT_INSN);
FORCE_RET();
}
OP(stop)
{
env->halted = 1;
RAISE_EXCEPTION(EXCP_HLT);
......
......@@ -28,6 +28,8 @@ void do_interrupt(int is_hw)
#else
extern int semihosting_enabled;
#define MMUSUFFIX _mmu
#define GETPC() (__builtin_return_address(0))
......@@ -104,6 +106,20 @@ void do_interrupt(int is_hw)
/* Return from an exception. */
do_rte();
return;
case EXCP_HALT_INSN:
if (semihosting_enabled
&& (env->sr & SR_S) != 0
&& (env->pc & 3) == 0
&& lduw_code(env->pc - 4) == 0x4e71
&& ldl_code(env->pc) == 0x4e7bf000) {
env->pc += 4;
do_m68k_semihosting(env, env->dregs[0]);
return;
}
env->halted = 1;
env->exception_index = EXCP_HLT;
cpu_loop_exit();
return;
}
if (env->exception_index >= EXCP_TRAP0
&& env->exception_index <= EXCP_TRAP15) {
......
......@@ -1901,7 +1901,6 @@ DISAS_INSN(move_to_usp)
DISAS_INSN(halt)
{
gen_flush_cc_op(s);
gen_jmp(s, gen_im32(s->pc));
gen_op_halt();
}
......@@ -1919,7 +1918,8 @@ DISAS_INSN(stop)
s->pc += 2;
gen_set_sr_im(s, ext, 0);
disas_halt(s, insn);
gen_jmp(s, gen_im32(s->pc));
gen_op_stop();
}
DISAS_INSN(rte)
......
......@@ -6865,7 +