Archipelago » qemu

/*

 * gdb server stub

 *

 * Copyright (c) 2003-2005 Fabrice Bellard

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include "qemu-common.h"

#ifdef CONFIG_USER_ONLY

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#include "qemu.h"

#else

#include "monitor.h"

#include "qemu-char.h"

#include "sysemu.h"

#include "gdbstub.h"

#endif

#define MAX_PACKET_LENGTH 4096

#include "exec-all.h"

#include "qemu_socket.h"

#include "kvm.h"

enum {

    GDB_SIGNAL_0 = 0,

    GDB_SIGNAL_INT = 2,

    GDB_SIGNAL_TRAP = 5,

    GDB_SIGNAL_UNKNOWN = 143

};

#ifdef CONFIG_USER_ONLY

/* Map target signal numbers to GDB protocol signal numbers and vice

 * versa.  For user emulation's currently supported systems, we can

 * assume most signals are defined.

 */

static int gdb_signal_table[] = {

    0,

    TARGET_SIGHUP,

    TARGET_SIGINT,

    TARGET_SIGQUIT,

    TARGET_SIGILL,

    TARGET_SIGTRAP,

    TARGET_SIGABRT,

    -1, /* SIGEMT */

    TARGET_SIGFPE,

    TARGET_SIGKILL,

    TARGET_SIGBUS,

    TARGET_SIGSEGV,

    TARGET_SIGSYS,

    TARGET_SIGPIPE,

    TARGET_SIGALRM,

    TARGET_SIGTERM,

    TARGET_SIGURG,

    TARGET_SIGSTOP,

    TARGET_SIGTSTP,

    TARGET_SIGCONT,

    TARGET_SIGCHLD,

    TARGET_SIGTTIN,

    TARGET_SIGTTOU,

    TARGET_SIGIO,

    TARGET_SIGXCPU,

    TARGET_SIGXFSZ,

    TARGET_SIGVTALRM,

    TARGET_SIGPROF,

    TARGET_SIGWINCH,

    -1, /* SIGLOST */

    TARGET_SIGUSR1,

    TARGET_SIGUSR2,

#ifdef TARGET_SIGPWR

    TARGET_SIGPWR,

#else

    -1,

#endif

    -1, /* SIGPOLL */

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

#ifdef __SIGRTMIN

    __SIGRTMIN + 1,

    __SIGRTMIN + 2,

    __SIGRTMIN + 3,

    __SIGRTMIN + 4,

    __SIGRTMIN + 5,

    __SIGRTMIN + 6,

    __SIGRTMIN + 7,

    __SIGRTMIN + 8,

    __SIGRTMIN + 9,

    __SIGRTMIN + 10,

    __SIGRTMIN + 11,

    __SIGRTMIN + 12,

    __SIGRTMIN + 13,

    __SIGRTMIN + 14,

    __SIGRTMIN + 15,

    __SIGRTMIN + 16,

    __SIGRTMIN + 17,

    __SIGRTMIN + 18,

    __SIGRTMIN + 19,

    __SIGRTMIN + 20,

    __SIGRTMIN + 21,

    __SIGRTMIN + 22,

    __SIGRTMIN + 23,

    __SIGRTMIN + 24,

    __SIGRTMIN + 25,

    __SIGRTMIN + 26,

    __SIGRTMIN + 27,

    __SIGRTMIN + 28,

    __SIGRTMIN + 29,

    __SIGRTMIN + 30,

    __SIGRTMIN + 31,

    -1, /* SIGCANCEL */

    __SIGRTMIN,

    __SIGRTMIN + 32,

    __SIGRTMIN + 33,

    __SIGRTMIN + 34,

    __SIGRTMIN + 35,

    __SIGRTMIN + 36,

    __SIGRTMIN + 37,

    __SIGRTMIN + 38,

    __SIGRTMIN + 39,

    __SIGRTMIN + 40,

    __SIGRTMIN + 41,

    __SIGRTMIN + 42,

    __SIGRTMIN + 43,

    __SIGRTMIN + 44,

    __SIGRTMIN + 45,

    __SIGRTMIN + 46,

    __SIGRTMIN + 47,

    __SIGRTMIN + 48,

    __SIGRTMIN + 49,

    __SIGRTMIN + 50,

    __SIGRTMIN + 51,

    __SIGRTMIN + 52,

    __SIGRTMIN + 53,

    __SIGRTMIN + 54,

    __SIGRTMIN + 55,

    __SIGRTMIN + 56,

    __SIGRTMIN + 57,

    __SIGRTMIN + 58,

    __SIGRTMIN + 59,

    __SIGRTMIN + 60,

    __SIGRTMIN + 61,

    __SIGRTMIN + 62,

    __SIGRTMIN + 63,

    __SIGRTMIN + 64,

    __SIGRTMIN + 65,

    __SIGRTMIN + 66,

    __SIGRTMIN + 67,

    __SIGRTMIN + 68,

    __SIGRTMIN + 69,

    __SIGRTMIN + 70,

    __SIGRTMIN + 71,

    __SIGRTMIN + 72,

    __SIGRTMIN + 73,

    __SIGRTMIN + 74,

    __SIGRTMIN + 75,

    __SIGRTMIN + 76,

    __SIGRTMIN + 77,

    __SIGRTMIN + 78,

    __SIGRTMIN + 79,

    __SIGRTMIN + 80,

    __SIGRTMIN + 81,

    __SIGRTMIN + 82,

    __SIGRTMIN + 83,

    __SIGRTMIN + 84,

    __SIGRTMIN + 85,

    __SIGRTMIN + 86,

    __SIGRTMIN + 87,

    __SIGRTMIN + 88,

    __SIGRTMIN + 89,

    __SIGRTMIN + 90,

    __SIGRTMIN + 91,

    __SIGRTMIN + 92,

    __SIGRTMIN + 93,

    __SIGRTMIN + 94,

    __SIGRTMIN + 95,

    -1, /* SIGINFO */

    -1, /* UNKNOWN */

    -1, /* DEFAULT */

    -1,

    -1,

    -1,

    -1,

    -1,

    -1

#endif

};

