]> git.proxmox.com Git - mirror_qemu.git/blame - gdbstub.c
Fix Sparc64 double float gdb protocol (initial version by Paul Brook)
[mirror_qemu.git] / gdbstub.c
CommitLineData
b4608c04
FB
1/*
2 * gdb server stub
3 *
3475187d 4 * Copyright (c) 2003-2005 Fabrice Bellard
b4608c04
FB
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 */
978efd6a 20#include "config.h"
1fddef4b
FB
21#ifdef CONFIG_USER_ONLY
22#include <stdlib.h>
23#include <stdio.h>
24#include <stdarg.h>
25#include <string.h>
26#include <errno.h>
27#include <unistd.h>
978efd6a 28#include <fcntl.h>
1fddef4b
FB
29
30#include "qemu.h"
31#else
67b915a5 32#include "vl.h"
1fddef4b 33#endif
67b915a5 34
8f447cc7
FB
35#include "qemu_socket.h"
36#ifdef _WIN32
37/* XXX: these constants may be independent of the host ones even for Unix */
38#ifndef SIGTRAP
39#define SIGTRAP 5
40#endif
41#ifndef SIGINT
42#define SIGINT 2
43#endif
44#else
b4608c04 45#include <signal.h>
8f447cc7 46#endif
b4608c04 47
4abe615b 48//#define DEBUG_GDB
b4608c04 49
858693c6
FB
50enum RSState {
51 RS_IDLE,
52 RS_GETLINE,
53 RS_CHKSUM1,
54 RS_CHKSUM2,
a2d1ebaf 55 RS_SYSCALL,
858693c6 56};
858693c6 57typedef struct GDBState {
6a00d601 58 CPUState *env; /* current CPU */
41625033 59 enum RSState state; /* parsing state */
858693c6
FB
60 char line_buf[4096];
61 int line_buf_index;
62 int line_csum;
4046d913
PB
63 char last_packet[4100];
64 int last_packet_len;
41625033 65#ifdef CONFIG_USER_ONLY
4046d913 66 int fd;
41625033 67 int running_state;
4046d913
PB
68#else
69 CharDriverState *chr;
41625033 70#endif
858693c6 71} GDBState;
b4608c04 72
1fddef4b 73#ifdef CONFIG_USER_ONLY
4046d913
PB
74/* XXX: This is not thread safe. Do we care? */
75static int gdbserver_fd = -1;
76
1fddef4b
FB
77/* XXX: remove this hack. */
78static GDBState gdbserver_state;
1fddef4b 79
858693c6 80static int get_char(GDBState *s)
b4608c04
FB
81{
82 uint8_t ch;
83 int ret;
84
85 for(;;) {
8f447cc7 86 ret = recv(s->fd, &ch, 1, 0);
b4608c04
FB
87 if (ret < 0) {
88 if (errno != EINTR && errno != EAGAIN)
89 return -1;
90 } else if (ret == 0) {
91 return -1;
92 } else {
93 break;
94 }
95 }
96 return ch;
97}
4046d913 98#endif
b4608c04 99
a2d1ebaf
PB
100/* GDB stub state for use by semihosting syscalls. */
101static GDBState *gdb_syscall_state;
102static gdb_syscall_complete_cb gdb_current_syscall_cb;
103
104enum {
105 GDB_SYS_UNKNOWN,
106 GDB_SYS_ENABLED,
107 GDB_SYS_DISABLED,
108} gdb_syscall_mode;
109
110/* If gdb is connected when the first semihosting syscall occurs then use
111 remote gdb syscalls. Otherwise use native file IO. */
112int use_gdb_syscalls(void)
113{
114 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
115 gdb_syscall_mode = (gdb_syscall_state ? GDB_SYS_ENABLED
116 : GDB_SYS_DISABLED);
117 }
118 return gdb_syscall_mode == GDB_SYS_ENABLED;
119}
120
858693c6 121static void put_buffer(GDBState *s, const uint8_t *buf, int len)
b4608c04 122{
4046d913 123#ifdef CONFIG_USER_ONLY
b4608c04
FB
124 int ret;
125
126 while (len > 0) {
8f447cc7 127 ret = send(s->fd, buf, len, 0);
b4608c04
FB
128 if (ret < 0) {
129 if (errno != EINTR && errno != EAGAIN)
130 return;
131 } else {
132 buf += ret;
133 len -= ret;
134 }
135 }
4046d913
PB
136#else
137 qemu_chr_write(s->chr, buf, len);
138#endif
b4608c04
FB
139}
140
141static inline int fromhex(int v)
142{
143 if (v >= '0' && v <= '9')
144 return v - '0';
145 else if (v >= 'A' && v <= 'F')
146 return v - 'A' + 10;
147 else if (v >= 'a' && v <= 'f')
148 return v - 'a' + 10;
149 else
150 return 0;
151}
152
153static inline int tohex(int v)
154{
155 if (v < 10)
156 return v + '0';
157 else
158 return v - 10 + 'a';
159}
160
161static void memtohex(char *buf, const uint8_t *mem, int len)
162{
163 int i, c;
164 char *q;
165 q = buf;
166 for(i = 0; i < len; i++) {
167 c = mem[i];
168 *q++ = tohex(c >> 4);
169 *q++ = tohex(c & 0xf);
170 }
171 *q = '\0';
172}
173
174static void hextomem(uint8_t *mem, const char *buf, int len)
175{
176 int i;
177
178 for(i = 0; i < len; i++) {
179 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
180 buf += 2;
181 }
182}
183
b4608c04 184/* return -1 if error, 0 if OK */
858693c6 185static int put_packet(GDBState *s, char *buf)
b4608c04 186{
4046d913
PB
187 int len, csum, i;
188 char *p;
b4608c04
FB
189
190#ifdef DEBUG_GDB
191 printf("reply='%s'\n", buf);
192#endif
193
194 for(;;) {
4046d913
PB
195 p = s->last_packet;
196 *(p++) = '$';
b4608c04 197 len = strlen(buf);
4046d913
PB
198 memcpy(p, buf, len);
199 p += len;
b4608c04
FB
200 csum = 0;
201 for(i = 0; i < len; i++) {
202 csum += buf[i];
203 }
4046d913
PB
204 *(p++) = '#';
205 *(p++) = tohex((csum >> 4) & 0xf);
206 *(p++) = tohex((csum) & 0xf);
b4608c04 207
4046d913
PB
208 s->last_packet_len = p - s->last_packet;
209 put_buffer(s, s->last_packet, s->last_packet_len);
b4608c04 210
4046d913
PB
211#ifdef CONFIG_USER_ONLY
212 i = get_char(s);
213 if (i < 0)
b4608c04 214 return -1;
4046d913 215 if (i == '+')
b4608c04 216 break;
4046d913
PB
217#else
218 break;
219#endif
b4608c04
FB
220 }
221 return 0;
222}
223
6da41eaf
FB
224#if defined(TARGET_I386)
225
6da41eaf
FB
226static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
227{
e95c8d51 228 uint32_t *registers = (uint32_t *)mem_buf;
6da41eaf
FB
229 int i, fpus;
230
231 for(i = 0; i < 8; i++) {
e95c8d51 232 registers[i] = env->regs[i];
6da41eaf 233 }
e95c8d51
FB
234 registers[8] = env->eip;
235 registers[9] = env->eflags;
236 registers[10] = env->segs[R_CS].selector;
237 registers[11] = env->segs[R_SS].selector;
238 registers[12] = env->segs[R_DS].selector;
239 registers[13] = env->segs[R_ES].selector;
240 registers[14] = env->segs[R_FS].selector;
241 registers[15] = env->segs[R_GS].selector;
6da41eaf
FB
242 /* XXX: convert floats */
243 for(i = 0; i < 8; i++) {
244 memcpy(mem_buf + 16 * 4 + i * 10, &env->fpregs[i], 10);
245 }
e95c8d51 246 registers[36] = env->fpuc;
6da41eaf 247 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
e95c8d51
FB
248 registers[37] = fpus;
249 registers[38] = 0; /* XXX: convert tags */
250 registers[39] = 0; /* fiseg */
251 registers[40] = 0; /* fioff */
252 registers[41] = 0; /* foseg */
253 registers[42] = 0; /* fooff */
254 registers[43] = 0; /* fop */
255
256 for(i = 0; i < 16; i++)
257 tswapls(&registers[i]);
258 for(i = 36; i < 44; i++)
259 tswapls(&registers[i]);
6da41eaf
FB
260 return 44 * 4;
261}
262
263static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
264{
265 uint32_t *registers = (uint32_t *)mem_buf;
266 int i;
267
268 for(i = 0; i < 8; i++) {
269 env->regs[i] = tswapl(registers[i]);
270 }
e95c8d51
FB
271 env->eip = tswapl(registers[8]);
272 env->eflags = tswapl(registers[9]);
6da41eaf
FB
273#if defined(CONFIG_USER_ONLY)
274#define LOAD_SEG(index, sreg)\
275 if (tswapl(registers[index]) != env->segs[sreg].selector)\
276 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
277 LOAD_SEG(10, R_CS);
278 LOAD_SEG(11, R_SS);
279 LOAD_SEG(12, R_DS);
280 LOAD_SEG(13, R_ES);
281 LOAD_SEG(14, R_FS);
282 LOAD_SEG(15, R_GS);
283#endif
284}
285
9e62fd7f 286#elif defined (TARGET_PPC)
9e62fd7f
FB
287static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
288{
a541f297 289 uint32_t *registers = (uint32_t *)mem_buf, tmp;
9e62fd7f
FB
290 int i;
291
292 /* fill in gprs */
a541f297 293 for(i = 0; i < 32; i++) {
e95c8d51 294 registers[i] = tswapl(env->gpr[i]);
9e62fd7f
FB
295 }
296 /* fill in fprs */
297 for (i = 0; i < 32; i++) {
e95c8d51
FB
298 registers[(i * 2) + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
299 registers[(i * 2) + 33] = tswapl(*((uint32_t *)&env->fpr[i] + 1));
9e62fd7f
FB
300 }
301 /* nip, msr, ccr, lnk, ctr, xer, mq */
e95c8d51 302 registers[96] = tswapl(env->nip);
3fc6c082 303 registers[97] = tswapl(do_load_msr(env));
9e62fd7f
FB
304 tmp = 0;
305 for (i = 0; i < 8; i++)
a541f297 306 tmp |= env->crf[i] << (32 - ((i + 1) * 4));
e95c8d51
FB
307 registers[98] = tswapl(tmp);
308 registers[99] = tswapl(env->lr);
309 registers[100] = tswapl(env->ctr);
76a66253 310 registers[101] = tswapl(ppc_load_xer(env));
e95c8d51 311 registers[102] = 0;
a541f297
FB
312
313 return 103 * 4;
9e62fd7f
FB
314}
315
316static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
317{
318 uint32_t *registers = (uint32_t *)mem_buf;
319 int i;
320
321 /* fill in gprs */
322 for (i = 0; i < 32; i++) {
e95c8d51 323 env->gpr[i] = tswapl(registers[i]);
9e62fd7f
FB
324 }
325 /* fill in fprs */
326 for (i = 0; i < 32; i++) {
e95c8d51
FB
327 *((uint32_t *)&env->fpr[i]) = tswapl(registers[(i * 2) + 32]);
328 *((uint32_t *)&env->fpr[i] + 1) = tswapl(registers[(i * 2) + 33]);
9e62fd7f
FB
329 }
330 /* nip, msr, ccr, lnk, ctr, xer, mq */
e95c8d51 331 env->nip = tswapl(registers[96]);
3fc6c082 332 do_store_msr(env, tswapl(registers[97]));
e95c8d51 333 registers[98] = tswapl(registers[98]);
9e62fd7f 334 for (i = 0; i < 8; i++)
a541f297 335 env->crf[i] = (registers[98] >> (32 - ((i + 1) * 4))) & 0xF;
e95c8d51
FB
336 env->lr = tswapl(registers[99]);
337 env->ctr = tswapl(registers[100]);
76a66253 338 ppc_store_xer(env, tswapl(registers[101]));
e95c8d51
FB
339}
340#elif defined (TARGET_SPARC)
341static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
342{
3475187d 343 target_ulong *registers = (target_ulong *)mem_buf;
e95c8d51
FB
344 int i;
345
346 /* fill in g0..g7 */
48b2c193 347 for(i = 0; i < 8; i++) {
e95c8d51
FB
348 registers[i] = tswapl(env->gregs[i]);
349 }
350 /* fill in register window */
351 for(i = 0; i < 24; i++) {
352 registers[i + 8] = tswapl(env->regwptr[i]);
353 }
9d9754a3 354#ifndef TARGET_SPARC64
e95c8d51
FB
355 /* fill in fprs */
356 for (i = 0; i < 32; i++) {
357 registers[i + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
358 }
359 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
360 registers[64] = tswapl(env->y);
3475187d
FB
361 {
362 target_ulong tmp;
363
364 tmp = GET_PSR(env);
365 registers[65] = tswapl(tmp);
366 }
e95c8d51
FB
367 registers[66] = tswapl(env->wim);
368 registers[67] = tswapl(env->tbr);
369 registers[68] = tswapl(env->pc);
370 registers[69] = tswapl(env->npc);
371 registers[70] = tswapl(env->fsr);
372 registers[71] = 0; /* csr */
373 registers[72] = 0;
3475187d
FB
374 return 73 * sizeof(target_ulong);
375#else
9d9754a3
FB
376 /* fill in fprs */
377 for (i = 0; i < 64; i += 2) {
378 uint64_t tmp;
379
8979596d
BS
380 tmp = ((uint64_t)*(uint32_t *)&env->fpr[i]) << 32;
381 tmp |= *(uint32_t *)&env->fpr[i + 1];
382 registers[i / 2 + 32] = tswap64(tmp);
3475187d 383 }
9d9754a3
FB
384 registers[64] = tswapl(env->pc);
385 registers[65] = tswapl(env->npc);
386 registers[66] = tswapl(env->tstate[env->tl]);
387 registers[67] = tswapl(env->fsr);
388 registers[68] = tswapl(env->fprs);
389 registers[69] = tswapl(env->y);
390 return 70 * sizeof(target_ulong);
3475187d 391#endif
e95c8d51
FB
392}
393
394static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
395{
3475187d 396 target_ulong *registers = (target_ulong *)mem_buf;
e95c8d51
FB
397 int i;
398
399 /* fill in g0..g7 */
400 for(i = 0; i < 7; i++) {
401 env->gregs[i] = tswapl(registers[i]);
402 }
403 /* fill in register window */
404 for(i = 0; i < 24; i++) {
3475187d 405 env->regwptr[i] = tswapl(registers[i + 8]);
e95c8d51 406 }
9d9754a3 407#ifndef TARGET_SPARC64
e95c8d51
FB
408 /* fill in fprs */
409 for (i = 0; i < 32; i++) {
410 *((uint32_t *)&env->fpr[i]) = tswapl(registers[i + 32]);
411 }
412 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
413 env->y = tswapl(registers[64]);
e80cfcfc 414 PUT_PSR(env, tswapl(registers[65]));
e95c8d51
FB
415 env->wim = tswapl(registers[66]);
416 env->tbr = tswapl(registers[67]);
417 env->pc = tswapl(registers[68]);
418 env->npc = tswapl(registers[69]);
419 env->fsr = tswapl(registers[70]);
3475187d 420#else
9d9754a3 421 for (i = 0; i < 64; i += 2) {
8979596d
BS
422 uint64_t tmp;
423
424 tmp = tswap64(registers[i / 2 + 32]);
425 *((uint32_t *)&env->fpr[i]) = tmp >> 32;
426 *((uint32_t *)&env->fpr[i + 1]) = tmp & 0xffffffff;
3475187d 427 }
9d9754a3
FB
428 env->pc = tswapl(registers[64]);
429 env->npc = tswapl(registers[65]);
430 env->tstate[env->tl] = tswapl(registers[66]);
431 env->fsr = tswapl(registers[67]);
432 env->fprs = tswapl(registers[68]);
433 env->y = tswapl(registers[69]);
3475187d 434#endif
9e62fd7f 435}
1fddef4b
FB
436#elif defined (TARGET_ARM)
437static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
438{
439 int i;
440 uint8_t *ptr;
441
442 ptr = mem_buf;
443 /* 16 core integer registers (4 bytes each). */
444 for (i = 0; i < 16; i++)
445 {
446 *(uint32_t *)ptr = tswapl(env->regs[i]);
447 ptr += 4;
448 }
449 /* 8 FPA registers (12 bytes each), FPS (4 bytes).
450 Not yet implemented. */
451 memset (ptr, 0, 8 * 12 + 4);
452 ptr += 8 * 12 + 4;
453 /* CPSR (4 bytes). */
b5ff1b31 454 *(uint32_t *)ptr = tswapl (cpsr_read(env));
1fddef4b
FB
455 ptr += 4;
456
457 return ptr - mem_buf;
458}
6da41eaf 459
1fddef4b
FB
460static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
461{
462 int i;
463 uint8_t *ptr;
464
465 ptr = mem_buf;
466 /* Core integer registers. */
467 for (i = 0; i < 16; i++)
468 {
469 env->regs[i] = tswapl(*(uint32_t *)ptr);
470 ptr += 4;
471 }
472 /* Ignore FPA regs and scr. */
473 ptr += 8 * 12 + 4;
b5ff1b31 474 cpsr_write (env, tswapl(*(uint32_t *)ptr), 0xffffffff);
1fddef4b 475}
e6e5906b
PB
476#elif defined (TARGET_M68K)
477static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
478{
479 int i;
480 uint8_t *ptr;
481 CPU_DoubleU u;
482
483 ptr = mem_buf;
484 /* D0-D7 */
485 for (i = 0; i < 8; i++) {
486 *(uint32_t *)ptr = tswapl(env->dregs[i]);
487 ptr += 4;
488 }
489 /* A0-A7 */
490 for (i = 0; i < 8; i++) {
491 *(uint32_t *)ptr = tswapl(env->aregs[i]);
492 ptr += 4;
493 }
494 *(uint32_t *)ptr = tswapl(env->sr);
495 ptr += 4;
496 *(uint32_t *)ptr = tswapl(env->pc);
497 ptr += 4;
498 /* F0-F7. The 68881/68040 have 12-bit extended precision registers.
499 ColdFire has 8-bit double precision registers. */
500 for (i = 0; i < 8; i++) {
501 u.d = env->fregs[i];
502 *(uint32_t *)ptr = tswap32(u.l.upper);
503 *(uint32_t *)ptr = tswap32(u.l.lower);
504 }
505 /* FP control regs (not implemented). */
506 memset (ptr, 0, 3 * 4);
507 ptr += 3 * 4;
508
509 return ptr - mem_buf;
510}
511
512static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
513{
514 int i;
515 uint8_t *ptr;
516 CPU_DoubleU u;
517
518 ptr = mem_buf;
519 /* D0-D7 */
520 for (i = 0; i < 8; i++) {
521 env->dregs[i] = tswapl(*(uint32_t *)ptr);
522 ptr += 4;
523 }
524 /* A0-A7 */
525 for (i = 0; i < 8; i++) {
526 env->aregs[i] = tswapl(*(uint32_t *)ptr);
527 ptr += 4;
528 }
529 env->sr = tswapl(*(uint32_t *)ptr);
530 ptr += 4;
531 env->pc = tswapl(*(uint32_t *)ptr);
532 ptr += 4;
533 /* F0-F7. The 68881/68040 have 12-bit extended precision registers.
534 ColdFire has 8-bit double precision registers. */
535 for (i = 0; i < 8; i++) {
536 u.l.upper = tswap32(*(uint32_t *)ptr);
537 u.l.lower = tswap32(*(uint32_t *)ptr);
538 env->fregs[i] = u.d;
539 }
540 /* FP control regs (not implemented). */
541 ptr += 3 * 4;
542}
6f970bd9
FB
543#elif defined (TARGET_MIPS)
544static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
545{
546 int i;
547 uint8_t *ptr;
548
549 ptr = mem_buf;
550 for (i = 0; i < 32; i++)
551 {
552 *(uint32_t *)ptr = tswapl(env->gpr[i]);
553 ptr += 4;
554 }
555
556 *(uint32_t *)ptr = tswapl(env->CP0_Status);
557 ptr += 4;
558
559 *(uint32_t *)ptr = tswapl(env->LO);
560 ptr += 4;
561
562 *(uint32_t *)ptr = tswapl(env->HI);
563 ptr += 4;
564
565 *(uint32_t *)ptr = tswapl(env->CP0_BadVAddr);
566 ptr += 4;
567
568 *(uint32_t *)ptr = tswapl(env->CP0_Cause);
569 ptr += 4;
570
571 *(uint32_t *)ptr = tswapl(env->PC);
572 ptr += 4;
573
36d23958 574 if (env->CP0_Config1 & (1 << CP0C1_FP))
8e33c08c 575 {
36d23958
TS
576 for (i = 0; i < 32; i++)
577 {
578 *(uint32_t *)ptr = tswapl(FPR_W (env, i));
579 ptr += 4;
580 }
8e33c08c 581
36d23958
TS
582 *(uint32_t *)ptr = tswapl(env->fcr31);
583 ptr += 4;
8e33c08c 584
36d23958
TS
585 *(uint32_t *)ptr = tswapl(env->fcr0);
586 ptr += 4;
587 }
8e33c08c 588
6f970bd9 589 /* 32 FP registers, fsr, fir, fp. Not yet implemented. */
8e33c08c 590 /* what's 'fp' mean here? */
6f970bd9
FB
591
592 return ptr - mem_buf;
593}
594
8e33c08c
TS
595/* convert MIPS rounding mode in FCR31 to IEEE library */
596static unsigned int ieee_rm[] =
597 {
598 float_round_nearest_even,
599 float_round_to_zero,
600 float_round_up,
601 float_round_down
602 };
603#define RESTORE_ROUNDING_MODE \
604 set_float_rounding_mode(ieee_rm[env->fcr31 & 3], &env->fp_status)
605
6f970bd9
FB
606static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
607{
608 int i;
609 uint8_t *ptr;
610
611 ptr = mem_buf;
612 for (i = 0; i < 32; i++)
613 {
614 env->gpr[i] = tswapl(*(uint32_t *)ptr);
615 ptr += 4;
616 }
617
618 env->CP0_Status = tswapl(*(uint32_t *)ptr);
619 ptr += 4;
620
621 env->LO = tswapl(*(uint32_t *)ptr);
622 ptr += 4;
623
624 env->HI = tswapl(*(uint32_t *)ptr);
625 ptr += 4;
626
627 env->CP0_BadVAddr = tswapl(*(uint32_t *)ptr);
628 ptr += 4;
629
630 env->CP0_Cause = tswapl(*(uint32_t *)ptr);
631 ptr += 4;
632
633 env->PC = tswapl(*(uint32_t *)ptr);
634 ptr += 4;
8e33c08c 635
36d23958 636 if (env->CP0_Config1 & (1 << CP0C1_FP))
8e33c08c 637 {
36d23958
TS
638 for (i = 0; i < 32; i++)
639 {
640 FPR_W (env, i) = tswapl(*(uint32_t *)ptr);
641 ptr += 4;
642 }
8e33c08c 643
36d23958
TS
644 env->fcr31 = tswapl(*(uint32_t *)ptr) & 0x0183FFFF;
645 ptr += 4;
8e33c08c 646
36d23958
TS
647 env->fcr0 = tswapl(*(uint32_t *)ptr);
648 ptr += 4;
8e33c08c 649
36d23958
TS
650 /* set rounding mode */
651 RESTORE_ROUNDING_MODE;
8e33c08c
TS
652
653#ifndef CONFIG_SOFTFLOAT
36d23958
TS
654 /* no floating point exception for native float */
655 SET_FP_ENABLE(env->fcr31, 0);
8e33c08c 656#endif
36d23958 657 }
6f970bd9 658}
fdf9b3e8
FB
659#elif defined (TARGET_SH4)
660static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
661{
662 uint32_t *ptr = (uint32_t *)mem_buf;
663 int i;
664
665#define SAVE(x) *ptr++=tswapl(x)
9c2a9ea1
PB
666 if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
667 for (i = 0; i < 8; i++) SAVE(env->gregs[i + 16]);
668 } else {
669 for (i = 0; i < 8; i++) SAVE(env->gregs[i]);
670 }
671 for (i = 8; i < 16; i++) SAVE(env->gregs[i]);
fdf9b3e8
FB
672 SAVE (env->pc);
673 SAVE (env->pr);
674 SAVE (env->gbr);
675 SAVE (env->vbr);
676 SAVE (env->mach);
677 SAVE (env->macl);
678 SAVE (env->sr);
679 SAVE (0); /* TICKS */
680 SAVE (0); /* STALLS */
681 SAVE (0); /* CYCLES */
682 SAVE (0); /* INSTS */
683 SAVE (0); /* PLR */
684
685 return ((uint8_t *)ptr - mem_buf);
686}
687
688static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
689{
690 uint32_t *ptr = (uint32_t *)mem_buf;
691 int i;
692
693#define LOAD(x) (x)=*ptr++;
9c2a9ea1
PB
694 if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
695 for (i = 0; i < 8; i++) LOAD(env->gregs[i + 16]);
696 } else {
697 for (i = 0; i < 8; i++) LOAD(env->gregs[i]);
698 }
699 for (i = 8; i < 16; i++) LOAD(env->gregs[i]);
fdf9b3e8
FB
700 LOAD (env->pc);
701 LOAD (env->pr);
702 LOAD (env->gbr);
703 LOAD (env->vbr);
704 LOAD (env->mach);
705 LOAD (env->macl);
706 LOAD (env->sr);
707}
1fddef4b 708#else
6da41eaf
FB
709static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
710{
711 return 0;
712}
713
714static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
715{
716}
717
718#endif
b4608c04 719
1fddef4b 720static int gdb_handle_packet(GDBState *s, CPUState *env, const char *line_buf)
b4608c04 721{
b4608c04 722 const char *p;
858693c6 723 int ch, reg_size, type;
b4608c04
FB
724 char buf[4096];
725 uint8_t mem_buf[2000];
726 uint32_t *registers;
9d9754a3 727 target_ulong addr, len;
b4608c04 728
858693c6
FB
729#ifdef DEBUG_GDB
730 printf("command='%s'\n", line_buf);
731#endif
732 p = line_buf;
733 ch = *p++;
734 switch(ch) {
735 case '?':
1fddef4b 736 /* TODO: Make this return the correct value for user-mode. */
858693c6
FB
737 snprintf(buf, sizeof(buf), "S%02x", SIGTRAP);
738 put_packet(s, buf);
739 break;
740 case 'c':
741 if (*p != '\0') {
9d9754a3 742 addr = strtoull(p, (char **)&p, 16);
4c3a88a2 743#if defined(TARGET_I386)
858693c6 744 env->eip = addr;
5be1a8e0 745#elif defined (TARGET_PPC)
858693c6 746 env->nip = addr;
8d5f07fa
FB
747#elif defined (TARGET_SPARC)
748 env->pc = addr;
749 env->npc = addr + 4;
b5ff1b31
FB
750#elif defined (TARGET_ARM)
751 env->regs[15] = addr;
fdf9b3e8
FB
752#elif defined (TARGET_SH4)
753 env->pc = addr;
4c3a88a2 754#endif
858693c6 755 }
41625033
FB
756#ifdef CONFIG_USER_ONLY
757 s->running_state = 1;
758#else
759 vm_start();
760#endif
761 return RS_IDLE;
858693c6
FB
762 case 's':
763 if (*p != '\0') {
764 addr = strtoul(p, (char **)&p, 16);
c33a346e 765#if defined(TARGET_I386)
858693c6 766 env->eip = addr;
5be1a8e0 767#elif defined (TARGET_PPC)
858693c6 768 env->nip = addr;
8d5f07fa
FB
769#elif defined (TARGET_SPARC)
770 env->pc = addr;
771 env->npc = addr + 4;
b5ff1b31
FB
772#elif defined (TARGET_ARM)
773 env->regs[15] = addr;
fdf9b3e8
FB
774#elif defined (TARGET_SH4)
775 env->pc = addr;
c33a346e 776#endif
858693c6
FB
777 }
778 cpu_single_step(env, 1);
41625033
FB
779#ifdef CONFIG_USER_ONLY
780 s->running_state = 1;
781#else
782 vm_start();
783#endif
784 return RS_IDLE;
a2d1ebaf
PB
785 case 'F':
786 {
787 target_ulong ret;
788 target_ulong err;
789
790 ret = strtoull(p, (char **)&p, 16);
791 if (*p == ',') {
792 p++;
793 err = strtoull(p, (char **)&p, 16);
794 } else {
795 err = 0;
796 }
797 if (*p == ',')
798 p++;
799 type = *p;
800 if (gdb_current_syscall_cb)
801 gdb_current_syscall_cb(s->env, ret, err);
802 if (type == 'C') {
803 put_packet(s, "T02");
804 } else {
805#ifdef CONFIG_USER_ONLY
806 s->running_state = 1;
807#else
808 vm_start();
809#endif
810 }
811 }
812 break;
858693c6
FB
813 case 'g':
814 reg_size = cpu_gdb_read_registers(env, mem_buf);
815 memtohex(buf, mem_buf, reg_size);
816 put_packet(s, buf);
817 break;
818 case 'G':
819 registers = (void *)mem_buf;
820 len = strlen(p) / 2;
821 hextomem((uint8_t *)registers, p, len);
822 cpu_gdb_write_registers(env, mem_buf, len);
823 put_packet(s, "OK");
824 break;
825 case 'm':
9d9754a3 826 addr = strtoull(p, (char **)&p, 16);
858693c6
FB
827 if (*p == ',')
828 p++;
9d9754a3 829 len = strtoull(p, NULL, 16);
6f970bd9
FB
830 if (cpu_memory_rw_debug(env, addr, mem_buf, len, 0) != 0) {
831 put_packet (s, "E14");
832 } else {
833 memtohex(buf, mem_buf, len);
834 put_packet(s, buf);
835 }
858693c6
FB
836 break;
837 case 'M':
9d9754a3 838 addr = strtoull(p, (char **)&p, 16);
858693c6
FB
839 if (*p == ',')
840 p++;
9d9754a3 841 len = strtoull(p, (char **)&p, 16);
b328f873 842 if (*p == ':')
858693c6
FB
843 p++;
844 hextomem(mem_buf, p, len);
845 if (cpu_memory_rw_debug(env, addr, mem_buf, len, 1) != 0)
905f20b1 846 put_packet(s, "E14");
858693c6
FB
847 else
848 put_packet(s, "OK");
849 break;
850 case 'Z':
851 type = strtoul(p, (char **)&p, 16);
852 if (*p == ',')
853 p++;
9d9754a3 854 addr = strtoull(p, (char **)&p, 16);
858693c6
FB
855 if (*p == ',')
856 p++;
9d9754a3 857 len = strtoull(p, (char **)&p, 16);
858693c6
FB
858 if (type == 0 || type == 1) {
859 if (cpu_breakpoint_insert(env, addr) < 0)
860 goto breakpoint_error;
861 put_packet(s, "OK");
6658ffb8
PB
862#ifndef CONFIG_USER_ONLY
863 } else if (type == 2) {
864 if (cpu_watchpoint_insert(env, addr) < 0)
865 goto breakpoint_error;
866 put_packet(s, "OK");
867#endif
858693c6
FB
868 } else {
869 breakpoint_error:
905f20b1 870 put_packet(s, "E22");
858693c6
FB
871 }
872 break;
873 case 'z':
874 type = strtoul(p, (char **)&p, 16);
875 if (*p == ',')
876 p++;
9d9754a3 877 addr = strtoull(p, (char **)&p, 16);
858693c6
FB
878 if (*p == ',')
879 p++;
9d9754a3 880 len = strtoull(p, (char **)&p, 16);
858693c6
FB
881 if (type == 0 || type == 1) {
882 cpu_breakpoint_remove(env, addr);
883 put_packet(s, "OK");
6658ffb8
PB
884#ifndef CONFIG_USER_ONLY
885 } else if (type == 2) {
886 cpu_watchpoint_remove(env, addr);
887 put_packet(s, "OK");
888#endif
858693c6
FB
889 } else {
890 goto breakpoint_error;
891 }
892 break;
831b7825 893#ifdef CONFIG_LINUX_USER
978efd6a
PB
894 case 'q':
895 if (strncmp(p, "Offsets", 7) == 0) {
896 TaskState *ts = env->opaque;
897
898 sprintf(buf, "Text=%x;Data=%x;Bss=%x", ts->info->code_offset,
899 ts->info->data_offset, ts->info->data_offset);
900 put_packet(s, buf);
901 break;
902 }
903 /* Fall through. */
904#endif
858693c6
FB
905 default:
906 // unknown_command:
907 /* put empty packet */
908 buf[0] = '\0';
909 put_packet(s, buf);
910 break;
911 }
912 return RS_IDLE;
913}
914
612458f5
FB
915extern void tb_flush(CPUState *env);
916
1fddef4b 917#ifndef CONFIG_USER_ONLY
858693c6
FB
918static void gdb_vm_stopped(void *opaque, int reason)
919{
920 GDBState *s = opaque;
921 char buf[256];
922 int ret;
923
a2d1ebaf
PB
924 if (s->state == RS_SYSCALL)
925 return;
926
858693c6 927 /* disable single step if it was enable */
6a00d601 928 cpu_single_step(s->env, 0);
858693c6 929
e80cfcfc 930 if (reason == EXCP_DEBUG) {
6658ffb8
PB
931 if (s->env->watchpoint_hit) {
932 snprintf(buf, sizeof(buf), "T%02xwatch:%x;", SIGTRAP,
933 s->env->watchpoint[s->env->watchpoint_hit - 1].vaddr);
934 put_packet(s, buf);
935 s->env->watchpoint_hit = 0;
936 return;
937 }
6a00d601 938 tb_flush(s->env);
858693c6 939 ret = SIGTRAP;
bbeb7b5c
FB
940 } else if (reason == EXCP_INTERRUPT) {
941 ret = SIGINT;
942 } else {
858693c6 943 ret = 0;
bbeb7b5c 944 }
858693c6
FB
945 snprintf(buf, sizeof(buf), "S%02x", ret);
946 put_packet(s, buf);
947}
1fddef4b 948#endif
858693c6 949
a2d1ebaf
PB
950/* Send a gdb syscall request.
951 This accepts limited printf-style format specifiers, specifically:
952 %x - target_ulong argument printed in hex.
953 %s - string pointer (target_ulong) and length (int) pair. */
954void gdb_do_syscall(gdb_syscall_complete_cb cb, char *fmt, ...)
955{
956 va_list va;
957 char buf[256];
958 char *p;
959 target_ulong addr;
960 GDBState *s;
961
962 s = gdb_syscall_state;
963 if (!s)
964 return;
965 gdb_current_syscall_cb = cb;
966 s->state = RS_SYSCALL;
967#ifndef CONFIG_USER_ONLY
968 vm_stop(EXCP_DEBUG);
969#endif
970 s->state = RS_IDLE;
971 va_start(va, fmt);
972 p = buf;
973 *(p++) = 'F';
974 while (*fmt) {
975 if (*fmt == '%') {
976 fmt++;
977 switch (*fmt++) {
978 case 'x':
979 addr = va_arg(va, target_ulong);
980 p += sprintf(p, TARGET_FMT_lx, addr);
981 break;
982 case 's':
983 addr = va_arg(va, target_ulong);
984 p += sprintf(p, TARGET_FMT_lx "/%x", addr, va_arg(va, int));
985 break;
986 default:
987 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
988 fmt - 1);
989 break;
990 }
991 } else {
992 *(p++) = *(fmt++);
993 }
994 }
995 va_end(va);
996 put_packet(s, buf);
997#ifdef CONFIG_USER_ONLY
998 gdb_handlesig(s->env, 0);
999#else
1000 cpu_interrupt(s->env, CPU_INTERRUPT_EXIT);
1001#endif
1002}
1003
6a00d601 1004static void gdb_read_byte(GDBState *s, int ch)
858693c6 1005{
6a00d601 1006 CPUState *env = s->env;
858693c6
FB
1007 int i, csum;
1008 char reply[1];
1009
1fddef4b 1010#ifndef CONFIG_USER_ONLY
4046d913
PB
1011 if (s->last_packet_len) {
1012 /* Waiting for a response to the last packet. If we see the start
1013 of a new command then abandon the previous response. */
1014 if (ch == '-') {
1015#ifdef DEBUG_GDB
1016 printf("Got NACK, retransmitting\n");
1017#endif
1018 put_buffer(s, s->last_packet, s->last_packet_len);
1019 }
1020#ifdef DEBUG_GDB
1021 else if (ch == '+')
1022 printf("Got ACK\n");
1023 else
1024 printf("Got '%c' when expecting ACK/NACK\n", ch);
1025#endif
1026 if (ch == '+' || ch == '$')
1027 s->last_packet_len = 0;
1028 if (ch != '$')
1029 return;
1030 }
858693c6
FB
1031 if (vm_running) {
1032 /* when the CPU is running, we cannot do anything except stop
1033 it when receiving a char */
1034 vm_stop(EXCP_INTERRUPT);
41625033 1035 } else
1fddef4b 1036#endif
41625033 1037 {
858693c6
FB
1038 switch(s->state) {
1039 case RS_IDLE:
1040 if (ch == '$') {
1041 s->line_buf_index = 0;
1042 s->state = RS_GETLINE;
c33a346e 1043 }
b4608c04 1044 break;
858693c6
FB
1045 case RS_GETLINE:
1046 if (ch == '#') {
1047 s->state = RS_CHKSUM1;
1048 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1049 s->state = RS_IDLE;
4c3a88a2 1050 } else {
858693c6 1051 s->line_buf[s->line_buf_index++] = ch;
4c3a88a2
FB
1052 }
1053 break;
858693c6
FB
1054 case RS_CHKSUM1:
1055 s->line_buf[s->line_buf_index] = '\0';
1056 s->line_csum = fromhex(ch) << 4;
1057 s->state = RS_CHKSUM2;
1058 break;
1059 case RS_CHKSUM2:
1060 s->line_csum |= fromhex(ch);
1061 csum = 0;
1062 for(i = 0; i < s->line_buf_index; i++) {
1063 csum += s->line_buf[i];
1064 }
1065 if (s->line_csum != (csum & 0xff)) {
1066 reply[0] = '-';
1067 put_buffer(s, reply, 1);
1068 s->state = RS_IDLE;
4c3a88a2 1069 } else {
858693c6
FB
1070 reply[0] = '+';
1071 put_buffer(s, reply, 1);
1fddef4b 1072 s->state = gdb_handle_packet(s, env, s->line_buf);
4c3a88a2
FB
1073 }
1074 break;
a2d1ebaf
PB
1075 default:
1076 abort();
858693c6
FB
1077 }
1078 }
1079}
1080
1fddef4b
FB
1081#ifdef CONFIG_USER_ONLY
1082int
1083gdb_handlesig (CPUState *env, int sig)
1084{
1085 GDBState *s;
1086 char buf[256];
1087 int n;
1088
1089 if (gdbserver_fd < 0)
1090 return sig;
1091
1092 s = &gdbserver_state;
1093
1094 /* disable single step if it was enabled */
1095 cpu_single_step(env, 0);
1096 tb_flush(env);
1097
1098 if (sig != 0)
1099 {
1100 snprintf(buf, sizeof(buf), "S%02x", sig);
1101 put_packet(s, buf);
1102 }
1103
1fddef4b
FB
1104 sig = 0;
1105 s->state = RS_IDLE;
41625033
FB
1106 s->running_state = 0;
1107 while (s->running_state == 0) {
1fddef4b
FB
1108 n = read (s->fd, buf, 256);
1109 if (n > 0)
1110 {
1111 int i;
1112
1113 for (i = 0; i < n; i++)
6a00d601 1114 gdb_read_byte (s, buf[i]);
1fddef4b
FB
1115 }
1116 else if (n == 0 || errno != EAGAIN)
1117 {
1118 /* XXX: Connection closed. Should probably wait for annother
1119 connection before continuing. */
1120 return sig;
1121 }
41625033 1122 }
1fddef4b
FB
1123 return sig;
1124}
e9009676
FB
1125
1126/* Tell the remote gdb that the process has exited. */
1127void gdb_exit(CPUState *env, int code)
1128{
1129 GDBState *s;
1130 char buf[4];
1131
1132 if (gdbserver_fd < 0)
1133 return;
1134
1135 s = &gdbserver_state;
1136
1137 snprintf(buf, sizeof(buf), "W%02x", code);
1138 put_packet(s, buf);
1139}
1140
1fddef4b 1141
7c9d8e07 1142static void gdb_accept(void *opaque)
858693c6
FB
1143{
1144 GDBState *s;
1145 struct sockaddr_in sockaddr;
1146 socklen_t len;
1147 int val, fd;
1148
1149 for(;;) {
1150 len = sizeof(sockaddr);
1151 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1152 if (fd < 0 && errno != EINTR) {
1153 perror("accept");
1154 return;
1155 } else if (fd >= 0) {
b4608c04
FB
1156 break;
1157 }
1158 }
858693c6
FB
1159
1160 /* set short latency */
1161 val = 1;
8f447cc7 1162 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
858693c6 1163
1fddef4b
FB
1164 s = &gdbserver_state;
1165 memset (s, 0, sizeof (GDBState));
6a00d601 1166 s->env = first_cpu; /* XXX: allow to change CPU */
858693c6
FB
1167 s->fd = fd;
1168
a2d1ebaf
PB
1169 gdb_syscall_state = s;
1170
858693c6 1171 fcntl(fd, F_SETFL, O_NONBLOCK);
858693c6
FB
1172}
1173
1174static int gdbserver_open(int port)
1175{
1176 struct sockaddr_in sockaddr;
1177 int fd, val, ret;
1178
1179 fd = socket(PF_INET, SOCK_STREAM, 0);
1180 if (fd < 0) {
1181 perror("socket");
1182 return -1;
1183 }
1184
1185 /* allow fast reuse */
1186 val = 1;
8f447cc7 1187 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
858693c6
FB
1188
1189 sockaddr.sin_family = AF_INET;
1190 sockaddr.sin_port = htons(port);
1191 sockaddr.sin_addr.s_addr = 0;
1192 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1193 if (ret < 0) {
1194 perror("bind");
1195 return -1;
1196 }
1197 ret = listen(fd, 0);
1198 if (ret < 0) {
1199 perror("listen");
1200 return -1;
1201 }
858693c6
FB
1202 return fd;
1203}
1204
1205int gdbserver_start(int port)
1206{
1207 gdbserver_fd = gdbserver_open(port);
1208 if (gdbserver_fd < 0)
1209 return -1;
1210 /* accept connections */
7c9d8e07 1211 gdb_accept (NULL);
4046d913
PB
1212 return 0;
1213}
1fddef4b 1214#else
4046d913
PB
1215static int gdb_chr_can_recieve(void *opaque)
1216{
1217 return 1;
1218}
1219
1220static void gdb_chr_recieve(void *opaque, const uint8_t *buf, int size)
1221{
1222 GDBState *s = opaque;
1223 int i;
1224
1225 for (i = 0; i < size; i++) {
1226 gdb_read_byte(s, buf[i]);
1227 }
1228}
1229
1230static void gdb_chr_event(void *opaque, int event)
1231{
1232 switch (event) {
1233 case CHR_EVENT_RESET:
1234 vm_stop(EXCP_INTERRUPT);
a2d1ebaf 1235 gdb_syscall_state = opaque;
4046d913
PB
1236 break;
1237 default:
1238 break;
1239 }
1240}
1241
cfc3475a 1242int gdbserver_start(const char *port)
4046d913
PB
1243{
1244 GDBState *s;
cfc3475a
PB
1245 char gdbstub_port_name[128];
1246 int port_num;
1247 char *p;
1248 CharDriverState *chr;
1249
1250 if (!port || !*port)
1251 return -1;
4046d913 1252
cfc3475a
PB
1253 port_num = strtol(port, &p, 10);
1254 if (*p == 0) {
1255 /* A numeric value is interpreted as a port number. */
1256 snprintf(gdbstub_port_name, sizeof(gdbstub_port_name),
1257 "tcp::%d,nowait,nodelay,server", port_num);
1258 port = gdbstub_port_name;
1259 }
1260
1261 chr = qemu_chr_open(port);
4046d913
PB
1262 if (!chr)
1263 return -1;
1264
1265 s = qemu_mallocz(sizeof(GDBState));
1266 if (!s) {
1267 return -1;
1268 }
1269 s->env = first_cpu; /* XXX: allow to change CPU */
1270 s->chr = chr;
1271 qemu_chr_add_handlers(chr, gdb_chr_can_recieve, gdb_chr_recieve,
1272 gdb_chr_event, s);
1273 qemu_add_vm_stop_handler(gdb_vm_stopped, s);
b4608c04
FB
1274 return 0;
1275}
4046d913 1276#endif