gdbstub.c

   1 /*
   2  * gdb server stub
   3  *
   4  * Copyright (c) 2003-2005 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 #include "config.h"
  21 #include "qemu-common.h"
  22 #ifdef CONFIG_USER_ONLY
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <stdarg.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30
  31 #include "qemu.h"
  32 #else
  33 #include "qemu-char.h"
  34 #include "sysemu.h"
  35 #include "gdbstub.h"
  36 #endif
  37
  38 #define MAX_PACKET_LENGTH 4096
  39
  40 #include "qemu_socket.h"
  41 #ifdef _WIN32
  42 /* XXX: these constants may be independent of the host ones even for Unix */
  43 #ifndef SIGTRAP
  44 #define SIGTRAP 5
  45 #endif
  46 #ifndef SIGINT
  47 #define SIGINT 2
  48 #endif
  49 #else
  50 #include <signal.h>
  51 #endif
  52
  53 //#define DEBUG_GDB
  54
  55 typedef struct GDBRegisterState {
  56     int base_reg;
  57     int num_regs;
  58     gdb_reg_cb get_reg;
  59     gdb_reg_cb set_reg;
  60     const char *xml;
  61     struct GDBRegisterState *next;
  62 } GDBRegisterState;
  63
  64 enum RSState {
  65     RS_IDLE,
  66     RS_GETLINE,
  67     RS_CHKSUM1,
  68     RS_CHKSUM2,
  69     RS_SYSCALL,
  70 };
  71 typedef struct GDBState {
  72     CPUState *env; /* current CPU */
  73     enum RSState state; /* parsing state */
  74     char line_buf[MAX_PACKET_LENGTH];
  75     int line_buf_index;
  76     int line_csum;
  77     uint8_t last_packet[MAX_PACKET_LENGTH + 4];
  78     int last_packet_len;
  79     int signal;
  80 #ifdef CONFIG_USER_ONLY
  81     int fd;
  82     int running_state;
  83 #else
  84     CharDriverState *chr;
  85 #endif
  86 } GDBState;
  87
  88 /* By default use no IRQs and no timers while single stepping so as to
  89  * make single stepping like an ICE HW step.
  90  */
  91 static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
  92
  93 /* This is an ugly hack to cope with both new and old gdb.
  94    If gdb sends qXfer:features:read then assume we're talking to a newish
  95    gdb that understands target descriptions.  */
  96 static int gdb_has_xml;
  97
  98 #ifdef CONFIG_USER_ONLY
  99 /* XXX: This is not thread safe.  Do we care?  */
 100 static int gdbserver_fd = -1;
 101
 102 /* XXX: remove this hack.  */
 103 static GDBState gdbserver_state;
 104
 105 static int get_char(GDBState *s)
 106 {
 107     uint8_t ch;
 108     int ret;
 109
 110     for(;;) {
 111         ret = recv(s->fd, &ch, 1, 0);
 112         if (ret < 0) {
 113             if (errno == ECONNRESET)
 114                 s->fd = -1;
 115             if (errno != EINTR && errno != EAGAIN)
 116                 return -1;
 117         } else if (ret == 0) {
 118             close(s->fd);
 119             s->fd = -1;
 120             return -1;
 121         } else {
 122             break;
 123         }
 124     }
 125     return ch;
 126 }
 127 #endif
 128
 129 /* GDB stub state for use by semihosting syscalls.  */
 130 static GDBState *gdb_syscall_state;
 131 static gdb_syscall_complete_cb gdb_current_syscall_cb;
 132
 133 enum {
 134     GDB_SYS_UNKNOWN,
 135     GDB_SYS_ENABLED,
 136     GDB_SYS_DISABLED,
 137 } gdb_syscall_mode;
 138
 139 /* If gdb is connected when the first semihosting syscall occurs then use
 140    remote gdb syscalls.  Otherwise use native file IO.  */
 141 int use_gdb_syscalls(void)
 142 {
 143     if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
 144         gdb_syscall_mode = (gdb_syscall_state ? GDB_SYS_ENABLED
 145                                               : GDB_SYS_DISABLED);
 146     }
 147     return gdb_syscall_mode == GDB_SYS_ENABLED;
 148 }
 149
 150 /* Resume execution.  */
 151 static inline void gdb_continue(GDBState *s)
 152 {
 153 #ifdef CONFIG_USER_ONLY
 154     s->running_state = 1;
 155 #else
 156     vm_start();
 157 #endif
 158 }
 159
 160 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
 161 {
 162 #ifdef CONFIG_USER_ONLY
 163     int ret;
 164
 165     while (len > 0) {
 166         ret = send(s->fd, buf, len, 0);
 167         if (ret < 0) {
 168             if (errno != EINTR && errno != EAGAIN)
 169                 return;
 170         } else {
 171             buf += ret;
 172             len -= ret;
 173         }
 174     }
 175 #else
 176     qemu_chr_write(s->chr, buf, len);
 177 #endif
 178 }
 179
 180 static inline int fromhex(int v)
 181 {
 182     if (v >= '0' && v <= '9')
 183         return v - '0';
 184     else if (v >= 'A' && v <= 'F')
 185         return v - 'A' + 10;
 186     else if (v >= 'a' && v <= 'f')
 187         return v - 'a' + 10;
 188     else
 189         return 0;
 190 }
 191
 192 static inline int tohex(int v)
 193 {
 194     if (v < 10)
 195         return v + '0';
 196     else
 197         return v - 10 + 'a';
 198 }
 199
 200 static void memtohex(char *buf, const uint8_t *mem, int len)
 201 {
 202     int i, c;
 203     char *q;
 204     q = buf;
 205     for(i = 0; i < len; i++) {
 206         c = mem[i];
 207         *q++ = tohex(c >> 4);
 208         *q++ = tohex(c & 0xf);
 209     }
 210     *q = '\0';
 211 }
 212
 213 static void hextomem(uint8_t *mem, const char *buf, int len)
 214 {
 215     int i;
 216
 217     for(i = 0; i < len; i++) {
 218         mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
 219         buf += 2;
 220     }
 221 }
 222
 223 /* return -1 if error, 0 if OK */
 224 static int put_packet_binary(GDBState *s, const char *buf, int len)
 225 {
 226     int csum, i;
 227     uint8_t *p;
 228
 229     for(;;) {
 230         p = s->last_packet;
 231         *(p++) = '$';
 232         memcpy(p, buf, len);
 233         p += len;
 234         csum = 0;
 235         for(i = 0; i < len; i++) {
 236             csum += buf[i];
 237         }
 238         *(p++) = '#';
 239         *(p++) = tohex((csum >> 4) & 0xf);
 240         *(p++) = tohex((csum) & 0xf);
 241
 242         s->last_packet_len = p - s->last_packet;
 243         put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
 244
 245 #ifdef CONFIG_USER_ONLY
 246         i = get_char(s);
 247         if (i < 0)
 248             return -1;
 249         if (i == '+')
 250             break;
 251 #else
 252         break;
 253 #endif
 254     }
 255     return 0;
 256 }
 257
 258 /* return -1 if error, 0 if OK */
 259 static int put_packet(GDBState *s, const char *buf)
 260 {
 261 #ifdef DEBUG_GDB
 262     printf("reply='%s'\n", buf);
 263 #endif
 264
 265     return put_packet_binary(s, buf, strlen(buf));
 266 }
 267
 268 /* The GDB remote protocol transfers values in target byte order.  This means
 269    we can use the raw memory access routines to access the value buffer.
 270    Conveniently, these also handle the case where the buffer is mis-aligned.
 271  */
 272 #define GET_REG8(val) do { \
 273     stb_p(mem_buf, val); \
 274     return 1; \
 275     } while(0)
 276 #define GET_REG16(val) do { \
 277     stw_p(mem_buf, val); \
 278     return 2; \
 279     } while(0)
 280 #define GET_REG32(val) do { \
 281     stl_p(mem_buf, val); \
 282     return 4; \
 283     } while(0)
 284 #define GET_REG64(val) do { \
 285     stq_p(mem_buf, val); \
 286     return 8; \
 287     } while(0)
 288
 289 #if TARGET_LONG_BITS == 64
 290 #define GET_REGL(val) GET_REG64(val)
 291 #define ldtul_p(addr) ldq_p(addr)
 292 #else
 293 #define GET_REGL(val) GET_REG32(val)
 294 #define ldtul_p(addr) ldl_p(addr)
 295 #endif
 296
 297 #if defined(TARGET_I386)
 298
 299 #ifdef TARGET_X86_64
 300 static const int gpr_map[16] = {
 301     R_EAX, R_EBX, R_ECX, R_EDX, R_ESI, R_EDI, R_EBP, R_ESP,
 302     8, 9, 10, 11, 12, 13, 14, 15
 303 };
 304 #else
 305 static const int gpr_map[8] = {0, 1, 2, 3, 4, 5, 6, 7};
 306 #endif
 307
 308 #define NUM_CORE_REGS (CPU_NB_REGS * 2 + 25)
 309
 310 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 311 {
 312     if (n < CPU_NB_REGS) {
 313         GET_REGL(env->regs[gpr_map[n]]);
 314     } else if (n >= CPU_NB_REGS + 8 && n < CPU_NB_REGS + 16) {
 315         /* FIXME: byteswap float values.  */
 316 #ifdef USE_X86LDOUBLE
 317         memcpy(mem_buf, &env->fpregs[n - (CPU_NB_REGS + 8)], 10);
 318 #else
 319         memset(mem_buf, 0, 10);
 320 #endif
 321         return 10;
 322     } else if (n >= CPU_NB_REGS + 24) {
 323         n -= CPU_NB_REGS + 24;
 324         if (n < CPU_NB_REGS) {
 325             stq_p(mem_buf, env->xmm_regs[n].XMM_Q(0));
 326             stq_p(mem_buf + 8, env->xmm_regs[n].XMM_Q(1));
 327             return 16;
 328         } else if (n == CPU_NB_REGS) {
 329             GET_REG32(env->mxcsr);
 330         }
 331     } else {
 332         n -= CPU_NB_REGS;
 333         switch (n) {
 334         case 0: GET_REGL(env->eip);
 335         case 1: GET_REG32(env->eflags);
 336         case 2: GET_REG32(env->segs[R_CS].selector);
 337         case 3: GET_REG32(env->segs[R_SS].selector);
 338         case 4: GET_REG32(env->segs[R_DS].selector);
 339         case 5: GET_REG32(env->segs[R_ES].selector);
 340         case 6: GET_REG32(env->segs[R_FS].selector);
 341         case 7: GET_REG32(env->segs[R_GS].selector);
 342         /* 8...15 x87 regs.  */
 343         case 16: GET_REG32(env->fpuc);
 344         case 17: GET_REG32((env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11);
 345         case 18: GET_REG32(0); /* ftag */
 346         case 19: GET_REG32(0); /* fiseg */
 347         case 20: GET_REG32(0); /* fioff */
 348         case 21: GET_REG32(0); /* foseg */
 349         case 22: GET_REG32(0); /* fooff */
 350         case 23: GET_REG32(0); /* fop */
 351         /* 24+ xmm regs.  */
 352         }
 353     }
 354     return 0;
 355 }
 356
 357 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int i)
 358 {
 359     uint32_t tmp;
 360
 361     if (i < CPU_NB_REGS) {
 362         env->regs[gpr_map[i]] = ldtul_p(mem_buf);
 363         return sizeof(target_ulong);
 364     } else if (i >= CPU_NB_REGS + 8 && i < CPU_NB_REGS + 16) {
 365         i -= CPU_NB_REGS + 8;
 366 #ifdef USE_X86LDOUBLE
 367         memcpy(&env->fpregs[i], mem_buf, 10);
 368 #endif
 369         return 10;
 370     } else if (i >= CPU_NB_REGS + 24) {
 371         i -= CPU_NB_REGS + 24;
 372         if (i < CPU_NB_REGS) {
 373             env->xmm_regs[i].XMM_Q(0) = ldq_p(mem_buf);
 374             env->xmm_regs[i].XMM_Q(1) = ldq_p(mem_buf + 8);
 375             return 16;
 376         } else if (i == CPU_NB_REGS) {
 377             env->mxcsr = ldl_p(mem_buf);
 378             return 4;
 379         }
 380     } else {
 381         i -= CPU_NB_REGS;
 382         switch (i) {
 383         case 0: env->eip = ldtul_p(mem_buf); return sizeof(target_ulong);
 384         case 1: env->eflags = ldl_p(mem_buf); return 4;
 385 #if defined(CONFIG_USER_ONLY)
 386 #define LOAD_SEG(index, sreg)\
 387             tmp = ldl_p(mem_buf);\
 388             if (tmp != env->segs[sreg].selector)\
 389                 cpu_x86_load_seg(env, sreg, tmp);
 390 #else
 391 /* FIXME: Honor segment registers.  Needs to avoid raising an exception
 392    when the selector is invalid.  */
 393 #define LOAD_SEG(index, sreg) do {} while(0)
 394 #endif
 395         case 2: LOAD_SEG(10, R_CS); return 4;
 396         case 3: LOAD_SEG(11, R_SS); return 4;
 397         case 4: LOAD_SEG(12, R_DS); return 4;
 398         case 5: LOAD_SEG(13, R_ES); return 4;
 399         case 6: LOAD_SEG(14, R_FS); return 4;
 400         case 7: LOAD_SEG(15, R_GS); return 4;
 401         /* 8...15 x87 regs.  */
 402         case 16: env->fpuc = ldl_p(mem_buf); return 4;
 403         case 17:
 404                  tmp = ldl_p(mem_buf);
 405                  env->fpstt = (tmp >> 11) & 7;
 406                  env->fpus = tmp & ~0x3800;
 407                  return 4;
 408         case 18: /* ftag */ return 4;
 409         case 19: /* fiseg */ return 4;
 410         case 20: /* fioff */ return 4;
 411         case 21: /* foseg */ return 4;
 412         case 22: /* fooff */ return 4;
 413         case 23: /* fop */ return 4;
 414         /* 24+ xmm regs.  */
 415         }
 416     }
 417     /* Unrecognised register.  */
 418     return 0;
 419 }
 420
 421 #elif defined (TARGET_PPC)
 422
 423 #define NUM_CORE_REGS 71
 424
 425 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 426 {
 427     if (n < 32) {
 428         /* gprs */
 429         GET_REGL(env->gpr[n]);
 430     } else if (n < 64) {
 431         /* fprs */
 432         stfq_p(mem_buf, env->fpr[n]);
 433         return 8;
 434     } else {
 435         switch (n) {
 436         case 64: GET_REGL(env->nip);
 437         case 65: GET_REGL(env->msr);
 438         case 66:
 439             {
 440                 uint32_t cr = 0;
 441                 int i;
 442                 for (i = 0; i < 8; i++)
 443                     cr |= env->crf[i] << (32 - ((i + 1) * 4));
 444                 GET_REG32(cr);
 445             }
 446         case 67: GET_REGL(env->lr);
 447         case 68: GET_REGL(env->ctr);
 448         case 69: GET_REG32(ppc_load_xer(env));
 449         case 70: GET_REG32(0); /* fpscr */
 450         }
 451     }
 452     return 0;
 453 }
 454
 455 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 456 {
 457     if (n < 32) {
 458         /* gprs */
 459         env->gpr[n] = ldtul_p(mem_buf);
 460         return sizeof(target_ulong);
 461     } else if (n < 64) {
 462         /* fprs */
 463         env->fpr[n] = ldfq_p(mem_buf);
 464         return 8;
 465     } else {
 466         switch (n) {
 467         case 64:
 468             env->nip = ldtul_p(mem_buf);
 469             return sizeof(target_ulong);
 470         case 65:
 471             ppc_store_msr(env, ldtul_p(mem_buf));
 472             return sizeof(target_ulong);
 473         case 66:
 474             {
 475                 uint32_t cr = ldl_p(mem_buf);
 476                 int i;
 477                 for (i = 0; i < 8; i++)
 478                     env->crf[i] = (cr >> (32 - ((i + 1) * 4))) & 0xF;
 479                 return 4;
 480             }
 481         case 67:
 482             env->lr = ldtul_p(mem_buf);
 483             return sizeof(target_ulong);
 484         case 68:
 485             env->ctr = ldtul_p(mem_buf);
 486             return sizeof(target_ulong);
 487         case 69:
 488             ppc_store_xer(env, ldl_p(mem_buf));
 489             return 4;
 490         case 70:
 491             /* fpscr */
 492             return 4;
 493         }
 494     }
 495     return 0;
 496 }
 497
 498 #elif defined (TARGET_SPARC)
 499
 500 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
 501 #define NUM_CORE_REGS 86
 502 #else
 503 #define NUM_CORE_REGS 73
 504 #endif
 505
 506 #ifdef TARGET_ABI32
 507 #define GET_REGA(val) GET_REG32(val)
 508 #else
 509 #define GET_REGA(val) GET_REGL(val)
 510 #endif
 511
 512 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 513 {
 514     if (n < 8) {
 515         /* g0..g7 */
 516         GET_REGA(env->gregs[n]);
 517     }
 518     if (n < 32) {
 519         /* register window */
 520         GET_REGA(env->regwptr[n - 8]);
 521     }
 522 #if defined(TARGET_ABI32) || !defined(TARGET_SPARC64)
 523     if (n < 64) {
 524         /* fprs */
 525         GET_REG32(*((uint32_t *)&env->fpr[n - 32]));
 526     }
 527     /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
 528     switch (n) {
 529     case 64: GET_REGA(env->y);
 530     case 65: GET_REGA(GET_PSR(env));
 531     case 66: GET_REGA(env->wim);
 532     case 67: GET_REGA(env->tbr);
 533     case 68: GET_REGA(env->pc);
 534     case 69: GET_REGA(env->npc);
 535     case 70: GET_REGA(env->fsr);
 536     case 71: GET_REGA(0); /* csr */
 537     case 72: GET_REGA(0);
 538     }
 539 #else
 540     if (n < 64) {
 541         /* f0-f31 */
 542         GET_REG32(*((uint32_t *)&env->fpr[n - 32]));
 543     }
 544     if (n < 80) {
 545         /* f32-f62 (double width, even numbers only) */
 546         uint64_t val;
 547
 548         val = (uint64_t)*((uint32_t *)&env->fpr[(n - 64) * 2 + 32]) << 32;
 549         val |= *((uint32_t *)&env->fpr[(n - 64) * 2 + 33]);
 550         GET_REG64(val);
 551     }
 552     switch (n) {
 553     case 80: GET_REGL(env->pc);
 554     case 81: GET_REGL(env->npc);
 555     case 82: GET_REGL(((uint64_t)GET_CCR(env) << 32) |
 556                            ((env->asi & 0xff) << 24) |
 557                            ((env->pstate & 0xfff) << 8) |
 558                            GET_CWP64(env));
 559     case 83: GET_REGL(env->fsr);
 560     case 84: GET_REGL(env->fprs);
 561     case 85: GET_REGL(env->y);
 562     }
 563 #endif
 564     return 0;
 565 }
 566
 567 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 568 {
 569 #if defined(TARGET_ABI32)
 570     abi_ulong tmp;
 571
 572     tmp = ldl_p(mem_buf);
 573 #else
 574     target_ulong tmp;
 575
 576     tmp = ldtul_p(mem_buf);
 577 #endif
 578
 579     if (n < 8) {
 580         /* g0..g7 */
 581         env->gregs[n] = tmp;
 582     } else if (n < 32) {
 583         /* register window */
 584         env->regwptr[n - 8] = tmp;
 585     }
 586 #if defined(TARGET_ABI32) || !defined(TARGET_SPARC64)
 587     else if (n < 64) {
 588         /* fprs */
 589         *((uint32_t *)&env->fpr[n - 32]) = tmp;
 590     } else {
 591         /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
 592         switch (n) {
 593         case 64: env->y = tmp; break;
 594         case 65: PUT_PSR(env, tmp); break;
 595         case 66: env->wim = tmp; break;
 596         case 67: env->tbr = tmp; break;
 597         case 68: env->pc = tmp; break;
 598         case 69: env->npc = tmp; break;
 599         case 70: env->fsr = tmp; break;
 600         default: return 0;
 601         }
 602     }
 603     return 4;
 604 #else
 605     else if (n < 64) {
 606         /* f0-f31 */
 607         uint32_t fpr;
 608
 609         env->fpr[n] = ldfl_p(mem_buf);
 610         return 4;
 611     } else if (n < 80) {
 612         /* f32-f62 (double width, even numbers only) */
 613         *((uint32_t *)&env->fpr[(n - 64) * 2 + 32]) = tmp >> 32;
 614         *((uint32_t *)&env->fpr[(n - 64) * 2 + 33]) = tmp;
 615     } else {
 616         switch (n) {
 617         case 80: env->pc = tmp; break;
 618         case 81: env->npc = tmp; break;
 619         case 82:
 620             PUT_CCR(env, tmp >> 32);
 621             env->asi = (tmp >> 24) & 0xff;
 622             env->pstate = (tmp >> 8) & 0xfff;
 623             PUT_CWP64(env, tmp & 0xff);
 624             break;
 625         case 83: env->fsr = tmp; break;
 626         case 84: env->fprs = tmp; break;
 627         case 85: env->y = tmp; break;
 628         default: return 0;
 629         }
 630     }
 631     return 8;
 632 #endif
 633 }
 634 #elif defined (TARGET_ARM)
 635
 636 /* Old gdb always expect FPA registers.  Newer (xml-aware) gdb only expect
 637    whatever the target description contains.  Due to a historical mishap
 638    the FPA registers appear in between core integer regs and the CPSR.
 639    We hack round this by giving the FPA regs zero size when talking to a
 640    newer gdb.  */
 641 #define NUM_CORE_REGS 26
 642 #define GDB_CORE_XML "arm-core.xml"
 643
 644 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 645 {
 646     if (n < 16) {
 647         /* Core integer register.  */
 648         GET_REG32(env->regs[n]);
 649     }
 650     if (n < 24) {
 651         /* FPA registers.  */
 652         if (gdb_has_xml)
 653             return 0;
 654         memset(mem_buf, 0, 12);
 655         return 12;
 656     }
 657     switch (n) {
 658     case 24:
 659         /* FPA status register.  */
 660         if (gdb_has_xml)
 661             return 0;
 662         GET_REG32(0);
 663     case 25:
 664         /* CPSR */
 665         GET_REG32(cpsr_read(env));
 666     }
 667     /* Unknown register.  */
 668     return 0;
 669 }
 670
 671 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 672 {
 673     uint32_t tmp;
 674
 675     tmp = ldl_p(mem_buf);
 676
 677     /* Mask out low bit of PC to workaround gdb bugs.  This will probably
 678        cause problems if we ever implement the Jazelle DBX extensions.  */
 679     if (n == 15)
 680         tmp &= ~1;
 681
 682     if (n < 16) {
 683         /* Core integer register.  */
 684         env->regs[n] = tmp;
 685         return 4;
 686     }
 687     if (n < 24) { /* 16-23 */
 688         /* FPA registers (ignored).  */
 689         if (gdb_has_xml)
 690             return 0;
 691         return 12;
 692     }
 693     switch (n) {
 694     case 24:
 695         /* FPA status register (ignored).  */
 696         if (gdb_has_xml)
 697             return 0;
 698         return 4;
 699     case 25:
 700         /* CPSR */
 701         cpsr_write (env, tmp, 0xffffffff);
 702         return 4;
 703     }
 704     /* Unknown register.  */
 705     return 0;
 706 }
 707
 708 #elif defined (TARGET_M68K)
 709
 710 #define NUM_CORE_REGS 18
 711
 712 #define GDB_CORE_XML "cf-core.xml"
 713
 714 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 715 {
 716     if (n < 8) {
 717         /* D0-D7 */
 718         GET_REG32(env->dregs[n]);
 719     } else if (n < 16) {
 720         /* A0-A7 */
 721         GET_REG32(env->aregs[n - 8]);
 722     } else {
 723         switch (n) {
 724         case 16: GET_REG32(env->sr);
 725         case 17: GET_REG32(env->pc);
 726         }
 727     }
 728     /* FP registers not included here because they vary between
 729        ColdFire and m68k.  Use XML bits for these.  */
 730     return 0;
 731 }
 732
 733 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 734 {
 735     uint32_t tmp;
 736
 737     tmp = ldl_p(mem_buf);
 738
 739     if (n < 8) {
 740         /* D0-D7 */
 741         env->dregs[n] = tmp;
 742     } else if (n < 8) {
 743         /* A0-A7 */
 744         env->aregs[n - 8] = tmp;
 745     } else {
 746         switch (n) {
 747         case 16: env->sr = tmp; break;
 748         case 17: env->pc = tmp; break;
 749         default: return 0;
 750         }
 751     }
 752     return 4;
 753 }
 754 #elif defined (TARGET_MIPS)
 755
 756 #define NUM_CORE_REGS 73
 757
 758 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 759 {
 760     if (n < 32) {
 761         GET_REGL(env->active_tc.gpr[n]);
 762     }
 763     if (env->CP0_Config1 & (1 << CP0C1_FP)) {
 764         if (n >= 38 && n < 70) {
 765             if (env->CP0_Status & (1 << CP0St_FR))
 766                 GET_REGL(env->active_fpu.fpr[n - 38].d);
 767             else
 768                 GET_REGL(env->active_fpu.fpr[n - 38].w[FP_ENDIAN_IDX]);
 769         }
 770         switch (n) {
 771         case 70: GET_REGL((int32_t)env->active_fpu.fcr31);
 772         case 71: GET_REGL((int32_t)env->active_fpu.fcr0);
 773         }
 774     }
 775     switch (n) {
 776     case 32: GET_REGL((int32_t)env->CP0_Status);
 777     case 33: GET_REGL(env->active_tc.LO[0]);
 778     case 34: GET_REGL(env->active_tc.HI[0]);
 779     case 35: GET_REGL(env->CP0_BadVAddr);
 780     case 36: GET_REGL((int32_t)env->CP0_Cause);
 781     case 37: GET_REGL(env->active_tc.PC);
 782     case 72: GET_REGL(0); /* fp */
 783     case 89: GET_REGL((int32_t)env->CP0_PRid);
 784     }
 785     if (n >= 73 && n <= 88) {
 786         /* 16 embedded regs.  */
 787         GET_REGL(0);
 788     }
 789
 790     return 0;
 791 }
 792
 793 /* convert MIPS rounding mode in FCR31 to IEEE library */
 794 static unsigned int ieee_rm[] =
 795   {
 796     float_round_nearest_even,
 797     float_round_to_zero,
 798     float_round_up,
 799     float_round_down
 800   };
 801 #define RESTORE_ROUNDING_MODE \
 802     set_float_rounding_mode(ieee_rm[env->active_fpu.fcr31 & 3], &env->active_fpu.fp_status)
 803
 804 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 805 {
 806     target_ulong tmp;
 807
 808     tmp = ldtul_p(mem_buf);
 809
 810     if (n < 32) {
 811         env->active_tc.gpr[n] = tmp;
 812         return sizeof(target_ulong);
 813     }
 814     if (env->CP0_Config1 & (1 << CP0C1_FP)
 815             && n >= 38 && n < 73) {
 816         if (n < 70) {
 817             if (env->CP0_Status & (1 << CP0St_FR))
 818               env->active_fpu.fpr[n - 38].d = tmp;
 819             else
 820               env->active_fpu.fpr[n - 38].w[FP_ENDIAN_IDX] = tmp;
 821         }
 822         switch (n) {
 823         case 70:
 824             env->active_fpu.fcr31 = tmp & 0xFF83FFFF;
 825             /* set rounding mode */
 826             RESTORE_ROUNDING_MODE;
 827 #ifndef CONFIG_SOFTFLOAT
 828             /* no floating point exception for native float */
 829             SET_FP_ENABLE(env->active_fpu.fcr31, 0);
 830 #endif
 831             break;
 832         case 71: env->active_fpu.fcr0 = tmp; break;
 833         }
 834         return sizeof(target_ulong);
 835     }
 836     switch (n) {
 837     case 32: env->CP0_Status = tmp; break;
 838     case 33: env->active_tc.LO[0] = tmp; break;
 839     case 34: env->active_tc.HI[0] = tmp; break;
 840     case 35: env->CP0_BadVAddr = tmp; break;
 841     case 36: env->CP0_Cause = tmp; break;
 842     case 37: env->active_tc.PC = tmp; break;
 843     case 72: /* fp, ignored */ break;
 844     default:
 845         if (n > 89)
 846             return 0;
 847         /* Other registers are readonly.  Ignore writes.  */
 848         break;
 849     }
 850
 851     return sizeof(target_ulong);
 852 }
 853 #elif defined (TARGET_SH4)
 854
 855 /* Hint: Use "set architecture sh4" in GDB to see fpu registers */
 856 /* FIXME: We should use XML for this.  */
 857
 858 #define NUM_CORE_REGS 59
 859
 860 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 861 {
 862     if (n < 8) {
 863         if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
 864             GET_REGL(env->gregs[n + 16]);
 865         } else {
 866             GET_REGL(env->gregs[n]);
 867         }
 868     } else if (n < 16) {
 869         GET_REGL(env->gregs[n - 8]);
 870     } else if (n >= 25 && n < 41) {
 871         GET_REGL(env->fregs[(n - 25) + ((env->fpscr & FPSCR_FR) ? 16 : 0)]);
 872     } else if (n >= 43 && n < 51) {
 873         GET_REGL(env->gregs[n - 43]);
 874     } else if (n >= 51 && n < 59) {
 875         GET_REGL(env->gregs[n - (51 - 16)]);
 876     }
 877     switch (n) {
 878     case 16: GET_REGL(env->pc);
 879     case 17: GET_REGL(env->pr);
 880     case 18: GET_REGL(env->gbr);
 881     case 19: GET_REGL(env->vbr);
 882     case 20: GET_REGL(env->mach);
 883     case 21: GET_REGL(env->macl);
 884     case 22: GET_REGL(env->sr);
 885     case 23: GET_REGL(env->fpul);
 886     case 24: GET_REGL(env->fpscr);
 887     case 41: GET_REGL(env->ssr);
 888     case 42: GET_REGL(env->spc);
 889     }
 890
 891     return 0;
 892 }
 893
 894 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 895 {
 896     uint32_t tmp;
 897
 898     tmp = ldl_p(mem_buf);
 899
 900     if (n < 8) {
 901         if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
 902             env->gregs[n + 16] = tmp;
 903         } else {
 904             env->gregs[n] = tmp;
 905         }
 906         return 4;
 907     } else if (n < 16) {
 908         env->gregs[n - 8] = tmp;
 909         return 4;
 910     } else if (n >= 25 && n < 41) {
 911         env->fregs[(n - 25) + ((env->fpscr & FPSCR_FR) ? 16 : 0)] = tmp;
 912     } else if (n >= 43 && n < 51) {
 913         env->gregs[n - 43] = tmp;
 914         return 4;
 915     } else if (n >= 51 && n < 59) {
 916         env->gregs[n - (51 - 16)] = tmp;
 917         return 4;
 918     }
 919     switch (n) {
 920     case 16: env->pc = tmp;
 921     case 17: env->pr = tmp;
 922     case 18: env->gbr = tmp;
 923     case 19: env->vbr = tmp;
 924     case 20: env->mach = tmp;
 925     case 21: env->macl = tmp;
 926     case 22: env->sr = tmp;
 927     case 23: env->fpul = tmp;
 928     case 24: env->fpscr = tmp;
 929     case 41: env->ssr = tmp;
 930     case 42: env->spc = tmp;
 931     default: return 0;
 932     }
 933
 934     return 4;
 935 }
 936 #elif defined (TARGET_CRIS)
 937
 938 #define NUM_CORE_REGS 49
 939
 940 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 941 {
 942     uint8_t srs;
 943
 944     srs = env->pregs[PR_SRS];
 945     if (n < 16) {
 946         GET_REG32(env->regs[n]);
 947     }
 948
 949     if (n >= 21 && n < 32) {
 950         GET_REG32(env->pregs[n - 16]);
 951     }
 952     if (n >= 33 && n < 49) {
 953         GET_REG32(env->sregs[srs][n - 33]);
 954     }
 955     switch (n) {
 956     case 16: GET_REG8(env->pregs[0]);
 957     case 17: GET_REG8(env->pregs[1]);
 958     case 18: GET_REG32(env->pregs[2]);
 959     case 19: GET_REG8(srs);
 960     case 20: GET_REG16(env->pregs[4]);
 961     case 32: GET_REG32(env->pc);
 962     }
 963
 964     return 0;
 965 }
 966
 967 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 968 {
 969     uint32_t tmp;
 970
 971     if (n > 49)
 972         return 0;
 973
 974     tmp = ldl_p(mem_buf);
 975
 976     if (n < 16) {
 977         env->regs[n] = tmp;
 978     }
 979
 980     if (n >= 21 && n < 32) {
 981         env->pregs[n - 16] = tmp;
 982     }
 983
 984     /* FIXME: Should support function regs be writable?  */
 985     switch (n) {
 986     case 16: return 1;
 987     case 17: return 1;
 988     case 18: env->pregs[PR_PID] = tmp; break;
 989     case 19: return 1;
 990     case 20: return 2;
 991     case 32: env->pc = tmp; break;
 992     }
 993
 994     return 4;
 995 }
 996 #else
 997
 998 #define NUM_CORE_REGS 0
 999