#else

/* In system mode we only need SIGINT and SIGTRAP; other signals

   are not yet supported.  */

enum {

    TARGET_SIGINT = 2,

    TARGET_SIGTRAP = 5

};

static int gdb_signal_table[] = {

    -1,

    -1,

    TARGET_SIGINT,

    -1,

    -1,

    TARGET_SIGTRAP

};

#endif

#ifdef CONFIG_USER_ONLY

static int target_signal_to_gdb (int sig)

{

    int i;

    for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)

        if (gdb_signal_table[i] == sig)

            return i;

    return GDB_SIGNAL_UNKNOWN;

}

#endif

static int gdb_signal_to_target (int sig)

{

    if (sig < ARRAY_SIZE (gdb_signal_table))

        return gdb_signal_table[sig];

    else

        return -1;

}

//#define DEBUG_GDB

typedef struct GDBRegisterState {

    int base_reg;

    int num_regs;

    gdb_reg_cb get_reg;

    gdb_reg_cb set_reg;

    const char *xml;

    struct GDBRegisterState *next;

} GDBRegisterState;

enum RSState {

    RS_INACTIVE,

    RS_IDLE,

    RS_GETLINE,

    RS_CHKSUM1,

    RS_CHKSUM2,

    RS_SYSCALL,

};

typedef struct GDBState {

    CPUState *c_cpu; /* current CPU for step/continue ops */

    CPUState *g_cpu; /* current CPU for other ops */

    CPUState *query_cpu; /* for q{f|s}ThreadInfo */

    enum RSState state; /* parsing state */

    char line_buf[MAX_PACKET_LENGTH];

    int line_buf_index;

    int line_csum;

    uint8_t last_packet[MAX_PACKET_LENGTH + 4];

    int last_packet_len;

    int signal;

#ifdef CONFIG_USER_ONLY

    int fd;

    int running_state;

#else

    CharDriverState *chr;

    CharDriverState *mon_chr;

#endif

} GDBState;

/* By default use no IRQs and no timers while single stepping so as to

 * make single stepping like an ICE HW step.

 */

static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;

static GDBState *gdbserver_state;

/* This is an ugly hack to cope with both new and old gdb.

   If gdb sends qXfer:features:read then assume we're talking to a newish

   gdb that understands target descriptions.  */

static int gdb_has_xml;

#ifdef CONFIG_USER_ONLY

/* XXX: This is not thread safe.  Do we care?  */

static int gdbserver_fd = -1;

static int get_char(GDBState *s)

