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_REGL(env->xer);
 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             env->xer = ldtul_p(mem_buf);
 489             return sizeof(target_ulong);
 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         env->fpr[n] = ldfl_p(mem_buf);
 608         return 4;
 609     } else if (n < 80) {
 610         /* f32-f62 (double width, even numbers only) */
 611         *((uint32_t *)&env->fpr[(n - 64) * 2 + 32]) = tmp >> 32;
 612         *((uint32_t *)&env->fpr[(n - 64) * 2 + 33]) = tmp;
 613     } else {
 614         switch (n) {
 615         case 80: env->pc = tmp; break;
 616         case 81: env->npc = tmp; break;
 617         case 82:
 618             PUT_CCR(env, tmp >> 32);
 619             env->asi = (tmp >> 24) & 0xff;
 620             env->pstate = (tmp >> 8) & 0xfff;
 621             PUT_CWP64(env, tmp & 0xff);
 622             break;
 623         case 83: env->fsr = tmp; break;
 624         case 84: env->fprs = tmp; break;
 625         case 85: env->y = tmp; break;
 626         default: return 0;
 627         }
 628     }
 629     return 8;
 630 #endif
 631 }
 632 #elif defined (TARGET_ARM)
 633
 634 /* Old gdb always expect FPA registers.  Newer (xml-aware) gdb only expect
 635    whatever the target description contains.  Due to a historical mishap
 636    the FPA registers appear in between core integer regs and the CPSR.
 637    We hack round this by giving the FPA regs zero size when talking to a
 638    newer gdb.  */
 639 #define NUM_CORE_REGS 26
 640 #define GDB_CORE_XML "arm-core.xml"
 641
 642 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 643 {
 644     if (n < 16) {
 645         /* Core integer register.  */
 646         GET_REG32(env->regs[n]);
 647     }
 648     if (n < 24) {
 649         /* FPA registers.  */
 650         if (gdb_has_xml)
 651             return 0;
 652         memset(mem_buf, 0, 12);
 653         return 12;
 654     }
 655     switch (n) {
 656     case 24:
 657         /* FPA status register.  */
 658         if (gdb_has_xml)
 659             return 0;
 660         GET_REG32(0);
 661     case 25:
 662         /* CPSR */
 663         GET_REG32(cpsr_read(env));
 664     }
 665     /* Unknown register.  */
 666     return 0;
 667 }
 668
 669 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 670 {
 671     uint32_t tmp;
 672
 673     tmp = ldl_p(mem_buf);
 674
 675     /* Mask out low bit of PC to workaround gdb bugs.  This will probably
 676        cause problems if we ever implement the Jazelle DBX extensions.  */
 677     if (n == 15)
 678         tmp &= ~1;
 679
 680     if (n < 16) {
 681         /* Core integer register.  */
 682         env->regs[n] = tmp;
 683         return 4;
 684     }
 685     if (n < 24) { /* 16-23 */
 686         /* FPA registers (ignored).  */
 687         if (gdb_has_xml)
 688             return 0;
 689         return 12;
 690     }
 691     switch (n) {
 692     case 24:
 693         /* FPA status register (ignored).  */
 694         if (gdb_has_xml)
 695             return 0;
 696         return 4;
 697     case 25:
 698         /* CPSR */
 699         cpsr_write (env, tmp, 0xffffffff);
 700         return 4;
 701     }
 702     /* Unknown register.  */
 703     return 0;
 704 }
 705
 706 #elif defined (TARGET_M68K)
 707
 708 #define NUM_CORE_REGS 18
 709
 710 #define GDB_CORE_XML "cf-core.xml"
 711
 712 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 713 {
 714     if (n < 8) {
 715         /* D0-D7 */
 716         GET_REG32(env->dregs[n]);
 717     } else if (n < 16) {
 718         /* A0-A7 */
 719         GET_REG32(env->aregs[n - 8]);
 720     } else {
 721         switch (n) {
 722         case 16: GET_REG32(env->sr);
 723         case 17: GET_REG32(env->pc);
 724         }
 725     }
 726     /* FP registers not included here because they vary between
 727        ColdFire and m68k.  Use XML bits for these.  */
 728     return 0;
 729 }
 730
 731 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 732 {
 733     uint32_t tmp;
 734
 735     tmp = ldl_p(mem_buf);
 736
 737     if (n < 8) {
 738         /* D0-D7 */
 739         env->dregs[n] = tmp;
 740     } else if (n < 8) {
 741         /* A0-A7 */
 742         env->aregs[n - 8] = tmp;
 743     } else {
 744         switch (n) {
 745         case 16: env->sr = tmp; break;
 746         case 17: env->pc = tmp; break;
 747         default: return 0;
 748         }
 749     }
 750     return 4;
 751 }
 752 #elif defined (TARGET_MIPS)
 753
 754 #define NUM_CORE_REGS 73
 755
 756 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 757 {
 758     if (n < 32) {
 759         GET_REGL(env->active_tc.gpr[n]);
 760     }
 761     if (env->CP0_Config1 & (1 << CP0C1_FP)) {
 762         if (n >= 38 && n < 70) {
 763             if (env->CP0_Status & (1 << CP0St_FR))
 764                 GET_REGL(env->active_fpu.fpr[n - 38].d);
 765             else
 766                 GET_REGL(env->active_fpu.fpr[n - 38].w[FP_ENDIAN_IDX]);
 767         }
 768         switch (n) {
 769         case 70: GET_REGL((int32_t)env->active_fpu.fcr31);
 770         case 71: GET_REGL((int32_t)env->active_fpu.fcr0);
 771         }
 772     }
 773     switch (n) {
 774     case 32: GET_REGL((int32_t)env->CP0_Status);
 775     case 33: GET_REGL(env->active_tc.LO[0]);
 776     case 34: GET_REGL(env->active_tc.HI[0]);
 777     case 35: GET_REGL(env->CP0_BadVAddr);
 778     case 36: GET_REGL((int32_t)env->CP0_Cause);
 779     case 37: GET_REGL(env->active_tc.PC);
 780     case 72: GET_REGL(0); /* fp */
 781     case 89: GET_REGL((int32_t)env->CP0_PRid);
 782     }
 783     if (n >= 73 && n <= 88) {
 784         /* 16 embedded regs.  */
 785         GET_REGL(0);
 786     }
 787
 788     return 0;
 789 }
 790
 791 /* convert MIPS rounding mode in FCR31 to IEEE library */
 792 static unsigned int ieee_rm[] =
 793   {
 794     float_round_nearest_even,
 795     float_round_to_zero,
 796     float_round_up,
 797     float_round_down
 798   };
 799 #define RESTORE_ROUNDING_MODE \
 800     set_float_rounding_mode(ieee_rm[env->active_fpu.fcr31 & 3], &env->active_fpu.fp_status)
 801
 802 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 803 {
 804     target_ulong tmp;
 805
 806     tmp = ldtul_p(mem_buf);
 807
 808     if (n < 32) {
 809         env->active_tc.gpr[n] = tmp;
 810         return sizeof(target_ulong);
 811     }
 812     if (env->CP0_Config1 & (1 << CP0C1_FP)
 813             && n >= 38 && n < 73) {
 814         if (n < 70) {
 815             if (env->CP0_Status & (1 << CP0St_FR))
 816               env->active_fpu.fpr[n - 38].d = tmp;
 817             else
 818               env->active_fpu.fpr[n - 38].w[FP_ENDIAN_IDX] = tmp;
 819         }
 820         switch (n) {
 821         case 70:
 822             env->active_fpu.fcr31 = tmp & 0xFF83FFFF;
 823             /* set rounding mode */
 824             RESTORE_ROUNDING_MODE;
 825 #ifndef CONFIG_SOFTFLOAT
 826             /* no floating point exception for native float */
 827             SET_FP_ENABLE(env->active_fpu.fcr31, 0);
 828 #endif
 829             break;
 830         case 71: env->active_fpu.fcr0 = tmp; break;
 831         }
 832         return sizeof(target_ulong);
 833     }
 834     switch (n) {
 835     case 32: env->CP0_Status = tmp; break;
 836     case 33: env->active_tc.LO[0] = tmp; break;
 837     case 34: env->active_tc.HI[0] = tmp; break;
 838     case 35: env->CP0_BadVAddr = tmp; break;
 839     case 36: env->CP0_Cause = tmp; break;
 840     case 37: env->active_tc.PC = tmp; break;
 841     case 72: /* fp, ignored */ break;
 842     default:
 843         if (n > 89)
 844             return 0;
 845         /* Other registers are readonly.  Ignore writes.  */
 846         break;
 847     }
 848
 849     return sizeof(target_ulong);
 850 }
 851 #elif defined (TARGET_SH4)
 852
 853 /* Hint: Use "set architecture sh4" in GDB to see fpu registers */
 854 /* FIXME: We should use XML for this.  */
 855
 856 #define NUM_CORE_REGS 59
 857
 858 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 859 {
 860     if (n < 8) {
 861         if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
 862             GET_REGL(env->gregs[n + 16]);
 863         } else {
 864             GET_REGL(env->gregs[n]);
 865         }
 866     } else if (n < 16) {
 867         GET_REGL(env->gregs[n - 8]);
 868     } else if (n >= 25 && n < 41) {
 869         GET_REGL(env->fregs[(n - 25) + ((env->fpscr & FPSCR_FR) ? 16 : 0)]);
 870     } else if (n >= 43 && n < 51) {
 871         GET_REGL(env->gregs[n - 43]);
 872     } else if (n >= 51 && n < 59) {
 873         GET_REGL(env->gregs[n - (51 - 16)]);
 874     }
 875     switch (n) {
 876     case 16: GET_REGL(env->pc);
 877     case 17: GET_REGL(env->pr);
 878     case 18: GET_REGL(env->gbr);
 879     case 19: GET_REGL(env->vbr);
 880     case 20: GET_REGL(env->mach);
 881     case 21: GET_REGL(env->macl);
 882     case 22: GET_REGL(env->sr);
 883     case 23: GET_REGL(env->fpul);
 884     case 24: GET_REGL(env->fpscr);
 885     case 41: GET_REGL(env->ssr);
 886     case 42: GET_REGL(env->spc);
 887     }
 888
 889     return 0;
 890 }
 891
 892 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 893 {
 894     uint32_t tmp;
 895
 896     tmp = ldl_p(mem_buf);
 897
 898     if (n < 8) {
 899         if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
 900             env->gregs[n + 16] = tmp;
 901         } else {
 902             env->gregs[n] = tmp;
 903         }
 904         return 4;
 905     } else if (n < 16) {
 906         env->gregs[n - 8] = tmp;
 907         return 4;
 908     } else if (n >= 25 && n < 41) {
 909         env->fregs[(n - 25) + ((env->fpscr & FPSCR_FR) ? 16 : 0)] = tmp;
 910     } else if (n >= 43 && n < 51) {
 911         env->gregs[n - 43] = tmp;
 912         return 4;
 913     } else if (n >= 51 && n < 59) {
 914         env->gregs[n - (51 - 16)] = tmp;
 915         return 4;
 916     }
 917     switch (n) {
 918     case 16: env->pc = tmp;
 919     case 17: env->pr = tmp;
 920     case 18: env->gbr = tmp;
 921     case 19: env->vbr = tmp;
 922     case 20: env->mach = tmp;
 923     case 21: env->macl = tmp;
 924     case 22: env->sr = tmp;
 925     case 23: env->fpul = tmp;
 926     case 24: env->fpscr = tmp;
 927     case 41: env->ssr = tmp;
 928     case 42: env->spc = tmp;
 929     default: return 0;
 930     }
 931
 932     return 4;
 933 }
 934 #elif defined (TARGET_CRIS)
 935
 936 #define NUM_CORE_REGS 49
 937
 938 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 939 {
 940     uint8_t srs;
 941
 942     srs = env->pregs[PR_SRS];
 943     if (n < 16) {
 944         GET_REG32(env->regs[n]);
 945     }
 946
 947     if (n >= 21 && n < 32) {
 948         GET_REG32(env->pregs[n - 16]);
 949     }
 950     if (n >= 33 && n < 49) {
 951         GET_REG32(env->sregs[srs][n - 33]);
 952     }
 953     switch (n) {
 954     case 16: GET_REG8(env->pregs[0]);
 955     case 17: GET_REG8(env->pregs[1]);
 956     case 18: GET_REG32(env->pregs[2]);
 957     case 19: GET_REG8(srs);
 958     case 20: GET_REG16(env->pregs[4]);
 959     case 32: GET_REG32(env->pc);
 960     }
 961
 962     return 0;
 963 }
 964
 965 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
 966 {
 967     uint32_t tmp;
 968
 969     if (n > 49)
 970         return 0;
 971
 972     tmp = ldl_p(mem_buf);
 973
 974     if (n < 16) {
 975         env->regs[n] = tmp;
 976     }
 977
 978     if (n >= 21 && n < 32) {
 979         env->pregs[n - 16] = tmp;
 980     }
 981
 982     /* FIXME: Should support function regs be writable?  */
 983     switch (n) {
 984     case 16: return 1;
 985     case 17: return 1;
 986     case 18: env->pregs[PR_PID] = tmp; break;
 987     case 19: return 1;
 988     case 20: return 2;
 989     case 32: env->pc = tmp; break;
 990     }
 991
 992     return 4;
 993 }
 994 #else
 995
 996 #define NUM_CORE_REGS 0
 997
 998 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 999 {
1000     return 0;
1001 }
1002
1003 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1004 {
1005     return 0;
1006 }
1007
1008 #endif
1009
1010 static int num_g_regs = NUM_CORE_REGS;
1011
1012 #ifdef GDB_CORE_XML
1013 /* Encode data using the encoding for 'x' packets.  */
1014 static int memtox(char *buf, const char *mem, int len)
1015 {
1016     char *p = buf;
1017     char c;
1018
1019     while (len--) {
1020         c = *(mem++);
1021         switch (c) {
1022         case '#': case '$': case '*': case '}':
1023             *(p++) = '}';
1024             *(p++) = c ^ 0x20;
1025             break;
1026         default:
1027             *(p++) = c;
1028             break;
1029         }
1030     }
1031     return p - buf;
1032 }
1033
1034 const char *get_feature_xml(CPUState *env, const char *p, const char **newp)
1035 {
1036     extern const char *const xml_builtin[][2];
1037     size_t len;
1038     int i;
1039     const char *name;
1040     static char target_xml[1024];
1041
1042     len = 0;
1043     while (p[len] && p[len] != ':')
1044         len++;
1045     *newp = p + len;
1046
1047     name = NULL;
1048     if (strncmp(p, "target.xml", len) == 0) {
1049         /* Generate the XML description for this CPU.  */
1050         if (!target_xml[0]) {
1051             GDBRegisterState *r;
1052
1053             snprintf(target_xml, sizeof(target_xml),
1054                      "<?xml version=\"1.0\"?>"
1055                      "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
1056                      "<target>"
1057                      "<xi:include href=\"%s\"/>",
1058                      GDB_CORE_XML);
1059
1060             for (r = env->gdb_regs; r; r = r->next) {
1061                 strcat(target_xml, "<xi:include href=\"");
1062                 strcat(target_xml, r->xml);
1063                 strcat(target_xml, "\"/>");
1064             }
1065             strcat(target_xml, "</target>");
1066         }
1067         return target_xml;
1068     }
1069     for (i = 0; ; i++) {
1070         name = xml_builtin[i][0];
1071         if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
1072             break;
1073     }
1074     return name ? xml_builtin[i][1] : NULL;
1075 }
1076 #endif
1077
1078 static int gdb_read_register(CPUState *env, uint8_t *mem_buf, int reg)
1079 {
1080     GDBRegisterState *r;
1081
1082     if (reg < NUM_CORE_REGS)
1083         return cpu_gdb_read_register(env, mem_buf, reg);
1084
1085     for (r = env->gdb_regs; r; r = r->next) {
1086         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
1087             return r->get_reg(env, mem_buf, reg - r->base_reg);
1088         }
1089     }
1090     return 0;
1091 }
1092
1093 static int gdb_write_register(CPUState *env, uint8_t *mem_buf, int reg)
1094 {
1095     GDBRegisterState *r;
1096
1097     if (reg < NUM_CORE_REGS)
1098         return cpu_gdb_write_register(env, mem_buf, reg);
1099
1100     for (r = env->gdb_regs; r; r = r->next) {
1101         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
1102             return r->set_reg(env, mem_buf, reg - r->base_reg);
1103         }
1104     }
1105     return 0;
1106 }
1107
1108 /* Register a supplemental set of CPU registers.  If g_pos is nonzero it
1109    specifies the first register number and these registers are included in
1110    a standard "g" packet.  Direction is relative to gdb, i.e. get_reg is
1111    gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
1112  */
1113
1114 void gdb_register_coprocessor(CPUState * env,
1115                              gdb_reg_cb get_reg, gdb_reg_cb set_reg,
1116                              int num_regs, const char *xml, int g_pos)
1117 {
1118     GDBRegisterState *s;
1119     GDBRegisterState **p;
1120     static int last_reg = NUM_CORE_REGS;
1121
1122     s = (GDBRegisterState *)qemu_mallocz(sizeof(GDBRegisterState));
1123     s->base_reg = last_reg;
1124     s->num_regs = num_regs;
1125     s->get_reg = get_reg;
1126     s->set_reg = set_reg;
1127     s->xml = xml;
1128     p = &env->gdb_regs;
1129     while (*p) {
1130         /* Check for duplicates.  */
1131         if (strcmp((*p)->xml, xml) == 0)
1132             return;
1133         p = &(*p)->next;
1134     }
1135     /* Add to end of list.  */
1136     last_reg += num_regs;
1137     *p = s;
1138     if (g_pos) {
1139         if (g_pos != s->base_reg) {
1140             fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"
1141                     "Expected %d got %d\n", xml, g_pos, s->base_reg);
1142         } else {
1143             num_g_regs = last_reg;
1144         }
1145     }
1146 }
1147
1148 static int gdb_handle_packet(GDBState *s, CPUState *env, const char *line_buf)
1149 {
1150     const char *p;
1151     int ch, reg_size, type;
1152     char buf[MAX_PACKET_LENGTH];
1153     uint8_t mem_buf[MAX_PACKET_LENGTH];
1154     uint8_t *registers;
1155     target_ulong addr, len;
1156
1157 #ifdef DEBUG_GDB
1158     printf("command='%s'\n", line_buf);
1159 #endif
1160     p = line_buf;
1161     ch = *p++;
1162     switch(ch) {
1163     case '?':
1164         /* TODO: Make this return the correct value for user-mode.  */
1165         snprintf(buf, sizeof(buf), "S%02x", SIGTRAP);
1166         put_packet(s, buf);
1167         /* Remove all the breakpoints when this query is issued,
1168          * because gdb is doing and initial connect and the state
1169          * should be cleaned up.
1170          */
1171         cpu_breakpoint_remove_all(env);
1172         cpu_watchpoint_remove_all(env);
1173         break;
1174     case 'c':
1175         if (*p != '\0') {
1176             addr = strtoull(p, (char **)&p, 16);
1177 #if defined(TARGET_I386)
1178             env->eip = addr;
1179 #elif defined (TARGET_PPC)
1180             env->nip = addr;
1181 #elif defined (TARGET_SPARC)
1182             env->pc = addr;
1183             env->npc = addr + 4;
1184 #elif defined (TARGET_ARM)
1185             env->regs[15] = addr;
1186 #elif defined (TARGET_SH4)
1187             env->pc = addr;
1188 #elif defined (TARGET_MIPS)
1189             env->active_tc.PC = addr;
1190 #elif defined (TARGET_CRIS)
1191             env->pc = addr;
1192 #endif
1193         }
1194         gdb_continue(s);
1195         return RS_IDLE;
1196     case 'C':
1197         s->signal = strtoul(p, (char **)&p, 16);
1198         gdb_continue(s);
1199         return RS_IDLE;
1200     case 'k':
1201         /* Kill the target */
1202         fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
1203         exit(0);
1204     case 'D':
1205         /* Detach packet */
1206         cpu_breakpoint_remove_all(env);
1207         cpu_watchpoint_remove_all(env);
1208         gdb_continue(s);
1209         put_packet(s, "OK");
1210         break;
1211     case 's':
1212         if (*p != '\0') {
1213             addr = strtoull(p, (char **)&p, 16);
1214 #if defined(TARGET_I386)
1215             env->eip = addr;
1216 #elif defined (TARGET_PPC)
1217             env->nip = addr;
1218 #elif defined (TARGET_SPARC)
1219             env->pc = addr;
1220             env->npc = addr + 4;
1221 #elif defined (TARGET_ARM)
1222             env->regs[15] = addr;
1223 #elif defined (TARGET_SH4)
1224             env->pc = addr;
1225 #elif defined (TARGET_MIPS)
1226             env->active_tc.PC = addr;
1227 #elif defined (TARGET_CRIS)
1228             env->pc = addr;
1229 #endif
1230         }
1231         cpu_single_step(env, sstep_flags);
1232         gdb_continue(s);
1233         return RS_IDLE;
1234     case 'F':
1235         {
1236             target_ulong ret;
1237             target_ulong err;
1238
1239             ret = strtoull(p, (char **)&p, 16);
1240             if (*p == ',') {
1241                 p++;
1242                 err = strtoull(p, (char **)&p, 16);
1243             } else {
1244                 err = 0;
1245             }
1246             if (*p == ',')
1247                 p++;
1248             type = *p;
1249             if (gdb_current_syscall_cb)
1250                 gdb_current_syscall_cb(s->env, ret, err);
1251             if (type == 'C') {
1252                 put_packet(s, "T02");
1253             } else {
1254                 gdb_continue(s);
1255             }
1256         }
1257         break;
1258     case 'g':
1259         len = 0;
1260         for (addr = 0; addr < num_g_regs; addr++) {
1261             reg_size = gdb_read_register(env, mem_buf + len, addr);
1262             len += reg_size;
1263         }
1264         memtohex(buf, mem_buf, len);
1265         put_packet(s, buf);
1266         break;
1267     case 'G':
1268         registers = mem_buf;
1269         len = strlen(p) / 2;
1270         hextomem((uint8_t *)registers, p, len);
1271         for (addr = 0; addr < num_g_regs && len > 0; addr++) {
1272             reg_size = gdb_write_register(env, registers, addr);
1273             len -= reg_size;
1274             registers += reg_size;
1275         }
1276         put_packet(s, "OK");
1277         break;
1278     case 'm':
1279         addr = strtoull(p, (char **)&p, 16);
1280         if (*p == ',')
1281             p++;
1282         len = strtoull(p, NULL, 16);
1283         if (cpu_memory_rw_debug(env, addr, mem_buf, len, 0) != 0) {
1284             put_packet (s, "E14");
1285         } else {
1286             memtohex(buf, mem_buf, len);
1287             put_packet(s, buf);
1288         }
1289         break;
1290     case 'M':
1291         addr = strtoull(p, (char **)&p, 16);
1292         if (*p == ',')
1293             p++;
1294         len = strtoull(p, (char **)&p, 16);
1295         if (*p == ':')
1296             p++;
1297         hextomem(mem_buf, p, len);
1298         if (cpu_memory_rw_debug(env, addr, mem_buf, len, 1) != 0)
1299             put_packet(s, "E14");
1300         else
1301             put_packet(s, "OK");
1302         break;
1303     case 'p':
1304         /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
1305            This works, but can be very slow.  Anything new enough to
1306            understand XML also knows how to use this properly.  */
1307         if (!gdb_has_xml)
1308             goto unknown_command;
1309         addr = strtoull(p, (char **)&p, 16);
1310         reg_size = gdb_read_register(env, mem_buf, addr);
1311         if (reg_size) {
1312             memtohex(buf, mem_buf, reg_size);
1313             put_packet(s, buf);
1314         } else {
1315             put_packet(s, "E14");
1316         }
1317         break;
1318     case 'P':
1319         if (!gdb_has_xml)
1320             goto unknown_command;
1321         addr = strtoull(p, (char **)&p, 16);
1322         if (*p == '=')
1323             p++;
1324         reg_size = strlen(p) / 2;
1325         hextomem(mem_buf, p, reg_size);
1326         gdb_write_register(env, mem_buf, addr);
1327         put_packet(s, "OK");
1328         break;
1329     case 'Z':
1330         type = strtoul(p, (char **)&p, 16);
1331         if (*p == ',')
1332             p++;
1333         addr = strtoull(p, (char **)&p, 16);
1334         if (*p == ',')
1335             p++;
1336         len = strtoull(p, (char **)&p, 16);
1337         switch (type) {
1338         case 0:
1339         case 1:
1340             if (cpu_breakpoint_insert(env, addr) < 0)
1341                 goto breakpoint_error;
1342             put_packet(s, "OK");
1343             break;
1344 #ifndef CONFIG_USER_ONLY
1345         case 2:
1346             type = PAGE_WRITE;
1347             goto insert_watchpoint;
1348         case 3:
1349             type = PAGE_READ;
1350             goto insert_watchpoint;
1351         case 4:
1352             type = PAGE_READ | PAGE_WRITE;
1353         insert_watchpoint:
1354             if (cpu_watchpoint_insert(env, addr, type) < 0)
1355                 goto breakpoint_error;
1356             put_packet(s, "OK");
1357             break;
1358 #endif
1359         default:
1360             put_packet(s, "");
1361             break;
1362         }
1363         break;
1364     breakpoint_error:
1365         put_packet(s, "E22");
1366         break;
1367
1368     case 'z':
1369         type = strtoul(p, (char **)&p, 16);
1370         if (*p == ',')
1371             p++;
1372         addr = strtoull(p, (char **)&p, 16);
1373         if (*p == ',')
1374             p++;
1375         len = strtoull(p, (char **)&p, 16);
1376         if (type == 0 || type == 1) {
1377             cpu_breakpoint_remove(env, addr);
1378             put_packet(s, "OK");
1379 #ifndef CONFIG_USER_ONLY
1380         } else if (type >= 2 || type <= 4) {
1381             cpu_watchpoint_remove(env, addr);
1382             put_packet(s, "OK");
1383 #endif
1384         } else {
1385             put_packet(s, "");
1386         }
1387         break;
1388     case 'q':
1389     case 'Q':
1390         /* parse any 'q' packets here */
1391         if (!strcmp(p,"qemu.sstepbits")) {
1392             /* Query Breakpoint bit definitions */
1393             snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1394                      SSTEP_ENABLE,
1395                      SSTEP_NOIRQ,
1396                      SSTEP_NOTIMER);
1397             put_packet(s, buf);
1398             break;
1399         } else if (strncmp(p,"qemu.sstep",10) == 0) {
1400             /* Display or change the sstep_flags */
1401             p += 10;
1402             if (*p != '=') {
1403                 /* Display current setting */
1404                 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1405                 put_packet(s, buf);
1406                 break;
1407             }
1408             p++;
1409             type = strtoul(p, (char **)&p, 16);
1410             sstep_flags = type;
1411             put_packet(s, "OK");
1412             break;
1413         }
1414 #ifdef CONFIG_LINUX_USER
1415         else if (strncmp(p, "Offsets", 7) == 0) {
1416             TaskState *ts = env->opaque;
1417
1418             snprintf(buf, sizeof(buf),
1419                      "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1420                      ";Bss=" TARGET_ABI_FMT_lx,
1421                      ts->info->code_offset,
1422                      ts->info->data_offset,
1423                      ts->info->data_offset);
1424             put_packet(s, buf);
1425             break;
1426         }
1427 #endif
1428         if (strncmp(p, "Supported", 9) == 0) {
1429             snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1430 #ifdef GDB_CORE_XML
1431             strcat(buf, ";qXfer:features:read+");
1432 #endif
1433             put_packet(s, buf);
1434             break;
1435         }
1436 #ifdef GDB_CORE_XML
1437         if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1438             const char *xml;
1439             target_ulong total_len;
1440
1441             gdb_has_xml = 1;
1442             p += 19;
1443             xml = get_feature_xml(env, p, &p);
1444             if (!xml) {
1445                 snprintf(buf, sizeof(buf), "E00");
1446                 put_packet(s, buf);
1447                 break;
1448             }
1449
1450             if (*p == ':')
1451                 p++;
1452             addr = strtoul(p, (char **)&p, 16);
1453             if (*p == ',')
1454                 p++;
1455             len = strtoul(p, (char **)&p, 16);
1456
1457             total_len = strlen(xml);
1458             if (addr > total_len) {
1459                 snprintf(buf, sizeof(buf), "E00");
1460                 put_packet(s, buf);
1461                 break;
1462             }
1463             if (len > (MAX_PACKET_LENGTH - 5) / 2)
1464                 len = (MAX_PACKET_LENGTH - 5) / 2;
1465             if (len < total_len - addr) {
1466                 buf[0] = 'm';
1467                 len = memtox(buf + 1, xml + addr, len);
1468             } else {
1469                 buf[0] = 'l';
1470                 len = memtox(buf + 1, xml + addr, total_len - addr);
1471             }
1472             put_packet_binary(s, buf, len + 1);
1473             break;
1474         }
1475 #endif
1476         /* Unrecognised 'q' command.  */
1477         goto unknown_command;
1478
1479     default:
1480     unknown_command:
1481         /* put empty packet */
1482         buf[0] = '\0';
1483         put_packet(s, buf);
1484         break;
1485     }
1486     return RS_IDLE;
1487 }
1488
1489 extern void tb_flush(CPUState *env);
1490
1491 #ifndef CONFIG_USER_ONLY
1492 static void gdb_vm_stopped(void *opaque, int reason)
1493 {
1494     GDBState *s = opaque;
1495     char buf[256];
1496     const char *type;
1497     int ret;
1498
1499     if (s->state == RS_SYSCALL)
1500         return;
1501
1502     /* disable single step if it was enable */
1503     cpu_single_step(s->env, 0);
1504
1505     if (reason == EXCP_DEBUG) {
1506         if (s->env->watchpoint_hit) {
1507             switch (s->env->watchpoint[s->env->watchpoint_hit - 1].type &
1508                     (PAGE_READ | PAGE_WRITE)) {
1509             case PAGE_READ:
1510                 type = "r";
1511                 break;
1512             case PAGE_READ | PAGE_WRITE:
1513                 type = "a";
1514                 break;
1515             default:
1516                 type = "";
1517                 break;
1518             }
1519             snprintf(buf, sizeof(buf), "T%02x%swatch:" TARGET_FMT_lx ";",
1520                      SIGTRAP, type,
1521                      s->env->watchpoint[s->env->watchpoint_hit - 1].vaddr);
1522             put_packet(s, buf);
1523             s->env->watchpoint_hit = 0;
1524             return;
1525         }
1526         tb_flush(s->env);
1527         ret = SIGTRAP;
1528     } else if (reason == EXCP_INTERRUPT) {
1529         ret = SIGINT;
1530     } else {
1531         ret = 0;
1532     }
1533     snprintf(buf, sizeof(buf), "S%02x", ret);
1534     put_packet(s, buf);
1535 }
1536 #endif
1537
1538 /* Send a gdb syscall request.
1539    This accepts limited printf-style format specifiers, specifically:
1540     %x  - target_ulong argument printed in hex.
1541     %lx - 64-bit argument printed in hex.
1542     %s  - string pointer (target_ulong) and length (int) pair.  */
1543 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1544 {
1545     va_list va;
1546     char buf[256];
1547     char *p;
1548     target_ulong addr;
1549     uint64_t i64;
1550     GDBState *s;
1551
1552     s = gdb_syscall_state;
1553     if (!s)
1554         return;
1555     gdb_current_syscall_cb = cb;
1556     s->state = RS_SYSCALL;
1557 #ifndef CONFIG_USER_ONLY
1558     vm_stop(EXCP_DEBUG);
1559 #endif
1560     s->state = RS_IDLE;
1561     va_start(va, fmt);
1562     p = buf;
1563     *(p++) = 'F';
1564     while (*fmt) {
1565         if (*fmt == '%') {
1566             fmt++;
1567             switch (*fmt++) {
1568             case 'x':
1569                 addr = va_arg(va, target_ulong);
1570                 p += snprintf(p, &buf[sizeof(buf)] - p, TARGET_FMT_lx, addr);
1571                 break;
1572             case 'l':
1573                 if (*(fmt++) != 'x')
1574                     goto bad_format;
1575                 i64 = va_arg(va, uint64_t);
1576                 p += snprintf(p, &buf[sizeof(buf)] - p, "%" PRIx64, i64);
1577                 break;
1578             case 's':
1579                 addr = va_arg(va, target_ulong);
1580                 p += snprintf(p, &buf[sizeof(buf)] - p, TARGET_FMT_lx "/%x",
1581                               addr, va_arg(va, int));
1582                 break;
1583             default:
1584             bad_format:
1585                 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1586                         fmt - 1);
1587                 break;
1588             }
1589         } else {
1590             *(p++) = *(fmt++);
1591         }
1592     }
1593     *p = 0;
1594     va_end(va);
1595     put_packet(s, buf);
1596 #ifdef CONFIG_USER_ONLY
1597     gdb_handlesig(s->env, 0);
1598 #else
1599     cpu_interrupt(s->env, CPU_INTERRUPT_EXIT);
1600 #endif
1601 }
1602
1603 static void gdb_read_byte(GDBState *s, int ch)
1604 {
1605     CPUState *env = s->env;
1606     int i, csum;
1607     uint8_t reply;
1608
1609 #ifndef CONFIG_USER_ONLY
1610     if (s->last_packet_len) {
1611         /* Waiting for a response to the last packet.  If we see the start
1612            of a new command then abandon the previous response.  */
1613         if (ch == '-') {
1614 #ifdef DEBUG_GDB
1615             printf("Got NACK, retransmitting\n");
1616 #endif
1617             put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
1618         }
1619 #ifdef DEBUG_GDB
1620         else if (ch == '+')
1621             printf("Got ACK\n");
1622         else
1623             printf("Got '%c' when expecting ACK/NACK\n", ch);
1624 #endif
1625         if (ch == '+' || ch == '$')
1626             s->last_packet_len = 0;
1627         if (ch != '$')
1628             return;
1629     }
1630     if (vm_running) {
1631         /* when the CPU is running, we cannot do anything except stop
1632            it when receiving a char */
1633         vm_stop(EXCP_INTERRUPT);
1634     } else
1635 #endif
1636     {
1637         switch(s->state) {
1638         case RS_IDLE:
1639             if (ch == '$') {
1640                 s->line_buf_index = 0;
1641                 s->state = RS_GETLINE;
1642             }
1643             break;
1644         case RS_GETLINE:
1645             if (ch == '#') {
1646             s->state = RS_CHKSUM1;
1647             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1648                 s->state = RS_IDLE;
1649             } else {
1650             s->line_buf[s->line_buf_index++] = ch;
1651             }
1652             break;
1653         case RS_CHKSUM1:
1654             s->line_buf[s->line_buf_index] = '\0';
1655             s->line_csum = fromhex(ch) << 4;
1656             s->state = RS_CHKSUM2;
1657             break;
1658         case RS_CHKSUM2:
1659             s->line_csum |= fromhex(ch);
1660             csum = 0;
1661             for(i = 0; i < s->line_buf_index; i++) {
1662                 csum += s->line_buf[i];
1663             }
1664             if (s->line_csum != (csum & 0xff)) {
1665                 reply = '-';
1666                 put_buffer(s, &reply, 1);
1667                 s->state = RS_IDLE;
1668             } else {
1669                 reply = '+';
1670                 put_buffer(s, &reply, 1);
1671                 s->state = gdb_handle_packet(s, env, s->line_buf);
1672             }
1673             break;
1674         default:
1675             abort();
1676         }
1677     }
1678 }
1679
1680 #ifdef CONFIG_USER_ONLY
1681 int
1682 gdb_handlesig (CPUState *env, int sig)
1683 {
1684   GDBState *s;
1685   char buf[256];
1686   int n;
1687
1688   s = &gdbserver_state;
1689   if (gdbserver_fd < 0 || s->fd < 0)
1690     return sig;
1691
1692   /* disable single step if it was enabled */
1693   cpu_single_step(env, 0);
1694   tb_flush(env);
1695
1696   if (sig != 0)
1697     {
1698       snprintf(buf, sizeof(buf), "S%02x", sig);
1699       put_packet(s, buf);
1700     }
1701   /* put_packet() might have detected that the peer terminated the
1702      connection.  */
1703   if (s->fd < 0)
1704       return sig;
1705
1706   sig = 0;
1707   s->state = RS_IDLE;
1708   s->running_state = 0;
1709   while (s->running_state == 0) {
1710       n = read (s->fd, buf, 256);
1711       if (n > 0)
1712         {
1713           int i;
1714
1715           for (i = 0; i < n; i++)
1716             gdb_read_byte (s, buf[i]);
1717         }
1718       else if (n == 0 || errno != EAGAIN)
1719         {
1720           /* XXX: Connection closed.  Should probably wait for annother
1721              connection before continuing.  */
1722           return sig;
1723         }
1724   }
1725   sig = s->signal;
1726   s->signal = 0;
1727   return sig;
1728 }
1729
1730 /* Tell the remote gdb that the process has exited.  */
1731 void gdb_exit(CPUState *env, int code)
1732 {
1733   GDBState *s;
1734   char buf[4];
1735
1736   s = &gdbserver_state;
1737   if (gdbserver_fd < 0 || s->fd < 0)
1738     return;
1739
1740   snprintf(buf, sizeof(buf), "W%02x", code);
1741   put_packet(s, buf);
1742 }
1743
1744
1745 static void gdb_accept(void *opaque)
1746 {
1747     GDBState *s;
1748     struct sockaddr_in sockaddr;
1749     socklen_t len;
1750     int val, fd;
1751
1752     for(;;) {
1753         len = sizeof(sockaddr);
1754         fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1755         if (fd < 0 && errno != EINTR) {
1756             perror("accept");
1757             return;
1758         } else if (fd >= 0) {
1759             break;
1760         }
1761     }
1762
1763     /* set short latency */
1764     val = 1;
1765     setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
1766
1767     s = &gdbserver_state;
1768     memset (s, 0, sizeof (GDBState));
1769     s->env = first_cpu; /* XXX: allow to change CPU */
1770     s->fd = fd;
1771     gdb_has_xml = 0;
1772
1773     gdb_syscall_state = s;
1774
1775     fcntl(fd, F_SETFL, O_NONBLOCK);
1776 }
1777
1778 static int gdbserver_open(int port)
1779 {
1780     struct sockaddr_in sockaddr;
1781     int fd, val, ret;
1782
1783     fd = socket(PF_INET, SOCK_STREAM, 0);
1784     if (fd < 0) {
1785         perror("socket");
1786         return -1;
1787     }
1788
1789     /* allow fast reuse */
1790     val = 1;
1791     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
1792
1793     sockaddr.sin_family = AF_INET;
1794     sockaddr.sin_port = htons(port);
1795     sockaddr.sin_addr.s_addr = 0;
1796     ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1797     if (ret < 0) {
1798         perror("bind");
1799         return -1;
1800     }
1801     ret = listen(fd, 0);
1802     if (ret < 0) {
1803         perror("listen");
1804         return -1;
1805     }
1806     return fd;
1807 }
1808
1809 int gdbserver_start(int port)
1810 {
1811     gdbserver_fd = gdbserver_open(port);
1812     if (gdbserver_fd < 0)
1813         return -1;
1814     /* accept connections */
1815     gdb_accept (NULL);
1816     return 0;
1817 }
1818 #else
1819 static int gdb_chr_can_receive(void *opaque)
1820 {
1821   /* We can handle an arbitrarily large amount of data.
1822    Pick the maximum packet size, which is as good as anything.  */
1823   return MAX_PACKET_LENGTH;
1824 }
1825
1826 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
1827 {
1828     GDBState *s = opaque;
1829     int i;
1830
1831     for (i = 0; i < size; i++) {
1832         gdb_read_byte(s, buf[i]);
1833     }
1834 }
1835
1836 static void gdb_chr_event(void *opaque, int event)
1837 {
1838     switch (event) {
1839     case CHR_EVENT_RESET:
1840         vm_stop(EXCP_INTERRUPT);
1841         gdb_syscall_state = opaque;
1842         gdb_has_xml = 0;
1843         break;
1844     default:
1845         break;
1846     }
1847 }
1848
1849 int gdbserver_start(const char *port)
1850 {
1851     GDBState *s;
1852     char gdbstub_port_name[128];
1853     int port_num;
1854     char *p;
1855     CharDriverState *chr;
1856
1857     if (!port || !*port)
1858       return -1;
1859
1860     port_num = strtol(port, &p, 10);
1861     if (*p == 0) {
1862         /* A numeric value is interpreted as a port number.  */
1863         snprintf(gdbstub_port_name, sizeof(gdbstub_port_name),
1864                  "tcp::%d,nowait,nodelay,server", port_num);
1865         port = gdbstub_port_name;
1866     }
1867
1868     chr = qemu_chr_open("gdb", port);
1869     if (!chr)
1870         return -1;
1871
1872     s = qemu_mallocz(sizeof(GDBState));
1873     if (!s) {
1874         return -1;
1875     }
1876     s->env = first_cpu; /* XXX: allow to change CPU */
1877     s->chr = chr;
1878     qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1879                           gdb_chr_event, s);
1880     qemu_add_vm_stop_handler(gdb_vm_stopped, s);
1881     return 0;
1882 }
1883 #endif