1000 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1001 {
1002     return 0;
1003 }
1004
1005 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1006 {
1007     return 0;
1008 }
1009
1010 #endif
1011
1012 static int num_g_regs = NUM_CORE_REGS;
1013
1014 #ifdef GDB_CORE_XML
1015 /* Encode data using the encoding for 'x' packets.  */
1016 static int memtox(char *buf, const char *mem, int len)
1017 {
1018     char *p = buf;
1019     char c;
1020
1021     while (len--) {
1022         c = *(mem++);
1023         switch (c) {
1024         case '#': case '$': case '*': case '}':
1025             *(p++) = '}';
1026             *(p++) = c ^ 0x20;
1027             break;
1028         default:
1029             *(p++) = c;
1030             break;
1031         }
1032     }
1033     return p - buf;
1034 }
1035
1036 const char *get_feature_xml(CPUState *env, const char *p, const char **newp)
1037 {
1038     extern const char *const xml_builtin[][2];
1039     size_t len;
1040     int i;
1041     const char *name;
1042     static char target_xml[1024];
1043
1044     len = 0;
1045     while (p[len] && p[len] != ':')
1046         len++;
1047     *newp = p + len;
1048
1049     name = NULL;
1050     if (strncmp(p, "target.xml", len) == 0) {
1051         /* Generate the XML description for this CPU.  */
1052         if (!target_xml[0]) {
1053             GDBRegisterState *r;
1054
1055             sprintf(target_xml,
1056                     "<?xml version=\"1.0\"?>"
1057                     "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
1058                     "<target>"
1059                     "<xi:include href=\"%s\"/>",
1060                     GDB_CORE_XML);
1061
1062             for (r = env->gdb_regs; r; r = r->next) {
1063                 strcat(target_xml, "<xi:include href=\"");
1064                 strcat(target_xml, r->xml);
1065                 strcat(target_xml, "\"/>");
1066             }
1067             strcat(target_xml, "</target>");
1068         }
1069         return target_xml;
1070     }
1071     for (i = 0; ; i++) {
1072         name = xml_builtin[i][0];
1073         if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
1074             break;
1075     }
1076     return name ? xml_builtin[i][1] : NULL;
1077 }
1078 #endif
1079
1080 static int gdb_read_register(CPUState *env, uint8_t *mem_buf, int reg)
1081 {
1082     GDBRegisterState *r;
1083
1084     if (reg < NUM_CORE_REGS)
1085         return cpu_gdb_read_register(env, mem_buf, reg);
1086
1087     for (r = env->gdb_regs; r; r = r->next) {
1088         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
1089             return r->get_reg(env, mem_buf, reg - r->base_reg);
1090         }
1091     }
1092     return 0;
1093 }
1094
1095 static int gdb_write_register(CPUState *env, uint8_t *mem_buf, int reg)
1096 {
1097     GDBRegisterState *r;
1098
1099     if (reg < NUM_CORE_REGS)
1100         return cpu_gdb_write_register(env, mem_buf, reg);
1101
1102     for (r = env->gdb_regs; r; r = r->next) {
1103         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
1104             return r->set_reg(env, mem_buf, reg - r->base_reg);
1105         }
1106     }
1107     return 0;
1108 }
1109
1110 /* Register a supplemental set of CPU registers.  If g_pos is nonzero it
1111    specifies the first register number and these registers are included in
1112    a standard "g" packet.  Direction is relative to gdb, i.e. get_reg is
1113    gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
1114  */
1115
1116 void gdb_register_coprocessor(CPUState * env,
1117                              gdb_reg_cb get_reg, gdb_reg_cb set_reg,
1118                              int num_regs, const char *xml, int g_pos)
1119 {
1120     GDBRegisterState *s;
1121     GDBRegisterState **p;
1122     static int last_reg = NUM_CORE_REGS;
1123
1124     s = (GDBRegisterState *)qemu_mallocz(sizeof(GDBRegisterState));
1125     s->base_reg = last_reg;
1126     s->num_regs = num_regs;
1127     s->get_reg = get_reg;
1128     s->set_reg = set_reg;
1129     s->xml = xml;
1130     p = &env->gdb_regs;
1131     while (*p) {
1132         /* Check for duplicates.  */
1133         if (strcmp((*p)->xml, xml) == 0)
1134             return;
1135         p = &(*p)->next;
1136     }
1137     /* Add to end of list.  */
1138     last_reg += num_regs;
1139     *p = s;
1140     if (g_pos) {
1141         if (g_pos != s->base_reg) {
1142             fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"
1143                     "Expected %d got %d\n", xml, g_pos, s->base_reg);
1144         } else {
1145             num_g_regs = last_reg;
1146         }
1147     }
1148 }
1149
1150 static int gdb_handle_packet(GDBState *s, CPUState *env, const char *line_buf)
1151 {
1152     const char *p;
1153     int ch, reg_size, type;
1154     char buf[MAX_PACKET_LENGTH];
1155     uint8_t mem_buf[MAX_PACKET_LENGTH];
1156     uint8_t *registers;
1157     target_ulong addr, len;
1158
1159 #ifdef DEBUG_GDB
1160     printf("command='%s'\n", line_buf);
1161 #endif
1162     p = line_buf;
1163     ch = *p++;
1164     switch(ch) {
1165     case '?':
1166         /* TODO: Make this return the correct value for user-mode.  */
1167         snprintf(buf, sizeof(buf), "S%02x", SIGTRAP);
1168         put_packet(s, buf);
1169         /* Remove all the breakpoints when this query is issued,
1170          * because gdb is doing and initial connect and the state
1171          * should be cleaned up.
1172          */
1173         cpu_breakpoint_remove_all(env);
1174         cpu_watchpoint_remove_all(env);
1175         break;
1176     case 'c':
1177         if (*p != '\0') {
1178             addr = strtoull(p, (char **)&p, 16);
1179 #if defined(TARGET_I386)
1180             env->eip = addr;
1181 #elif defined (TARGET_PPC)
1182             env->nip = addr;
1183 #elif defined (TARGET_SPARC)
1184             env->pc = addr;
1185             env->npc = addr + 4;
1186 #elif defined (TARGET_ARM)
1187             env->regs[15] = addr;
1188 #elif defined (TARGET_SH4)
1189             env->pc = addr;
1190 #elif defined (TARGET_MIPS)
1191             env->active_tc.PC = addr;
1192 #elif defined (TARGET_CRIS)
1193             env->pc = addr;
1194 #endif
1195         }
1196         gdb_continue(s);
1197         return RS_IDLE;
1198     case 'C':
1199         s->signal = strtoul(p, (char **)&p, 16);
1200         gdb_continue(s);
1201         return RS_IDLE;
1202     case 'k':
1203         /* Kill the target */
1204         fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
1205         exit(0);
1206     case 'D':
1207         /* Detach packet */
1208         cpu_breakpoint_remove_all(env);
1209         cpu_watchpoint_remove_all(env);
1210         gdb_continue(s);
1211         put_packet(s, "OK");
1212         break;
1213     case 's':
1214         if (*p != '\0') {
1215             addr = strtoull(p, (char **)&p, 16);
1216 #if defined(TARGET_I386)
1217             env->eip = addr;
1218 #elif defined (TARGET_PPC)
1219             env->nip = addr;
1220 #elif defined (TARGET_SPARC)
1221             env->pc = addr;
1222             env->npc = addr + 4;
1223 #elif defined (TARGET_ARM)
1224             env->regs[15] = addr;
1225 #elif defined (TARGET_SH4)
1226             env->pc = addr;
1227 #elif defined (TARGET_MIPS)
1228             env->active_tc.PC = addr;
1229 #elif defined (TARGET_CRIS)
1230             env->pc = addr;
1231 #endif
1232         }
1233         cpu_single_step(env, sstep_flags);
1234         gdb_continue(s);
1235         return RS_IDLE;
1236     case 'F':
1237         {
1238             target_ulong ret;
1239             target_ulong err;
1240
1241             ret = strtoull(p, (char **)&p, 16);
1242             if (*p == ',') {
1243                 p++;
1244                 err = strtoull(p, (char **)&p, 16);
1245             } else {
1246                 err = 0;
1247             }
1248             if (*p == ',')
1249                 p++;
1250             type = *p;
1251             if (gdb_current_syscall_cb)
1252                 gdb_current_syscall_cb(s->env, ret, err);
1253             if (type == 'C') {
1254                 put_packet(s, "T02");
1255             } else {
1256                 gdb_continue(s);
1257             }
1258         }
1259         break;
1260     case 'g':
1261         len = 0;
1262         for (addr = 0; addr < num_g_regs; addr++) {
1263             reg_size = gdb_read_register(env, mem_buf + len, addr);
1264             len += reg_size;
1265         }
1266         memtohex(buf, mem_buf, len);
1267         put_packet(s, buf);
1268         break;
1269     case 'G':
1270         registers = mem_buf;
1271         len = strlen(p) / 2;
1272         hextomem((uint8_t *)registers, p, len);
1273         for (addr = 0; addr < num_g_regs && len > 0; addr++) {
1274             reg_size = gdb_write_register(env, registers, addr);
1275             len -= reg_size;
1276             registers += reg_size;
1277         }
1278         put_packet(s, "OK");
1279         break;
1280     case 'm':
1281         addr = strtoull(p, (char **)&p, 16);
1282         if (*p == ',')
1283             p++;
1284         len = strtoull(p, NULL, 16);
1285         if (cpu_memory_rw_debug(env, addr, mem_buf, len, 0) != 0) {
1286             put_packet (s, "E14");
1287         } else {
1288             memtohex(buf, mem_buf, len);
1289             put_packet(s, buf);
1290         }
1291         break;
1292     case 'M':
1293         addr = strtoull(p, (char **)&p, 16);
1294         if (*p == ',')
1295             p++;
1296         len = strtoull(p, (char **)&p, 16);
1297         if (*p == ':')
1298             p++;
1299         hextomem(mem_buf, p, len);
1300         if (cpu_memory_rw_debug(env, addr, mem_buf, len, 1) != 0)
1301             put_packet(s, "E14");
1302         else
1303             put_packet(s, "OK");
1304         break;
1305     case 'p':
1306         /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
1307            This works, but can be very slow.  Anything new enough to
1308            understand XML also knows how to use this properly.  */
1309         if (!gdb_has_xml)
1310             goto unknown_command;
1311         addr = strtoull(p, (char **)&p, 16);
1312         reg_size = gdb_read_register(env, mem_buf, addr);
1313         if (reg_size) {
1314             memtohex(buf, mem_buf, reg_size);
1315             put_packet(s, buf);
1316         } else {
1317             put_packet(s, "E14");
1318         }
1319         break;
1320     case 'P':
1321         if (!gdb_has_xml)
1322             goto unknown_command;
1323         addr = strtoull(p, (char **)&p, 16);
1324         if (*p == '=')
1325             p++;
1326         reg_size = strlen(p) / 2;
1327         hextomem(mem_buf, p, reg_size);
1328         gdb_write_register(env, mem_buf, addr);
1329         put_packet(s, "OK");
1330         break;
1331     case 'Z':
1332         type = strtoul(p, (char **)&p, 16);
1333         if (*p == ',')
1334             p++;
1335         addr = strtoull(p, (char **)&p, 16);
1336         if (*p == ',')
1337             p++;
1338         len = strtoull(p, (char **)&p, 16);
1339         switch (type) {
1340         case 0:
1341         case 1:
1342             if (cpu_breakpoint_insert(env, addr) < 0)
1343                 goto breakpoint_error;
1344             put_packet(s, "OK");
1345             break;
1346 #ifndef CONFIG_USER_ONLY
1347         case 2:
1348             type = PAGE_WRITE;
1349             goto insert_watchpoint;
1350         case 3:
1351             type = PAGE_READ;
1352             goto insert_watchpoint;
1353         case 4:
1354             type = PAGE_READ | PAGE_WRITE;
1355         insert_watchpoint:
1356             if (cpu_watchpoint_insert(env, addr, type) < 0)
1357                 goto breakpoint_error;
1358             put_packet(s, "OK");
1359             break;
1360 #endif
1361         default:
1362             put_packet(s, "");
1363             break;
1364         }
1365         break;
1366     breakpoint_error:
1367         put_packet(s, "E22");
1368         break;
1369
1370     case 'z':
1371         type = strtoul(p, (char **)&p, 16);
1372         if (*p == ',')
1373             p++;
1374         addr = strtoull(p, (char **)&p, 16);
1375         if (*p == ',')
1376             p++;
1377         len = strtoull(p, (char **)&p, 16);
1378         if (type == 0 || type == 1) {
1379             cpu_breakpoint_remove(env, addr);
1380             put_packet(s, "OK");
1381 #ifndef CONFIG_USER_ONLY
1382         } else if (type >= 2 || type <= 4) {
1383             cpu_watchpoint_remove(env, addr);
1384             put_packet(s, "OK");
1385 #endif
1386         } else {
1387             put_packet(s, "");
1388         }
1389         break;
1390     case 'q':
1391     case 'Q':
1392         /* parse any 'q' packets here */
1393         if (!strcmp(p,"qemu.sstepbits")) {
1394             /* Query Breakpoint bit definitions */
1395             snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1396                      SSTEP_ENABLE,
1397                      SSTEP_NOIRQ,
1398                      SSTEP_NOTIMER);
1399             put_packet(s, buf);
1400             break;
1401         } else if (strncmp(p,"qemu.sstep",10) == 0) {
1402             /* Display or change the sstep_flags */
1403             p += 10;
1404             if (*p != '=') {
1405                 /* Display current setting */
1406                 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1407                 put_packet(s, buf);
1408                 break;
1409             }
1410             p++;
1411             type = strtoul(p, (char **)&p, 16);
1412             sstep_flags = type;
1413             put_packet(s, "OK");
1414             break;
1415         }
1416 #ifdef CONFIG_LINUX_USER
1417         else if (strncmp(p, "Offsets", 7) == 0) {
1418             TaskState *ts = env->opaque;
1419
1420             snprintf(buf, sizeof(buf),
1421                      "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1422                      ";Bss=" TARGET_ABI_FMT_lx,
1423                      ts->info->code_offset,
1424                      ts->info->data_offset,
1425                      ts->info->data_offset);
1426             put_packet(s, buf);
1427             break;
1428         }
1429 #endif
1430         if (strncmp(p, "Supported", 9) == 0) {
1431             sprintf(buf, "PacketSize=%x", MAX_PACKET_LENGTH);
1432 #ifdef GDB_CORE_XML
1433             strcat(buf, ";qXfer:features:read+");
1434 #endif
1435             put_packet(s, buf);
1436             break;
1437         }
1438 #ifdef GDB_CORE_XML
1439         if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1440             const char *xml;
1441             target_ulong total_len;
1442
1443             gdb_has_xml = 1;
1444             p += 19;
1445             xml = get_feature_xml(env, p, &p);
1446             if (!xml) {
1447                 sprintf(buf, "E00");
1448                 put_packet(s, buf);
1449                 break;
1450             }
1451
1452             if (*p == ':')
1453                 p++;
1454             addr = strtoul(p, (char **)&p, 16);
1455             if (*p == ',')
1456                 p++;
1457             len = strtoul(p, (char **)&p, 16);
1458
1459             total_len = strlen(xml);
1460             if (addr > total_len) {
1461                 sprintf(buf, "E00");
1462                 put_packet(s, buf);
1463                 break;
1464             }
1465             if (len > (MAX_PACKET_LENGTH - 5) / 2)
1466                 len = (MAX_PACKET_LENGTH - 5) / 2;
1467             if (len < total_len - addr) {
1468                 buf[0] = 'm';
1469                 len = memtox(buf + 1, xml + addr, len);
1470             } else {
1471                 buf[0] = 'l';
1472                 len = memtox(buf + 1, xml + addr, total_len - addr);
1473             }
1474             put_packet_binary(s, buf, len + 1);
1475             break;
1476         }
1477 #endif
1478         /* Unrecognised 'q' command.  */
1479         goto unknown_command;
1480
1481     default:
1482     unknown_command:
1483         /* put empty packet */
1484         buf[0] = '\0';
1485         put_packet(s, buf);
1486         break;
1487     }
1488     return RS_IDLE;
1489 }
1490
1491 extern void tb_flush(CPUState *env);
1492
1493 #ifndef CONFIG_USER_ONLY
1494 static void gdb_vm_stopped(void *opaque, int reason)
1495 {
1496     GDBState *s = opaque;
1497     char buf[256];
1498     int ret;
1499
1500     if (s->state == RS_SYSCALL)
1501         return;
1502
1503     /* disable single step if it was enable */
1504     cpu_single_step(s->env, 0);
1505
1506     if (reason == EXCP_DEBUG) {
1507         if (s->env->watchpoint_hit) {
1508             snprintf(buf, sizeof(buf), "T%02xwatch:" TARGET_FMT_lx ";",
1509                      SIGTRAP,
1510                      s->env->watchpoint[s->env->watchpoint_hit - 1].vaddr);
1511             put_packet(s, buf);
1512             s->env->watchpoint_hit = 0;
1513             return;
1514         }
1515         tb_flush(s->env);
1516         ret = SIGTRAP;
1517     } else if (reason == EXCP_INTERRUPT) {
1518         ret = SIGINT;
1519     } else {
1520         ret = 0;
1521     }
1522     snprintf(buf, sizeof(buf), "S%02x", ret);
1523     put_packet(s, buf);
1524 }
1525 #endif
1526
1527 /* Send a gdb syscall request.
1528    This accepts limited printf-style format specifiers, specifically:
1529     %x  - target_ulong argument printed in hex.
1530     %lx - 64-bit argument printed in hex.
1531     %s  - string pointer (target_ulong) and length (int) pair.  */
1532 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1533 {
1534     va_list va;
1535     char buf[256];
1536     char *p;
1537     target_ulong addr;
1538     uint64_t i64;
1539     GDBState *s;
1540
1541     s = gdb_syscall_state;
1542     if (!s)
1543         return;
1544     gdb_current_syscall_cb = cb;
1545     s->state = RS_SYSCALL;
1546 #ifndef CONFIG_USER_ONLY
1547     vm_stop(EXCP_DEBUG);
1548 #endif
1549     s->state = RS_IDLE;
1550     va_start(va, fmt);
1551     p = buf;
1552     *(p++) = 'F';
1553     while (*fmt) {
1554         if (*fmt == '%') {
1555             fmt++;
1556             switch (*fmt++) {
1557             case 'x':
1558                 addr = va_arg(va, target_ulong);
1559                 p += snprintf(p, &buf[sizeof(buf)] - p, TARGET_FMT_lx, addr);
1560                 break;
1561             case 'l':
1562                 if (*(fmt++) != 'x')
1563                     goto bad_format;
1564                 i64 = va_arg(va, uint64_t);
1565                 p += snprintf(p, &buf[sizeof(buf)] - p, "%" PRIx64, i64);
1566                 break;
1567             case 's':
1568                 addr = va_arg(va, target_ulong);
1569                 p += snprintf(p, &buf[sizeof(buf)] - p, TARGET_FMT_lx "/%x",
1570                               addr, va_arg(va, int));
1571                 break;
1572             default:
1573             bad_format:
1574                 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1575                         fmt - 1);
1576                 break;
1577             }
1578         } else {
1579             *(p++) = *(fmt++);
1580         }
1581     }
1582     *p = 0;
1583     va_end(va);
1584     put_packet(s, buf);
1585 #ifdef CONFIG_USER_ONLY
1586     gdb_handlesig(s->env, 0);
1587 #else
1588     cpu_interrupt(s->env, CPU_INTERRUPT_EXIT);
1589 #endif
1590 }
1591
1592 static void gdb_read_byte(GDBState *s, int ch)
1593 {
1594     CPUState *env = s->env;
1595     int i, csum;
1596     uint8_t reply;
1597
1598 #ifndef CONFIG_USER_ONLY
1599     if (s->last_packet_len) {
1600         /* Waiting for a response to the last packet.  If we see the start
1601            of a new command then abandon the previous response.  */
1602         if (ch == '-') {
1603 #ifdef DEBUG_GDB
1604             printf("Got NACK, retransmitting\n");
1605 #endif
1606             put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
1607         }
1608 #ifdef DEBUG_GDB
1609         else if (ch == '+')
1610             printf("Got ACK\n");
1611         else
1612             printf("Got '%c' when expecting ACK/NACK\n", ch);
1613 #endif
1614         if (ch == '+' || ch == '$')
1615             s->last_packet_len = 0;
1616         if (ch != '$')
1617             return;
1618     }
1619     if (vm_running) {
1620         /* when the CPU is running, we cannot do anything except stop
1621            it when receiving a char */
1622         vm_stop(EXCP_INTERRUPT);
1623     } else
1624 #endif
1625     {
1626         switch(s->state) {
1627         case RS_IDLE:
1628             if (ch == '$') {
1629                 s->line_buf_index = 0;
1630                 s->state = RS_GETLINE;
1631             }
1632             break;
1633         case RS_GETLINE:
1634             if (ch == '#') {
1635             s->state = RS_CHKSUM1;
1636             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1637                 s->state = RS_IDLE;
1638             } else {
1639             s->line_buf[s->line_buf_index++] = ch;
1640             }
1641             break;
1642         case RS_CHKSUM1:
1643             s->line_buf[s->line_buf_index] = '\0';
1644             s->line_csum = fromhex(ch) << 4;
1645             s->state = RS_CHKSUM2;
1646             break;
1647         case RS_CHKSUM2:
1648             s->line_csum |= fromhex(ch);
1649             csum = 0;
1650             for(i = 0; i < s->line_buf_index; i++) {
1651                 csum += s->line_buf[i];
1652             }
1653             if (s->line_csum != (csum & 0xff)) {
1654                 reply = '-';
1655                 put_buffer(s, &reply, 1);
1656                 s->state = RS_IDLE;
1657             } else {
1658                 reply = '+';
1659                 put_buffer(s, &reply, 1);
1660                 s->state = gdb_handle_packet(s, env, s->line_buf);
1661             }
1662             break;
1663         default:
1664             abort();
1665         }
1666     }
1667 }
1668
1669 #ifdef CONFIG_USER_ONLY
1670 int
1671 gdb_handlesig (CPUState *env, int sig)
1672 {
1673   GDBState *s;
1674   char buf[256];
1675   int n;
1676
1677   s = &gdbserver_state;
1678   if (gdbserver_fd < 0 || s->fd < 0)
1679     return sig;
1680
1681   /* disable single step if it was enabled */
1682   cpu_single_step(env, 0);
1683   tb_flush(env);
1684
1685   if (sig != 0)
1686     {
1687       snprintf(buf, sizeof(buf), "S%02x", sig);
1688       put_packet(s, buf);
1689     }
1690   /* put_packet() might have detected that the peer terminated the
1691      connection.  */
1692   if (s->fd < 0)
1693       return sig;
1694
1695   sig = 0;
1696   s->state = RS_IDLE;
1697   s->running_state = 0;
1698   while (s->running_state == 0) {
1699       n = read (s->fd, buf, 256);
1700       if (n > 0)
1701         {
1702           int i;
1703
1704           for (i = 0; i < n; i++)
1705             gdb_read_byte (s, buf[i]);
1706         }
1707       else if (n == 0 || errno != EAGAIN)
1708         {
1709           /* XXX: Connection closed.  Should probably wait for annother
1710              connection before continuing.  */
1711           return sig;
1712         }
1713   }
1714   sig = s->signal;
1715   s->signal = 0;
1716   return sig;
1717 }
1718
1719 /* Tell the remote gdb that the process has exited.  */
1720 void gdb_exit(CPUState *env, int code)
1721 {
1722   GDBState *s;
1723   char buf[4];
1724
1725   s = &gdbserver_state;
1726   if (gdbserver_fd < 0 || s->fd < 0)
1727     return;
1728
1729   snprintf(buf, sizeof(buf), "W%02x", code);
1730   put_packet(s, buf);
1731 }
1732
1733
1734 static void gdb_accept(void *opaque)
1735 {
1736     GDBState *s;
1737     struct sockaddr_in sockaddr;
1738     socklen_t len;
1739     int val, fd;
1740
1741     for(;;) {
1742         len = sizeof(sockaddr);
1743         fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1744         if (fd < 0 && errno != EINTR) {
1745             perror("accept");
1746             return;
1747         } else if (fd >= 0) {
1748             break;
1749         }
1750     }
1751
1752     /* set short latency */
1753     val = 1;
1754     setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
1755
1756     s = &gdbserver_state;
1757     memset (s, 0, sizeof (GDBState));
1758     s->env = first_cpu; /* XXX: allow to change CPU */
1759     s->fd = fd;
1760     gdb_has_xml = 0;
1761
1762     gdb_syscall_state = s;
1763
1764     fcntl(fd, F_SETFL, O_NONBLOCK);
1765 }
1766
1767 static int gdbserver_open(int port)
1768 {
1769     struct sockaddr_in sockaddr;
1770     int fd, val, ret;
1771
1772     fd = socket(PF_INET, SOCK_STREAM, 0);
1773     if (fd < 0) {
1774         perror("socket");
1775         return -1;
1776     }
1777
1778     /* allow fast reuse */
1779     val = 1;
1780     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
1781
1782     sockaddr.sin_family = AF_INET;
1783     sockaddr.sin_port = htons(port);
1784     sockaddr.sin_addr.s_addr = 0;
1785     ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1786     if (ret < 0) {
1787         perror("bind");
1788         return -1;
1789     }
1790     ret = listen(fd, 0);
1791     if (ret < 0) {
1792         perror("listen");
1793         return -1;
1794     }
1795     return fd;
1796 }
1797
1798 int gdbserver_start(int port)
1799 {
1800     gdbserver_fd = gdbserver_open(port);
1801     if (gdbserver_fd < 0)
1802         return -1;
1803     /* accept connections */
1804     gdb_accept (NULL);
1805     return 0;
1806 }
1807 #else
1808 static int gdb_chr_can_receive(void *opaque)
1809 {
1810   /* We can handle an arbitrarily large amount of data.
1811    Pick the maximum packet size, which is as good as anything.  */
1812   return MAX_PACKET_LENGTH;
1813 }
1814
1815 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
1816 {
1817     GDBState *s = opaque;
1818     int i;
1819
1820     for (i = 0; i < size; i++) {
1821         gdb_read_byte(s, buf[i]);
1822     }
1823 }
1824
1825 static void gdb_chr_event(void *opaque, int event)
1826 {
1827     switch (event) {
1828     case CHR_EVENT_RESET:
1829         vm_stop(EXCP_INTERRUPT);
1830         gdb_syscall_state = opaque;
1831         gdb_has_xml = 0;
1832         break;
1833     default:
1834         break;
1835     }
1836 }
1837
1838 int gdbserver_start(const char *port)
1839 {
1840     GDBState *s;
1841     char gdbstub_port_name[128];
1842     int port_num;
1843     char *p;
1844     CharDriverState *chr;
1845
1846     if (!port || !*port)
1847       return -1;
1848
1849     port_num = strtol(port, &p, 10);
1850     if (*p == 0) {
1851         /* A numeric value is interpreted as a port number.  */
1852         snprintf(gdbstub_port_name, sizeof(gdbstub_port_name),
1853                  "tcp::%d,nowait,nodelay,server", port_num);
1854         port = gdbstub_port_name;
1855     }
1856
1857     chr = qemu_chr_open(port);
1858     if (!chr)
1859         return -1;
1860
1861     s = qemu_mallocz(sizeof(GDBState));
1862     if (!s) {
1863         return -1;
1864     }
1865     s->env = first_cpu; /* XXX: allow to change CPU */
1866     s->chr = chr;
1867     qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1868                           gdb_chr_event, s);
1869     qemu_add_vm_stop_handler(gdb_vm_stopped, s);
1870     return 0;
1871 }
1872 #endif