{

    uint8_t ch;

    int ret;

    for(;;) {

        ret = recv(s->fd, &ch, 1, 0);

        if (ret < 0) {

            if (errno == ECONNRESET)

                s->fd = -1;

            if (errno != EINTR && errno != EAGAIN)

                return -1;

        } else if (ret == 0) {

            close(s->fd);

            s->fd = -1;

            return -1;

        } else {

            break;

        }

    }

    return ch;

}

#endif

static gdb_syscall_complete_cb gdb_current_syscall_cb;

static enum {

    GDB_SYS_UNKNOWN,

    GDB_SYS_ENABLED,

    GDB_SYS_DISABLED,

} gdb_syscall_mode;

/* If gdb is connected when the first semihosting syscall occurs then use

   remote gdb syscalls.  Otherwise use native file IO.  */

int use_gdb_syscalls(void)

{

    if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {

        gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED

                                            : GDB_SYS_DISABLED);

    }

    return gdb_syscall_mode == GDB_SYS_ENABLED;

}

/* Resume execution.  */

static inline void gdb_continue(GDBState *s)

{

#ifdef CONFIG_USER_ONLY

    s->running_state = 1;

#else

    vm_start();

#endif

}

static void put_buffer(GDBState *s, const uint8_t *buf, int len)

{

#ifdef CONFIG_USER_ONLY

    int ret;

    while (len > 0) {

        ret = send(s->fd, buf, len, 0);

        if (ret < 0) {

            if (errno != EINTR && errno != EAGAIN)

                return;

        } else {

            buf += ret;

            len -= ret;

        }

    }

#else

    qemu_chr_write(s->chr, buf, len);

#endif

}

static inline int fromhex(int v)

{

    if (v >= '0' && v <= '9')

        return v - '0';

    else if (v >= 'A' && v <= 'F')

        return v - 'A' + 10;

    else if (v >= 'a' && v <= 'f')

        return v - 'a' + 10;

    else

        return 0;

}

static inline int tohex(int v)

{

    if (v < 10)

        return v + '0';

    else

        return v - 10 + 'a';

}

static void memtohex(char *buf, const uint8_t *mem, int len)

{

    int i, c;

    char *q;

    q = buf;

    for(i = 0; i < len; i++) {

        c = mem[i];

        *q++ = tohex(c >> 4);

        *q++ = tohex(c & 0xf);

    }

    *q = '\0';

}

static void hextomem(uint8_t *mem, const char *buf, int len)

{

    int i;

    for(i = 0; i < len; i++) {

        mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);

        buf += 2;

    }

}

/* return -1 if error, 0 if OK */

static int put_packet_binary(GDBState *s, const char *buf, int len)

{

    int csum, i;

    uint8_t *p;

    for(;;) {

        p = s->last_packet;

        *(p++) = '$';

        memcpy(p, buf, len);

        p += len;

        csum = 0;

        for(i = 0; i < len; i++) {

            csum += buf[i];

        }

        *(p++) = '#';

        *(p++) = tohex((csum >> 4) & 0xf);

        *(p++) = tohex((csum) & 0xf);

        s->last_packet_len = p - s->last_packet;

        put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);

#ifdef CONFIG_USER_ONLY

        i = get_char(s);

        if (i < 0)

            return -1;

        if (i == '+')

            break;

#else

        break;

#endif

    }

    return 0;

}

/* return -1 if error, 0 if OK */

static int put_packet(GDBState *s, const char *buf)

{

#ifdef DEBUG_GDB

    printf("reply='%s'\n", buf);

#endif

    return put_packet_binary(s, buf, strlen(buf));

}

/* The GDB remote protocol transfers values in target byte order.  This means

   we can use the raw memory access routines to access the value buffer.

   Conveniently, these also handle the case where the buffer is mis-aligned.

 */

#define GET_REG8(val) do { \

    stb_p(mem_buf, val); \

    return 1; \

    } while(0)

#define GET_REG16(val) do { \

    stw_p(mem_buf, val); \

    return 2; \

    } while(0)

#define GET_REG32(val) do { \

    stl_p(mem_buf, val); \

    return 4; \

    } while(0)

#define GET_REG64(val) do { \

    stq_p(mem_buf, val); \

    return 8; \

    } while(0)

#if TARGET_LONG_BITS == 64

#define GET_REGL(val) GET_REG64(val)

#define ldtul_p(addr) ldq_p(addr)

#else

#define GET_REGL(val) GET_REG32(val)

#define ldtul_p(addr) ldl_p(addr)

#endif

#if defined(TARGET_I386)

