Archipelago » qemu

ifeq ($(ARCH),ia64)

OBJS += ia64-syscall.o

endif

all: $(PROGS)

    tb_reset_jump_recursive2(tb, 1);

}

static void breakpoint_invalidate(CPUState *env, target_ulong pc)

{

    target_ulong phys_addr;

   breakpoint is reached */

int cpu_breakpoint_insert(CPUState *env, target_ulong pc)

{

    int i;

    for(i = 0; i < env->nb_breakpoints; i++) {

/* remove a breakpoint */

int cpu_breakpoint_remove(CPUState *env, target_ulong pc)

{

    int i;

    for(i = 0; i < env->nb_breakpoints; i++) {

        if (env->breakpoints[i] == pc)

    }

    return -1;

 found:

    env->nb_breakpoints--;

    breakpoint_invalidate(env, pc);

    return 0;

   CPU loop after each instruction */

void cpu_single_step(CPUState *env, int enabled)

{

    if (env->singlestep_enabled != enabled) {

        env->singlestep_enabled = enabled;

        /* must flush all the translated code to avoid inconsistancies */

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include "vl.h"

#include <sys/socket.h>

#include <netinet/in.h>

    RS_GETLINE,

    RS_CHKSUM1,

    RS_CHKSUM2,

};

typedef struct GDBState {

    enum RSState state;

    int line_csum;

} GDBState;

static int get_char(GDBState *s)

{

    uint8_t ch;

    env->npc = tswapl(registers[69]);

    env->fsr = tswapl(registers[70]);

}

static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)

{

    return 0;

#endif

{

    const char *p;

    int ch, reg_size, type;

    char buf[4096];

    ch = *p++;

    switch(ch) {

    case '?':

        snprintf(buf, sizeof(buf), "S%02x", SIGTRAP);

        put_packet(s, buf);

        break;

            env->npc = addr + 4;

#endif

        }

    case 's':

        if (*p != '\0') {

            addr = strtoul(p, (char **)&p, 16);

#endif

        }

        cpu_single_step(env, 1);

    case 'g':

        reg_size = cpu_gdb_read_registers(env, mem_buf);

        memtohex(buf, mem_buf, reg_size);

extern void tb_flush(CPUState *env);

static void gdb_vm_stopped(void *opaque, int reason)

{

    GDBState *s = opaque;

    snprintf(buf, sizeof(buf), "S%02x", ret);

    put_packet(s, buf);

}

{

    int i, csum;

    char reply[1];

    if (vm_running) {

        /* when the CPU is running, we cannot do anything except stop

           it when receiving a char */

        vm_stop(EXCP_INTERRUPT);

    } else {

        switch(s->state) {

        case RS_IDLE:

            if (ch == '$') {

            } else {

                reply[0] = '+';

                put_buffer(s, reply, 1);

            }

            break;

        }

    }

}

static int gdb_can_read(void *opaque)

{

    return 256;

        vm_start();

    } else {

        for(i = 0; i < size; i++)

    }

}

static void gdb_accept(void *opaque, const uint8_t *buf, int size)

{

    GDBState *s;

    val = 1;

    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));

    s = qemu_mallocz(sizeof(GDBState));

    if (!s) {

        close(fd);

        return;

    }

    s->fd = fd;

    fcntl(fd, F_SETFL, O_NONBLOCK);

    /* stop the VM */

    vm_stop(EXCP_INTERRUPT);

    qemu_add_fd_read_handler(s->fd, gdb_can_read, gdb_read, s);

    /* when the VM is stopped, the following callback is called */

    qemu_add_vm_stop_handler(gdb_vm_stopped, s);

}

static int gdbserver_open(int port)

        perror("listen");

        return -1;

    }

    fcntl(fd, F_SETFL, O_NONBLOCK);

    return fd;

}

    if (gdbserver_fd < 0)

        return -1;

    /* accept connections */

    qemu_add_fd_read_handler(gdbserver_fd, NULL, gdb_accept, NULL);

    return 0;

}

        case EXCP_INTERRUPT:

            /* just indicate that signals should be handled asap */

            break;

        default:

            pc = env->segs[R_CS].base + env->eip;

            fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n", 

                queue_signal(info.si_signo, &info);

            }

            break;

        default:

        error:

            fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", 

            break;

	case 0x100: // XXX, why do we get these?

	    break;

        default:

            printf ("Unhandled trap: 0x%x\n", trapnr);

            cpu_dump_state(env, stderr, fprintf, 0);

        case EXCP_INTERRUPT:

            /* Don't know why this should ever happen... */

            break;

        default:

            fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", 

                    trapnr);

void usage(void)

{

    printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003-2004 Fabrice Bellard\n"

           "Linux CPU emulator (compiled for %s emulation)\n"

           "\n"

           "-h           print this help\n"

           "-L path      set the elf interpreter prefix (default=%s)\n"

           "-s size      set the stack size in bytes (default=%ld)\n"

           "\n"

           "-d options   activate log (logfile=%s)\n"

           "-p pagesize  set the host page size to 'pagesize'\n",

           TARGET_ARCH,

           interp_prefix, 

           x86_stack_size,

           DEBUG_LOGFILE);

    CPUState *env;

    int optind;

    const char *r;

    if (argc <= 1)

        usage();

                fprintf(stderr, "page size must be a power of two\n");

                exit(1);

            }

        } else 

#ifdef USE_CODE_COPY

        if (!strcmp(r, "no-code-copy")) {

#error unsupported target CPU

#endif

    cpu_loop(env);

    /* never exits */

    return 0;

#include "cpu.h"

#include "syscall.h"

/* This struct is used to hold certain information about the image.

 * Basically, it replicates in user space what would be certain

    k->first = q->next;

    if (!k->first)

        k->pending = 0;

    handler = k->sa._sa_handler;

    if (handler == TARGET_SIG_DFL) {

#include "softfloat.h"

#define EXCP_UDEF            1   /* undefined instruction */

#define EXCP_SWI             2   /* software interrupt */

#define EXCP_PREFETCH_ABORT  3

    int user_mode_only;

    uint32_t address;

    /* in order to avoid passing too many arguments to the memory

       write helpers, we store some rarely used information in the CPU

       context) */

    cpu_loop_exit();

}

/* VFP support.  We follow the convention used for VFP instrunctions:

   Single precition routines have a "s" suffix, double precision a

   "d" suffix.  */

    dc->pc = pc_start;

    lj = -1;

    do {

        if (search_pc) {

            j = gen_opc_ptr - gen_opc_buf;

            if (lj < j) {

          disas_thumb_insn(dc);

        else

          disas_arm_insn(env, dc);

             (dc->pc - pc_start) < (TARGET_PAGE_SIZE - 32));

    switch(dc->is_jmp) {

    case DISAS_JUMP_NEXT:

   close to the modifying instruction */

#define TARGET_HAS_PRECISE_SMC

#include "cpu-defs.h"

#include "softfloat.h"

#include "softfloat.h"

/* Instruction types */

enum {

    PPC_NONE     = 0x0000,

#include "softfloat.h"

/*#define EXCP_INTERRUPT 0x100*/

/* trap definitions */

#else

#include "cpu.h"

#endif /* !defined(QEMU_TOOL) */

void readline_start(const char *prompt, int is_password,

                    ReadLineFunc *readline_func, void *opaque);

#endif /* VL_H */