#ifdef TARGET_X86_64

static const int gpr_map[16] = {

    R_EAX, R_EBX, R_ECX, R_EDX, R_ESI, R_EDI, R_EBP, R_ESP,

    8, 9, 10, 11, 12, 13, 14, 15

};

#else

#define gpr_map gpr_map32

#endif

static const int gpr_map32[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };

#define NUM_CORE_REGS (CPU_NB_REGS * 2 + 25)

#define IDX_IP_REG      CPU_NB_REGS

#define IDX_FLAGS_REG   (IDX_IP_REG + 1)

#define IDX_SEG_REGS    (IDX_FLAGS_REG + 1)

#define IDX_FP_REGS     (IDX_SEG_REGS + 6)

#define IDX_XMM_REGS    (IDX_FP_REGS + 16)

#define IDX_MXCSR_REG   (IDX_XMM_REGS + CPU_NB_REGS)

static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)

{

    if (n < CPU_NB_REGS) {

        if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {

            GET_REG64(env->regs[gpr_map[n]]);

        } else if (n < CPU_NB_REGS32) {

            GET_REG32(env->regs[gpr_map32[n]]);

        }

    } else if (n >= IDX_FP_REGS && n < IDX_FP_REGS + 8) {

#ifdef USE_X86LDOUBLE

        /* FIXME: byteswap float values - after fixing fpregs layout. */

        memcpy(mem_buf, &env->fpregs[n - IDX_FP_REGS], 10);

#else

        memset(mem_buf, 0, 10);

#endif

        return 10;

    } else if (n >= IDX_XMM_REGS && n < IDX_XMM_REGS + CPU_NB_REGS) {

        n -= IDX_XMM_REGS;

        if (n < CPU_NB_REGS32 ||

            (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK)) {

            stq_p(mem_buf, env->xmm_regs[n].XMM_Q(0));

            stq_p(mem_buf + 8, env->xmm_regs[n].XMM_Q(1));

            return 16;

        }

    } else {

        switch (n) {

        case IDX_IP_REG:

            if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {

                GET_REG64(env->eip);

            } else {

                GET_REG32(env->eip);

            }

        case IDX_FLAGS_REG: GET_REG32(env->eflags);

        case IDX_SEG_REGS:     GET_REG32(env->segs[R_CS].selector);

        case IDX_SEG_REGS + 1: GET_REG32(env->segs[R_SS].selector);

        case IDX_SEG_REGS + 2: GET_REG32(env->segs[R_DS].selector);

        case IDX_SEG_REGS + 3: GET_REG32(env->segs[R_ES].selector);

        case IDX_SEG_REGS + 4: GET_REG32(env->segs[R_FS].selector);

        case IDX_SEG_REGS + 5: GET_REG32(env->segs[R_GS].selector);

        case IDX_FP_REGS + 8:  GET_REG32(env->fpuc);

        case IDX_FP_REGS + 9:  GET_REG32((env->fpus & ~0x3800) |

                                         (env->fpstt & 0x7) << 11);

        case IDX_FP_REGS + 10: GET_REG32(0); /* ftag */

        case IDX_FP_REGS + 11: GET_REG32(0); /* fiseg */

        case IDX_FP_REGS + 12: GET_REG32(0); /* fioff */

        case IDX_FP_REGS + 13: GET_REG32(0); /* foseg */

        case IDX_FP_REGS + 14: GET_REG32(0); /* fooff */

        case IDX_FP_REGS + 15: GET_REG32(0); /* fop */

        case IDX_MXCSR_REG: GET_REG32(env->mxcsr);

        }

    }

    return 0;

}

static int cpu_x86_gdb_load_seg(CPUState *env, int sreg, uint8_t *mem_buf)

{

    uint16_t selector = ldl_p(mem_buf);

    if (selector != env->segs[sreg].selector) {

#if defined(CONFIG_USER_ONLY)

        cpu_x86_load_seg(env, sreg, selector);

#else

        unsigned int limit, flags;

        target_ulong base;

        if (!(env->cr[0] & CR0_PE_MASK) || (env->eflags & VM_MASK)) {

            base = selector << 4;

            limit = 0xffff;

            flags = 0;

        } else {

            if (!cpu_x86_get_descr_debug(env, selector, &base, &limit, &flags))

                return 4;

        }

        cpu_x86_load_seg_cache(env, sreg, selector, base, limit, flags);

#endif

    }

    return 4;

}

static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)

{

    uint32_t tmp;

    if (n < CPU_NB_REGS) {

        if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {

            env->regs[gpr_map[n]] = ldtul_p(mem_buf);

            return sizeof(target_ulong);

        } else if (n < CPU_NB_REGS32) {

            n = gpr_map32[n];

            env->regs[n] &= ~0xffffffffUL;

            env->regs[n] |= (uint32_t)ldl_p(mem_buf);

            return 4;

        }

    } else if (n >= IDX_FP_REGS && n < IDX_FP_REGS + 8) {

#ifdef USE_X86LDOUBLE

        /* FIXME: byteswap float values - after fixing fpregs layout. */

        memcpy(&env->fpregs[n - IDX_FP_REGS], mem_buf, 10);

#endif

        return 10;

    } else if (n >= IDX_XMM_REGS && n < IDX_XMM_REGS + CPU_NB_REGS) {

        n -= IDX_XMM_REGS;

        if (n < CPU_NB_REGS32 ||

            (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK)) {

            env->xmm_regs[n].XMM_Q(0) = ldq_p(mem_buf);

            env->xmm_regs[n].XMM_Q(1) = ldq_p(mem_buf + 8);

            return 16;

        }

    } else {

        switch (n) {

        case IDX_IP_REG:

            if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {

                env->eip = ldq_p(mem_buf);

                return 8;

            } else {

                env->eip &= ~0xffffffffUL;

                env->eip |= (uint32_t)ldl_p(mem_buf);

                return 4;

            }

        case IDX_FLAGS_REG:

            env->eflags = ldl_p(mem_buf);

            return 4;

        case IDX_SEG_REGS:     return cpu_x86_gdb_load_seg(env, R_CS, mem_buf);

        case IDX_SEG_REGS + 1: return cpu_x86_gdb_load_seg(env, R_SS, mem_buf);

        case IDX_SEG_REGS + 2: return cpu_x86_gdb_load_seg(env, R_DS, mem_buf);

        case IDX_SEG_REGS + 3: return cpu_x86_gdb_load_seg(env, R_ES, mem_buf);

        case IDX_SEG_REGS + 4: return cpu_x86_gdb_load_seg(env, R_FS, mem_buf);

        case IDX_SEG_REGS + 5: return cpu_x86_gdb_load_seg(env, R_GS, mem_buf);

        case IDX_FP_REGS + 8:

            env->fpuc = ldl_p(mem_buf);

            return 4;

        case IDX_FP_REGS + 9:

            tmp = ldl_p(mem_buf);

            env->fpstt = (tmp >> 11) & 7;

            env->fpus = tmp & ~0x3800;

            return 4;

        case IDX_FP_REGS + 10: /* ftag */  return 4;

        case IDX_FP_REGS + 11: /* fiseg */ return 4;

        case IDX_FP_REGS + 12: /* fioff */ return 4;

        case IDX_FP_REGS + 13: /* foseg */ return 4;

        case IDX_FP_REGS + 14: /* fooff */ return 4;

        case IDX_FP_REGS + 15: /* fop */   return 4;

        case IDX_MXCSR_REG:

            env->mxcsr = ldl_p(mem_buf);

            return 4;

        }

    }

    /* Unrecognised register.  */

    return 0;

}

#elif defined (TARGET_PPC)

/* Old gdb always expects FP registers.  Newer (xml-aware) gdb only

   expects whatever the target description contains.  Due to a

   historical mishap the FP registers appear in between core integer

   regs and PC, MSR, CR, and so forth.  We hack round this by giving the

   FP regs zero size when talking to a newer gdb.  */

#define NUM_CORE_REGS 71

#if defined (TARGET_PPC64)

#define GDB_CORE_XML "power64-core.xml"

#else

#define GDB_CORE_XML "power-core.xml"

#endif

static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)

{

    if (n < 32) {

        /* gprs */

        GET_REGL(env->gpr[n]);

    } else if (n < 64) {

        /* fprs */

        if (gdb_has_xml)

            return 0;

        stfq_p(mem_buf, env->fpr[n-32]);

        return 8;

    } else {

        switch (n) {

        case 64: GET_REGL(env->nip);

        case 65: GET_REGL(env->msr);

        case 66:

            {

                uint32_t cr = 0;

                int i;

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

                    cr |= env->crf[i] << (32 - ((i + 1) * 4));

                GET_REG32(cr);

            }

        case 67: GET_REGL(env->lr);

        case 68: GET_REGL(env->ctr);

        case 69: GET_REGL(env->xer);

        case 70:

            {

                if (gdb_has_xml)

                    return 0;

                GET_REG32(0); /* fpscr */

            }

        }

    }

    return 0;

}

static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)

{

    if (n < 32) {

        /* gprs */

        env->gpr[n] = ldtul_p(mem_buf);

        return sizeof(target_ulong);

    } else if (n < 64) {

        /* fprs */

        if (gdb_has_xml)

            return 0;

        env->fpr[n-32] = ldfq_p(mem_buf);

        return 8;

    } else {

        switch (n) {

        case 64:

            env->nip = ldtul_p(mem_buf);

            return sizeof(target_ulong);

        case 65:

            ppc_store_msr(env, ldtul_p(mem_buf));

            return sizeof(target_ulong);

        case 66:

            {

                uint32_t cr = ldl_p(mem_buf);

                int i;

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

                    env->crf[i] = (cr >> (32 - ((i + 1) * 4))) & 0xF;

                return 4;

            }

        case 67:

            env->lr = ldtul_p(mem_buf);

            return sizeof(target_ulong);

        case 68:

            env->ctr = ldtul_p(mem_buf);

            return sizeof(target_ulong);

        case 69:

            env->xer = ldtul_p(mem_buf);

            return sizeof(target_ulong);

        case 70:

            /* fpscr */

            if (gdb_has_xml)

                return 0;

            return 4;

        }

    }

    return 0;

}

#elif defined (TARGET_SPARC)

#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)

#define NUM_CORE_REGS 86

#else

#define NUM_CORE_REGS 72

#endif

#ifdef TARGET_ABI32

#define GET_REGA(val) GET_REG32(val)

#else

#define GET_REGA(val) GET_REGL(val)

#endif

static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)

{

    if (n < 8) {

        /* g0..g7 */

        GET_REGA(env->gregs[n]);

    }

    if (n < 32) {

        /* register window */

        GET_REGA(env->regwptr[n - 8]);

    }

#if defined(TARGET_ABI32) || !defined(TARGET_SPARC64)

    if (n < 64) {

        /* fprs */

        GET_REG32(*((uint32_t *)&env->fpr[n - 32]));

    }

    /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */

    switch (n) {

    case 64: GET_REGA(env->y);

    case 65: GET_REGA(cpu_get_psr(env));

    case 66: GET_REGA(env->wim);

    case 67: GET_REGA(env->tbr);

    case 68: GET_REGA(env->pc);

    case 69: GET_REGA(env->npc);

    case 70: GET_REGA(env->fsr);

    case 71: GET_REGA(0); /* csr */

    default: GET_REGA(0);

    }

#else

    if (n < 64) {

        /* f0-f31 */

        GET_REG32(*((uint32_t *)&env->fpr[n - 32]));

    }

    if (n < 80) {

        /* f32-f62 (double width, even numbers only) */

        uint64_t val;

        val = (uint64_t)*((uint32_t *)&env->fpr[(n - 64) * 2 + 32]) << 32;

        val |= *((uint32_t *)&env->fpr[(n - 64) * 2 + 33]);

        GET_REG64(val);

    }

    switch (n) {

    case 80: GET_REGL(env->pc);

    case 81: GET_REGL(env->npc);

    case 82: GET_REGL((cpu_get_ccr(env) << 32) |

                      ((env->asi & 0xff) << 24) |

                      ((env->pstate & 0xfff) << 8) |

                      cpu_get_cwp64(env));

    case 83: GET_REGL(env->fsr);

    case 84: GET_REGL(env->fprs);

    case 85: GET_REGL(env->y);

    }

#endif

    return 0;

}

static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)

{

#if defined(TARGET_ABI32)

    abi_ulong tmp;

    tmp = ldl_p(mem_buf);

#else

    target_ulong tmp;

    tmp = ldtul_p(mem_buf);

#endif

    if (n < 8) {

        /* g0..g7 */

        env->gregs[n] = tmp;

    } else if (n < 32) {

        /* register window */

        env->regwptr[n - 8] = tmp;

    }

#if defined(TARGET_ABI32) || !defined(TARGET_SPARC64)

    else if (n < 64) {

        /* fprs */

        *((uint32_t *)&env->fpr[n - 32]) = tmp;

    } else {

        /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */

        switch (n) {