qdev: remove baked in notion of aliases (v2)
[qemu.git] / 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, see <http://www.gnu.org/licenses/>.
18 */
19 #include "config.h"
20 #include "qemu-common.h"
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>
28 #include <fcntl.h>
29
30 #include "qemu.h"
31 #else
32 #include "monitor.h"
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 "cpu.h"
41 #include "qemu_socket.h"
42 #include "kvm.h"
43
44 #ifndef TARGET_CPU_MEMORY_RW_DEBUG
45 static inline int target_memory_rw_debug(CPUState *env, target_ulong addr,
46 uint8_t *buf, int len, int is_write)
47 {
48 return cpu_memory_rw_debug(env, addr, buf, len, is_write);
49 }
50 #else
51 /* target_memory_rw_debug() defined in cpu.h */
52 #endif
53
54 enum {
55 GDB_SIGNAL_0 = 0,
56 GDB_SIGNAL_INT = 2,
57 GDB_SIGNAL_QUIT = 3,
58 GDB_SIGNAL_TRAP = 5,
59 GDB_SIGNAL_ABRT = 6,
60 GDB_SIGNAL_ALRM = 14,
61 GDB_SIGNAL_IO = 23,
62 GDB_SIGNAL_XCPU = 24,
63 GDB_SIGNAL_UNKNOWN = 143
64 };
65
66 #ifdef CONFIG_USER_ONLY
67
68 /* Map target signal numbers to GDB protocol signal numbers and vice
69 * versa. For user emulation's currently supported systems, we can
70 * assume most signals are defined.
71 */
72
73 static int gdb_signal_table[] = {
74 0,
75 TARGET_SIGHUP,
76 TARGET_SIGINT,
77 TARGET_SIGQUIT,
78 TARGET_SIGILL,
79 TARGET_SIGTRAP,
80 TARGET_SIGABRT,
81 -1, /* SIGEMT */
82 TARGET_SIGFPE,
83 TARGET_SIGKILL,
84 TARGET_SIGBUS,
85 TARGET_SIGSEGV,
86 TARGET_SIGSYS,
87 TARGET_SIGPIPE,
88 TARGET_SIGALRM,
89 TARGET_SIGTERM,
90 TARGET_SIGURG,
91 TARGET_SIGSTOP,
92 TARGET_SIGTSTP,
93 TARGET_SIGCONT,
94 TARGET_SIGCHLD,
95 TARGET_SIGTTIN,
96 TARGET_SIGTTOU,
97 TARGET_SIGIO,
98 TARGET_SIGXCPU,
99 TARGET_SIGXFSZ,
100 TARGET_SIGVTALRM,
101 TARGET_SIGPROF,
102 TARGET_SIGWINCH,
103 -1, /* SIGLOST */
104 TARGET_SIGUSR1,
105 TARGET_SIGUSR2,
106 #ifdef TARGET_SIGPWR
107 TARGET_SIGPWR,
108 #else
109 -1,
110 #endif
111 -1, /* SIGPOLL */
112 -1,
113 -1,
114 -1,
115 -1,
116 -1,
117 -1,
118 -1,
119 -1,
120 -1,
121 -1,
122 -1,
123 #ifdef __SIGRTMIN
124 __SIGRTMIN + 1,
125 __SIGRTMIN + 2,
126 __SIGRTMIN + 3,
127 __SIGRTMIN + 4,
128 __SIGRTMIN + 5,
129 __SIGRTMIN + 6,
130 __SIGRTMIN + 7,
131 __SIGRTMIN + 8,
132 __SIGRTMIN + 9,
133 __SIGRTMIN + 10,
134 __SIGRTMIN + 11,
135 __SIGRTMIN + 12,
136 __SIGRTMIN + 13,
137 __SIGRTMIN + 14,
138 __SIGRTMIN + 15,
139 __SIGRTMIN + 16,
140 __SIGRTMIN + 17,
141 __SIGRTMIN + 18,
142 __SIGRTMIN + 19,
143 __SIGRTMIN + 20,
144 __SIGRTMIN + 21,
145 __SIGRTMIN + 22,
146 __SIGRTMIN + 23,
147 __SIGRTMIN + 24,
148 __SIGRTMIN + 25,
149 __SIGRTMIN + 26,
150 __SIGRTMIN + 27,
151 __SIGRTMIN + 28,
152 __SIGRTMIN + 29,
153 __SIGRTMIN + 30,
154 __SIGRTMIN + 31,
155 -1, /* SIGCANCEL */
156 __SIGRTMIN,
157 __SIGRTMIN + 32,
158 __SIGRTMIN + 33,
159 __SIGRTMIN + 34,
160 __SIGRTMIN + 35,
161 __SIGRTMIN + 36,
162 __SIGRTMIN + 37,
163 __SIGRTMIN + 38,
164 __SIGRTMIN + 39,
165 __SIGRTMIN + 40,
166 __SIGRTMIN + 41,
167 __SIGRTMIN + 42,
168 __SIGRTMIN + 43,
169 __SIGRTMIN + 44,
170 __SIGRTMIN + 45,
171 __SIGRTMIN + 46,
172 __SIGRTMIN + 47,
173 __SIGRTMIN + 48,
174 __SIGRTMIN + 49,
175 __SIGRTMIN + 50,
176 __SIGRTMIN + 51,
177 __SIGRTMIN + 52,
178 __SIGRTMIN + 53,
179 __SIGRTMIN + 54,
180 __SIGRTMIN + 55,
181 __SIGRTMIN + 56,
182 __SIGRTMIN + 57,
183 __SIGRTMIN + 58,
184 __SIGRTMIN + 59,
185 __SIGRTMIN + 60,
186 __SIGRTMIN + 61,
187 __SIGRTMIN + 62,
188 __SIGRTMIN + 63,
189 __SIGRTMIN + 64,
190 __SIGRTMIN + 65,
191 __SIGRTMIN + 66,
192 __SIGRTMIN + 67,
193 __SIGRTMIN + 68,
194 __SIGRTMIN + 69,
195 __SIGRTMIN + 70,
196 __SIGRTMIN + 71,
197 __SIGRTMIN + 72,
198 __SIGRTMIN + 73,
199 __SIGRTMIN + 74,
200 __SIGRTMIN + 75,
201 __SIGRTMIN + 76,
202 __SIGRTMIN + 77,
203 __SIGRTMIN + 78,
204 __SIGRTMIN + 79,
205 __SIGRTMIN + 80,
206 __SIGRTMIN + 81,
207 __SIGRTMIN + 82,
208 __SIGRTMIN + 83,
209 __SIGRTMIN + 84,
210 __SIGRTMIN + 85,
211 __SIGRTMIN + 86,
212 __SIGRTMIN + 87,
213 __SIGRTMIN + 88,
214 __SIGRTMIN + 89,
215 __SIGRTMIN + 90,
216 __SIGRTMIN + 91,
217 __SIGRTMIN + 92,
218 __SIGRTMIN + 93,
219 __SIGRTMIN + 94,
220 __SIGRTMIN + 95,
221 -1, /* SIGINFO */
222 -1, /* UNKNOWN */
223 -1, /* DEFAULT */
224 -1,
225 -1,
226 -1,
227 -1,
228 -1,
229 -1
230 #endif
231 };
232 #else
233 /* In system mode we only need SIGINT and SIGTRAP; other signals
234 are not yet supported. */
235
236 enum {
237 TARGET_SIGINT = 2,
238 TARGET_SIGTRAP = 5
239 };
240
241 static int gdb_signal_table[] = {
242 -1,
243 -1,
244 TARGET_SIGINT,
245 -1,
246 -1,
247 TARGET_SIGTRAP
248 };
249 #endif
250
251 #ifdef CONFIG_USER_ONLY
252 static int target_signal_to_gdb (int sig)
253 {
254 int i;
255 for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
256 if (gdb_signal_table[i] == sig)
257 return i;
258 return GDB_SIGNAL_UNKNOWN;
259 }
260 #endif
261
262 static int gdb_signal_to_target (int sig)
263 {
264 if (sig < ARRAY_SIZE (gdb_signal_table))
265 return gdb_signal_table[sig];
266 else
267 return -1;
268 }
269
270 //#define DEBUG_GDB
271
272 typedef struct GDBRegisterState {
273 int base_reg;
274 int num_regs;
275 gdb_reg_cb get_reg;
276 gdb_reg_cb set_reg;
277 const char *xml;
278 struct GDBRegisterState *next;
279 } GDBRegisterState;
280
281 enum RSState {
282 RS_INACTIVE,
283 RS_IDLE,
284 RS_GETLINE,
285 RS_CHKSUM1,
286 RS_CHKSUM2,
287 RS_SYSCALL,
288 };
289 typedef struct GDBState {
290 CPUState *c_cpu; /* current CPU for step/continue ops */
291 CPUState *g_cpu; /* current CPU for other ops */
292 CPUState *query_cpu; /* for q{f|s}ThreadInfo */
293 enum RSState state; /* parsing state */
294 char line_buf[MAX_PACKET_LENGTH];
295 int line_buf_index;
296 int line_csum;
297 uint8_t last_packet[MAX_PACKET_LENGTH + 4];
298 int last_packet_len;
299 int signal;
300 #ifdef CONFIG_USER_ONLY
301 int fd;
302 int running_state;
303 #else
304 CharDriverState *chr;
305 CharDriverState *mon_chr;
306 #endif
307 } GDBState;
308
309 /* By default use no IRQs and no timers while single stepping so as to
310 * make single stepping like an ICE HW step.
311 */
312 static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
313
314 static GDBState *gdbserver_state;
315
316 /* This is an ugly hack to cope with both new and old gdb.
317 If gdb sends qXfer:features:read then assume we're talking to a newish
318 gdb that understands target descriptions. */
319 static int gdb_has_xml;
320
321 #ifdef CONFIG_USER_ONLY
322 /* XXX: This is not thread safe. Do we care? */
323 static int gdbserver_fd = -1;
324
325 static int get_char(GDBState *s)
326 {
327 uint8_t ch;
328 int ret;
329
330 for(;;) {
331 ret = qemu_recv(s->fd, &ch, 1, 0);
332 if (ret < 0) {
333 if (errno == ECONNRESET)
334 s->fd = -1;
335 if (errno != EINTR && errno != EAGAIN)
336 return -1;
337 } else if (ret == 0) {
338 close(s->fd);
339 s->fd = -1;
340 return -1;
341 } else {
342 break;
343 }
344 }
345 return ch;
346 }
347 #endif
348
349 static gdb_syscall_complete_cb gdb_current_syscall_cb;
350
351 static enum {
352 GDB_SYS_UNKNOWN,
353 GDB_SYS_ENABLED,
354 GDB_SYS_DISABLED,
355 } gdb_syscall_mode;
356
357 /* If gdb is connected when the first semihosting syscall occurs then use
358 remote gdb syscalls. Otherwise use native file IO. */
359 int use_gdb_syscalls(void)
360 {
361 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
362 gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
363 : GDB_SYS_DISABLED);
364 }
365 return gdb_syscall_mode == GDB_SYS_ENABLED;
366 }
367
368 /* Resume execution. */
369 static inline void gdb_continue(GDBState *s)
370 {
371 #ifdef CONFIG_USER_ONLY
372 s->running_state = 1;
373 #else
374 vm_start();
375 #endif
376 }
377
378 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
379 {
380 #ifdef CONFIG_USER_ONLY
381 int ret;
382
383 while (len > 0) {
384 ret = send(s->fd, buf, len, 0);
385 if (ret < 0) {
386 if (errno != EINTR && errno != EAGAIN)
387 return;
388 } else {
389 buf += ret;
390 len -= ret;
391 }
392 }
393 #else
394 qemu_chr_fe_write(s->chr, buf, len);
395 #endif
396 }
397
398 static inline int fromhex(int v)
399 {
400 if (v >= '0' && v <= '9')
401 return v - '0';
402 else if (v >= 'A' && v <= 'F')
403 return v - 'A' + 10;
404 else if (v >= 'a' && v <= 'f')
405 return v - 'a' + 10;
406 else
407 return 0;
408 }
409
410 static inline int tohex(int v)
411 {
412 if (v < 10)
413 return v + '0';
414 else
415 return v - 10 + 'a';
416 }
417
418 static void memtohex(char *buf, const uint8_t *mem, int len)
419 {
420 int i, c;
421 char *q;
422 q = buf;
423 for(i = 0; i < len; i++) {
424 c = mem[i];
425 *q++ = tohex(c >> 4);
426 *q++ = tohex(c & 0xf);
427 }
428 *q = '\0';
429 }
430
431 static void hextomem(uint8_t *mem, const char *buf, int len)
432 {
433 int i;
434
435 for(i = 0; i < len; i++) {
436 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
437 buf += 2;
438 }
439 }
440
441 /* return -1 if error, 0 if OK */
442 static int put_packet_binary(GDBState *s, const char *buf, int len)
443 {
444 int csum, i;
445 uint8_t *p;
446
447 for(;;) {
448 p = s->last_packet;
449 *(p++) = '$';
450 memcpy(p, buf, len);
451 p += len;
452 csum = 0;
453 for(i = 0; i < len; i++) {
454 csum += buf[i];
455 }
456 *(p++) = '#';
457 *(p++) = tohex((csum >> 4) & 0xf);
458 *(p++) = tohex((csum) & 0xf);
459
460 s->last_packet_len = p - s->last_packet;
461 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
462
463 #ifdef CONFIG_USER_ONLY
464 i = get_char(s);
465 if (i < 0)
466 return -1;
467 if (i == '+')
468 break;
469 #else
470 break;
471 #endif
472 }
473 return 0;
474 }
475
476 /* return -1 if error, 0 if OK */
477 static int put_packet(GDBState *s, const char *buf)
478 {
479 #ifdef DEBUG_GDB
480 printf("reply='%s'\n", buf);
481 #endif
482
483 return put_packet_binary(s, buf, strlen(buf));
484 }
485
486 /* The GDB remote protocol transfers values in target byte order. This means
487 we can use the raw memory access routines to access the value buffer.
488 Conveniently, these also handle the case where the buffer is mis-aligned.
489 */
490 #define GET_REG8(val) do { \
491 stb_p(mem_buf, val); \
492 return 1; \
493 } while(0)
494 #define GET_REG16(val) do { \
495 stw_p(mem_buf, val); \
496 return 2; \
497 } while(0)
498 #define GET_REG32(val) do { \
499 stl_p(mem_buf, val); \
500 return 4; \
501 } while(0)
502 #define GET_REG64(val) do { \
503 stq_p(mem_buf, val); \
504 return 8; \
505 } while(0)
506
507 #if TARGET_LONG_BITS == 64
508 #define GET_REGL(val) GET_REG64(val)
509 #define ldtul_p(addr) ldq_p(addr)
510 #else
511 #define GET_REGL(val) GET_REG32(val)
512 #define ldtul_p(addr) ldl_p(addr)
513 #endif
514
515 #if defined(TARGET_I386)
516
517 #ifdef TARGET_X86_64
518 static const int gpr_map[16] = {
519 R_EAX, R_EBX, R_ECX, R_EDX, R_ESI, R_EDI, R_EBP, R_ESP,
520 8, 9, 10, 11, 12, 13, 14, 15
521 };
522 #else
523 #define gpr_map gpr_map32
524 #endif
525 static const int gpr_map32[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
526
527 #define NUM_CORE_REGS (CPU_NB_REGS * 2 + 25)
528
529 #define IDX_IP_REG CPU_NB_REGS
530 #define IDX_FLAGS_REG (IDX_IP_REG + 1)
531 #define IDX_SEG_REGS (IDX_FLAGS_REG + 1)
532 #define IDX_FP_REGS (IDX_SEG_REGS + 6)
533 #define IDX_XMM_REGS (IDX_FP_REGS + 16)
534 #define IDX_MXCSR_REG (IDX_XMM_REGS + CPU_NB_REGS)
535
536 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
537 {
538 if (n < CPU_NB_REGS) {
539 if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {
540 GET_REG64(env->regs[gpr_map[n]]);
541 } else if (n < CPU_NB_REGS32) {
542 GET_REG32(env->regs[gpr_map32[n]]);
543 }
544 } else if (n >= IDX_FP_REGS && n < IDX_FP_REGS + 8) {
545 #ifdef USE_X86LDOUBLE
546 /* FIXME: byteswap float values - after fixing fpregs layout. */
547 memcpy(mem_buf, &env->fpregs[n - IDX_FP_REGS], 10);
548 #else
549 memset(mem_buf, 0, 10);
550 #endif
551 return 10;
552 } else if (n >= IDX_XMM_REGS && n < IDX_XMM_REGS + CPU_NB_REGS) {
553 n -= IDX_XMM_REGS;
554 if (n < CPU_NB_REGS32 ||
555 (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK)) {
556 stq_p(mem_buf, env->xmm_regs[n].XMM_Q(0));
557 stq_p(mem_buf + 8, env->xmm_regs[n].XMM_Q(1));
558 return 16;
559 }
560 } else {
561 switch (n) {
562 case IDX_IP_REG:
563 if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {
564 GET_REG64(env->eip);
565 } else {
566 GET_REG32(env->eip);
567 }
568 case IDX_FLAGS_REG: GET_REG32(env->eflags);
569
570 case IDX_SEG_REGS: GET_REG32(env->segs[R_CS].selector);
571 case IDX_SEG_REGS + 1: GET_REG32(env->segs[R_SS].selector);
572 case IDX_SEG_REGS + 2: GET_REG32(env->segs[R_DS].selector);
573 case IDX_SEG_REGS + 3: GET_REG32(env->segs[R_ES].selector);
574 case IDX_SEG_REGS + 4: GET_REG32(env->segs[R_FS].selector);
575 case IDX_SEG_REGS + 5: GET_REG32(env->segs[R_GS].selector);
576
577 case IDX_FP_REGS + 8: GET_REG32(env->fpuc);
578 case IDX_FP_REGS + 9: GET_REG32((env->fpus & ~0x3800) |
579 (env->fpstt & 0x7) << 11);
580 case IDX_FP_REGS + 10: GET_REG32(0); /* ftag */
581 case IDX_FP_REGS + 11: GET_REG32(0); /* fiseg */
582 case IDX_FP_REGS + 12: GET_REG32(0); /* fioff */
583 case IDX_FP_REGS + 13: GET_REG32(0); /* foseg */
584 case IDX_FP_REGS + 14: GET_REG32(0); /* fooff */
585 case IDX_FP_REGS + 15: GET_REG32(0); /* fop */
586
587 case IDX_MXCSR_REG: GET_REG32(env->mxcsr);
588 }
589 }
590 return 0;
591 }
592
593 static int cpu_x86_gdb_load_seg(CPUState *env, int sreg, uint8_t *mem_buf)
594 {
595 uint16_t selector = ldl_p(mem_buf);
596
597 if (selector != env->segs[sreg].selector) {
598 #if defined(CONFIG_USER_ONLY)
599 cpu_x86_load_seg(env, sreg, selector);
600 #else
601 unsigned int limit, flags;
602 target_ulong base;
603
604 if (!(env->cr[0] & CR0_PE_MASK) || (env->eflags & VM_MASK)) {
605 base = selector << 4;
606 limit = 0xffff;
607 flags = 0;
608 } else {
609 if (!cpu_x86_get_descr_debug(env, selector, &base, &limit, &flags))
610 return 4;
611 }
612 cpu_x86_load_seg_cache(env, sreg, selector, base, limit, flags);
613 #endif
614 }
615 return 4;
616 }
617
618 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
619 {
620 uint32_t tmp;
621
622 if (n < CPU_NB_REGS) {
623 if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {
624 env->regs[gpr_map[n]] = ldtul_p(mem_buf);
625 return sizeof(target_ulong);
626 } else if (n < CPU_NB_REGS32) {
627 n = gpr_map32[n];
628 env->regs[n] &= ~0xffffffffUL;
629 env->regs[n] |= (uint32_t)ldl_p(mem_buf);
630 return 4;
631 }
632 } else if (n >= IDX_FP_REGS && n < IDX_FP_REGS + 8) {
633 #ifdef USE_X86LDOUBLE
634 /* FIXME: byteswap float values - after fixing fpregs layout. */
635 memcpy(&env->fpregs[n - IDX_FP_REGS], mem_buf, 10);
636 #endif
637 return 10;
638 } else if (n >= IDX_XMM_REGS && n < IDX_XMM_REGS + CPU_NB_REGS) {
639 n -= IDX_XMM_REGS;
640 if (n < CPU_NB_REGS32 ||
641 (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK)) {
642 env->xmm_regs[n].XMM_Q(0) = ldq_p(mem_buf);
643 env->xmm_regs[n].XMM_Q(1) = ldq_p(mem_buf + 8);
644 return 16;
645 }
646 } else {
647 switch (n) {
648 case IDX_IP_REG:
649 if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {
650 env->eip = ldq_p(mem_buf);
651 return 8;
652 } else {
653 env->eip &= ~0xffffffffUL;
654 env->eip |= (uint32_t)ldl_p(mem_buf);
655 return 4;
656 }
657 case IDX_FLAGS_REG:
658 env->eflags = ldl_p(mem_buf);
659 return 4;
660
661 case IDX_SEG_REGS: return cpu_x86_gdb_load_seg(env, R_CS, mem_buf);
662 case IDX_SEG_REGS + 1: return cpu_x86_gdb_load_seg(env, R_SS, mem_buf);
663 case IDX_SEG_REGS + 2: return cpu_x86_gdb_load_seg(env, R_DS, mem_buf);
664 case IDX_SEG_REGS + 3: return cpu_x86_gdb_load_seg(env, R_ES, mem_buf);
665 case IDX_SEG_REGS + 4: return cpu_x86_gdb_load_seg(env, R_FS, mem_buf);
666 case IDX_SEG_REGS + 5: return cpu_x86_gdb_load_seg(env, R_GS, mem_buf);
667
668 case IDX_FP_REGS + 8:
669 env->fpuc = ldl_p(mem_buf);
670 return 4;
671 case IDX_FP_REGS + 9:
672 tmp = ldl_p(mem_buf);
673 env->fpstt = (tmp >> 11) & 7;
674 env->fpus = tmp & ~0x3800;
675 return 4;
676 case IDX_FP_REGS + 10: /* ftag */ return 4;
677 case IDX_FP_REGS + 11: /* fiseg */ return 4;
678 case IDX_FP_REGS + 12: /* fioff */ return 4;
679 case IDX_FP_REGS + 13: /* foseg */ return 4;
680 case IDX_FP_REGS + 14: /* fooff */ return 4;
681 case IDX_FP_REGS + 15: /* fop */ return 4;
682
683 case IDX_MXCSR_REG:
684 env->mxcsr = ldl_p(mem_buf);
685 return 4;
686 }
687 }
688 /* Unrecognised register. */
689 return 0;
690 }
691
692 #elif defined (TARGET_PPC)
693
694 /* Old gdb always expects FP registers. Newer (xml-aware) gdb only
695 expects whatever the target description contains. Due to a
696 historical mishap the FP registers appear in between core integer
697 regs and PC, MSR, CR, and so forth. We hack round this by giving the
698 FP regs zero size when talking to a newer gdb. */
699 #define NUM_CORE_REGS 71
700 #if defined (TARGET_PPC64)
701 #define GDB_CORE_XML "power64-core.xml"
702 #else
703 #define GDB_CORE_XML "power-core.xml"
704 #endif
705
706 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
707 {
708 if (n < 32) {
709 /* gprs */
710 GET_REGL(env->gpr[n]);
711 } else if (n < 64) {
712 /* fprs */
713 if (gdb_has_xml)
714 return 0;
715 stfq_p(mem_buf, env->fpr[n-32]);
716 return 8;
717 } else {
718 switch (n) {
719 case 64: GET_REGL(env->nip);
720 case 65: GET_REGL(env->msr);
721 case 66:
722 {
723 uint32_t cr = 0;
724 int i;
725 for (i = 0; i < 8; i++)
726 cr |= env->crf[i] << (32 - ((i + 1) * 4));
727 GET_REG32(cr);
728 }
729 case 67: GET_REGL(env->lr);
730 case 68: GET_REGL(env->ctr);
731 case 69: GET_REGL(env->xer);
732 case 70:
733 {
734 if (gdb_has_xml)
735 return 0;
736 GET_REG32(env->fpscr);
737 }
738 }
739 }
740 return 0;
741 }
742
743 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
744 {
745 if (n < 32) {
746 /* gprs */
747 env->gpr[n] = ldtul_p(mem_buf);
748 return sizeof(target_ulong);
749 } else if (n < 64) {
750 /* fprs */
751 if (gdb_has_xml)
752 return 0;
753 env->fpr[n-32] = ldfq_p(mem_buf);
754 return 8;
755 } else {
756 switch (n) {
757 case 64:
758 env->nip = ldtul_p(mem_buf);
759 return sizeof(target_ulong);
760 case 65:
761 ppc_store_msr(env, ldtul_p(mem_buf));
762 return sizeof(target_ulong);
763 case 66:
764 {
765 uint32_t cr = ldl_p(mem_buf);
766 int i;
767 for (i = 0; i < 8; i++)
768 env->crf[i] = (cr >> (32 - ((i + 1) * 4))) & 0xF;
769 return 4;
770 }
771 case 67:
772 env->lr = ldtul_p(mem_buf);
773 return sizeof(target_ulong);
774 case 68:
775 env->ctr = ldtul_p(mem_buf);
776 return sizeof(target_ulong);
777 case 69:
778 env->xer = ldtul_p(mem_buf);
779 return sizeof(target_ulong);
780 case 70:
781 /* fpscr */
782 if (gdb_has_xml)
783 return 0;
784 return 4;
785 }
786 }
787 return 0;
788 }
789
790 #elif defined (TARGET_SPARC)
791
792 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
793 #define NUM_CORE_REGS 86
794 #else
795 #define NUM_CORE_REGS 72
796 #endif
797
798 #ifdef TARGET_ABI32
799 #define GET_REGA(val) GET_REG32(val)
800 #else
801 #define GET_REGA(val) GET_REGL(val)
802 #endif
803
804 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
805 {
806 if (n < 8) {
807 /* g0..g7 */
808 GET_REGA(env->gregs[n]);
809 }
810 if (n < 32) {
811 /* register window */
812 GET_REGA(env->regwptr[n - 8]);
813 }
814 #if defined(TARGET_ABI32) || !defined(TARGET_SPARC64)
815 if (n < 64) {
816 /* fprs */
817 if (n & 1) {
818 GET_REG32(env->fpr[(n - 32) / 2].l.lower);
819 } else {
820 GET_REG32(env->fpr[(n - 32) / 2].l.upper);
821 }
822 }
823 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
824 switch (n) {
825 case 64: GET_REGA(env->y);
826 case 65: GET_REGA(cpu_get_psr(env));
827 case 66: GET_REGA(env->wim);
828 case 67: GET_REGA(env->tbr);
829 case 68: GET_REGA(env->pc);
830 case 69: GET_REGA(env->npc);
831 case 70: GET_REGA(env->fsr);
832 case 71: GET_REGA(0); /* csr */
833 default: GET_REGA(0);
834 }
835 #else
836 if (n < 64) {
837 /* f0-f31 */
838 if (n & 1) {
839 GET_REG32(env->fpr[(n - 32) / 2].l.lower);
840 } else {
841 GET_REG32(env->fpr[(n - 32) / 2].l.upper);
842 }
843 }
844 if (n < 80) {
845 /* f32-f62 (double width, even numbers only) */
846 GET_REG64(env->fpr[(n - 32) / 2].ll);
847 }
848 switch (n) {
849 case 80: GET_REGL(env->pc);
850 case 81: GET_REGL(env->npc);
851 case 82: GET_REGL((cpu_get_ccr(env) << 32) |
852 ((env->asi & 0xff) << 24) |
853 ((env->pstate & 0xfff) << 8) |
854 cpu_get_cwp64(env));
855 case 83: GET_REGL(env->fsr);
856 case 84: GET_REGL(env->fprs);
857 case 85: GET_REGL(env->y);
858 }
859 #endif
860 return 0;
861 }
862
863 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
864 {
865 #if defined(TARGET_ABI32)
866 abi_ulong tmp;
867
868 tmp = ldl_p(mem_buf);
869 #else
870 target_ulong tmp;
871
872 tmp = ldtul_p(mem_buf);
873 #endif
874
875 if (n < 8) {
876 /* g0..g7 */
877 env->gregs[n] = tmp;
878 } else if (n < 32) {
879 /* register window */
880 env->regwptr[n - 8] = tmp;
881 }
882 #if defined(TARGET_ABI32) || !defined(TARGET_SPARC64)
883 else if (n < 64) {
884 /* fprs */
885 /* f0-f31 */
886 if (n & 1) {
887 env->fpr[(n - 32) / 2].l.lower = tmp;
888 } else {
889 env->fpr[(n - 32) / 2].l.upper = tmp;
890 }
891 } else {
892 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
893 switch (n) {
894 case 64: env->y = tmp; break;
895 case 65: cpu_put_psr(env, tmp); break;
896 case 66: env->wim = tmp; break;
897 case 67: env->tbr = tmp; break;
898 case 68: env->pc = tmp; break;
899 case 69: env->npc = tmp; break;
900 case 70: env->fsr = tmp; break;
901 default: return 0;
902 }
903 }
904 return 4;
905 #else
906 else if (n < 64) {
907 /* f0-f31 */
908 tmp = ldl_p(mem_buf);
909 if (n & 1) {
910 env->fpr[(n - 32) / 2].l.lower = tmp;
911 } else {
912 env->fpr[(n - 32) / 2].l.upper = tmp;
913 }
914 return 4;
915 } else if (n < 80) {
916 /* f32-f62 (double width, even numbers only) */
917 env->fpr[(n - 32) / 2].ll = tmp;
918 } else {
919 switch (n) {
920 case 80: env->pc = tmp; break;
921 case 81: env->npc = tmp; break;
922 case 82:
923 cpu_put_ccr(env, tmp >> 32);
924 env->asi = (tmp >> 24) & 0xff;
925 env->pstate = (tmp >> 8) & 0xfff;
926 cpu_put_cwp64(env, tmp & 0xff);
927 break;
928 case 83: env->fsr = tmp; break;
929 case 84: env->fprs = tmp; break;
930 case 85: env->y = tmp; break;
931 default: return 0;
932 }
933 }
934 return 8;
935 #endif
936 }
937 #elif defined (TARGET_ARM)
938
939 /* Old gdb always expect FPA registers. Newer (xml-aware) gdb only expect
940 whatever the target description contains. Due to a historical mishap
941 the FPA registers appear in between core integer regs and the CPSR.
942 We hack round this by giving the FPA regs zero size when talking to a
943 newer gdb. */
944 #define NUM_CORE_REGS 26
945 #define GDB_CORE_XML "arm-core.xml"
946
947 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
948 {
949 if (n < 16) {
950 /* Core integer register. */
951 GET_REG32(env->regs[n]);
952 }
953 if (n < 24) {
954 /* FPA registers. */
955 if (gdb_has_xml)
956 return 0;
957 memset(mem_buf, 0, 12);
958 return 12;
959 }
960 switch (n) {
961 case 24:
962 /* FPA status register. */
963 if (gdb_has_xml)
964 return 0;
965 GET_REG32(0);
966 case 25:
967 /* CPSR */
968 GET_REG32(cpsr_read(env));
969 }
970 /* Unknown register. */
971 return 0;
972 }
973
974 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
975 {
976 uint32_t tmp;
977
978 tmp = ldl_p(mem_buf);
979
980 /* Mask out low bit of PC to workaround gdb bugs. This will probably
981 cause problems if we ever implement the Jazelle DBX extensions. */
982 if (n == 15)
983 tmp &= ~1;
984
985 if (n < 16) {
986 /* Core integer register. */
987 env->regs[n] = tmp;
988 return 4;
989 }
990 if (n < 24) { /* 16-23 */
991 /* FPA registers (ignored). */
992 if (gdb_has_xml)
993 return 0;
994 return 12;
995 }
996 switch (n) {
997 case 24:
998 /* FPA status register (ignored). */
999 if (gdb_has_xml)
1000 return 0;
1001 return 4;
1002 case 25:
1003 /* CPSR */
1004 cpsr_write (env, tmp, 0xffffffff);
1005 return 4;
1006 }
1007 /* Unknown register. */
1008 return 0;
1009 }
1010
1011 #elif defined (TARGET_M68K)
1012
1013 #define NUM_CORE_REGS 18
1014
1015 #define GDB_CORE_XML "cf-core.xml"
1016
1017 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1018 {
1019 if (n < 8) {
1020 /* D0-D7 */
1021 GET_REG32(env->dregs[n]);
1022 } else if (n < 16) {
1023 /* A0-A7 */
1024 GET_REG32(env->aregs[n - 8]);
1025 } else {
1026 switch (n) {
1027 case 16: GET_REG32(env->sr);
1028 case 17: GET_REG32(env->pc);
1029 }
1030 }
1031 /* FP registers not included here because they vary between
1032 ColdFire and m68k. Use XML bits for these. */
1033 return 0;
1034 }
1035
1036 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1037 {
1038 uint32_t tmp;
1039
1040 tmp = ldl_p(mem_buf);
1041
1042 if (n < 8) {
1043 /* D0-D7 */
1044 env->dregs[n] = tmp;
1045 } else if (n < 16) {
1046 /* A0-A7 */
1047 env->aregs[n - 8] = tmp;
1048 } else {
1049 switch (n) {
1050 case 16: env->sr = tmp; break;
1051 case 17: env->pc = tmp; break;
1052 default: return 0;
1053 }
1054 }
1055 return 4;
1056 }
1057 #elif defined (TARGET_MIPS)
1058
1059 #define NUM_CORE_REGS 73
1060
1061 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1062 {
1063 if (n < 32) {
1064 GET_REGL(env->active_tc.gpr[n]);
1065 }
1066 if (env->CP0_Config1 & (1 << CP0C1_FP)) {
1067 if (n >= 38 && n < 70) {
1068 if (env->CP0_Status & (1 << CP0St_FR))
1069 GET_REGL(env->active_fpu.fpr[n - 38].d);
1070 else
1071 GET_REGL(env->active_fpu.fpr[n - 38].w[FP_ENDIAN_IDX]);
1072 }
1073 switch (n) {
1074 case 70: GET_REGL((int32_t)env->active_fpu.fcr31);
1075 case 71: GET_REGL((int32_t)env->active_fpu.fcr0);
1076 }
1077 }
1078 switch (n) {
1079 case 32: GET_REGL((int32_t)env->CP0_Status);
1080 case 33: GET_REGL(env->active_tc.LO[0]);
1081 case 34: GET_REGL(env->active_tc.HI[0]);
1082 case 35: GET_REGL(env->CP0_BadVAddr);
1083 case 36: GET_REGL((int32_t)env->CP0_Cause);
1084 case 37: GET_REGL(env->active_tc.PC | !!(env->hflags & MIPS_HFLAG_M16));
1085 case 72: GET_REGL(0); /* fp */
1086 case 89: GET_REGL((int32_t)env->CP0_PRid);
1087 }
1088 if (n >= 73 && n <= 88) {
1089 /* 16 embedded regs. */
1090 GET_REGL(0);
1091 }
1092
1093 return 0;
1094 }
1095
1096 /* convert MIPS rounding mode in FCR31 to IEEE library */
1097 static unsigned int ieee_rm[] =
1098 {
1099 float_round_nearest_even,
1100 float_round_to_zero,
1101 float_round_up,
1102 float_round_down
1103 };
1104 #define RESTORE_ROUNDING_MODE \
1105 set_float_rounding_mode(ieee_rm[env->active_fpu.fcr31 & 3], &env->active_fpu.fp_status)
1106
1107 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1108 {
1109 target_ulong tmp;
1110
1111 tmp = ldtul_p(mem_buf);
1112
1113 if (n < 32) {
1114 env->active_tc.gpr[n] = tmp;
1115 return sizeof(target_ulong);
1116 }
1117 if (env->CP0_Config1 & (1 << CP0C1_FP)
1118 && n >= 38 && n < 73) {
1119 if (n < 70) {
1120 if (env->CP0_Status & (1 << CP0St_FR))
1121 env->active_fpu.fpr[n - 38].d = tmp;
1122 else
1123 env->active_fpu.fpr[n - 38].w[FP_ENDIAN_IDX] = tmp;
1124 }
1125 switch (n) {
1126 case 70:
1127 env->active_fpu.fcr31 = tmp & 0xFF83FFFF;
1128 /* set rounding mode */
1129 RESTORE_ROUNDING_MODE;
1130 break;
1131 case 71: env->active_fpu.fcr0 = tmp; break;
1132 }
1133 return sizeof(target_ulong);
1134 }
1135 switch (n) {
1136 case 32: env->CP0_Status = tmp; break;
1137 case 33: env->active_tc.LO[0] = tmp; break;
1138 case 34: env->active_tc.HI[0] = tmp; break;
1139 case 35: env->CP0_BadVAddr = tmp; break;
1140 case 36: env->CP0_Cause = tmp; break;
1141 case 37:
1142 env->active_tc.PC = tmp & ~(target_ulong)1;
1143 if (tmp & 1) {
1144 env->hflags |= MIPS_HFLAG_M16;
1145 } else {
1146 env->hflags &= ~(MIPS_HFLAG_M16);
1147 }
1148 break;
1149 case 72: /* fp, ignored */ break;
1150 default:
1151 if (n > 89)
1152 return 0;
1153 /* Other registers are readonly. Ignore writes. */
1154 break;
1155 }
1156
1157 return sizeof(target_ulong);
1158 }
1159 #elif defined (TARGET_SH4)
1160
1161 /* Hint: Use "set architecture sh4" in GDB to see fpu registers */
1162 /* FIXME: We should use XML for this. */
1163
1164 #define NUM_CORE_REGS 59
1165
1166 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1167 {
1168 if (n < 8) {
1169 if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
1170 GET_REGL(env->gregs[n + 16]);
1171 } else {
1172 GET_REGL(env->gregs[n]);
1173 }
1174 } else if (n < 16) {
1175 GET_REGL(env->gregs[n]);
1176 } else if (n >= 25 && n < 41) {
1177 GET_REGL(env->fregs[(n - 25) + ((env->fpscr & FPSCR_FR) ? 16 : 0)]);
1178 } else if (n >= 43 && n < 51) {
1179 GET_REGL(env->gregs[n - 43]);
1180 } else if (n >= 51 && n < 59) {
1181 GET_REGL(env->gregs[n - (51 - 16)]);
1182 }
1183 switch (n) {
1184 case 16: GET_REGL(env->pc);
1185 case 17: GET_REGL(env->pr);
1186 case 18: GET_REGL(env->gbr);
1187 case 19: GET_REGL(env->vbr);
1188 case 20: GET_REGL(env->mach);
1189 case 21: GET_REGL(env->macl);
1190 case 22: GET_REGL(env->sr);
1191 case 23: GET_REGL(env->fpul);
1192 case 24: GET_REGL(env->fpscr);
1193 case 41: GET_REGL(env->ssr);
1194 case 42: GET_REGL(env->spc);
1195 }
1196
1197 return 0;
1198 }
1199
1200 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1201 {
1202 uint32_t tmp;
1203
1204 tmp = ldl_p(mem_buf);
1205
1206 if (n < 8) {
1207 if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
1208 env->gregs[n + 16] = tmp;
1209 } else {
1210 env->gregs[n] = tmp;
1211 }
1212 return 4;
1213 } else if (n < 16) {
1214 env->gregs[n] = tmp;
1215 return 4;
1216 } else if (n >= 25 && n < 41) {
1217 env->fregs[(n - 25) + ((env->fpscr & FPSCR_FR) ? 16 : 0)] = tmp;
1218 return 4;
1219 } else if (n >= 43 && n < 51) {
1220 env->gregs[n - 43] = tmp;
1221 return 4;
1222 } else if (n >= 51 && n < 59) {
1223 env->gregs[n - (51 - 16)] = tmp;
1224 return 4;
1225 }
1226 switch (n) {
1227 case 16: env->pc = tmp; break;
1228 case 17: env->pr = tmp; break;
1229 case 18: env->gbr = tmp; break;
1230 case 19: env->vbr = tmp; break;
1231 case 20: env->mach = tmp; break;
1232 case 21: env->macl = tmp; break;
1233 case 22: env->sr = tmp; break;
1234 case 23: env->fpul = tmp; break;
1235 case 24: env->fpscr = tmp; break;
1236 case 41: env->ssr = tmp; break;
1237 case 42: env->spc = tmp; break;
1238 default: return 0;
1239 }
1240
1241 return 4;
1242 }
1243 #elif defined (TARGET_MICROBLAZE)
1244
1245 #define NUM_CORE_REGS (32 + 5)
1246
1247 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1248 {
1249 if (n < 32) {
1250 GET_REG32(env->regs[n]);
1251 } else {
1252 GET_REG32(env->sregs[n - 32]);
1253 }
1254 return 0;
1255 }
1256
1257 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1258 {
1259 uint32_t tmp;
1260
1261 if (n > NUM_CORE_REGS)
1262 return 0;
1263
1264 tmp = ldl_p(mem_buf);
1265
1266 if (n < 32) {
1267 env->regs[n] = tmp;
1268 } else {
1269 env->sregs[n - 32] = tmp;
1270 }
1271 return 4;
1272 }
1273 #elif defined (TARGET_CRIS)
1274
1275 #define NUM_CORE_REGS 49
1276
1277 static int
1278 read_register_crisv10(CPUState *env, uint8_t *mem_buf, int n)
1279 {
1280 if (n < 15) {
1281 GET_REG32(env->regs[n]);
1282 }
1283
1284 if (n == 15) {
1285 GET_REG32(env->pc);
1286 }
1287
1288 if (n < 32) {
1289 switch (n) {
1290 case 16:
1291 GET_REG8(env->pregs[n - 16]);
1292 break;
1293 case 17:
1294 GET_REG8(env->pregs[n - 16]);
1295 break;
1296 case 20:
1297 case 21:
1298 GET_REG16(env->pregs[n - 16]);
1299 break;
1300 default:
1301 if (n >= 23) {
1302 GET_REG32(env->pregs[n - 16]);
1303 }
1304 break;
1305 }
1306 }
1307 return 0;
1308 }
1309
1310 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1311 {
1312 uint8_t srs;
1313
1314 if (env->pregs[PR_VR] < 32)
1315 return read_register_crisv10(env, mem_buf, n);
1316
1317 srs = env->pregs[PR_SRS];
1318 if (n < 16) {
1319 GET_REG32(env->regs[n]);
1320 }
1321
1322 if (n >= 21 && n < 32) {
1323 GET_REG32(env->pregs[n - 16]);
1324 }
1325 if (n >= 33 && n < 49) {
1326 GET_REG32(env->sregs[srs][n - 33]);
1327 }
1328 switch (n) {
1329 case 16: GET_REG8(env->pregs[0]);
1330 case 17: GET_REG8(env->pregs[1]);
1331 case 18: GET_REG32(env->pregs[2]);
1332 case 19: GET_REG8(srs);
1333 case 20: GET_REG16(env->pregs[4]);
1334 case 32: GET_REG32(env->pc);
1335 }
1336
1337 return 0;
1338 }
1339
1340 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1341 {
1342 uint32_t tmp;
1343
1344 if (n > 49)
1345 return 0;
1346
1347 tmp = ldl_p(mem_buf);
1348
1349 if (n < 16) {
1350 env->regs[n] = tmp;
1351 }
1352
1353 if (n >= 21 && n < 32) {
1354 env->pregs[n - 16] = tmp;
1355 }
1356
1357 /* FIXME: Should support function regs be writable? */
1358 switch (n) {
1359 case 16: return 1;
1360 case 17: return 1;
1361 case 18: env->pregs[PR_PID] = tmp; break;
1362 case 19: return 1;
1363 case 20: return 2;
1364 case 32: env->pc = tmp; break;
1365 }
1366
1367 return 4;
1368 }
1369 #elif defined (TARGET_ALPHA)
1370
1371 #define NUM_CORE_REGS 67
1372
1373 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1374 {
1375 uint64_t val;
1376 CPU_DoubleU d;
1377
1378 switch (n) {
1379 case 0 ... 30:
1380 val = env->ir[n];
1381 break;
1382 case 32 ... 62:
1383 d.d = env->fir[n - 32];
1384 val = d.ll;
1385 break;
1386 case 63:
1387 val = cpu_alpha_load_fpcr(env);
1388 break;
1389 case 64:
1390 val = env->pc;
1391 break;
1392 case 66:
1393 val = env->unique;
1394 break;
1395 case 31:
1396 case 65:
1397 /* 31 really is the zero register; 65 is unassigned in the
1398 gdb protocol, but is still required to occupy 8 bytes. */
1399 val = 0;
1400 break;
1401 default:
1402 return 0;
1403 }
1404 GET_REGL(val);
1405 }
1406
1407 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1408 {
1409 target_ulong tmp = ldtul_p(mem_buf);
1410 CPU_DoubleU d;
1411
1412 switch (n) {
1413 case 0 ... 30:
1414 env->ir[n] = tmp;
1415 break;
1416 case 32 ... 62:
1417 d.ll = tmp;
1418 env->fir[n - 32] = d.d;
1419 break;
1420 case 63:
1421 cpu_alpha_store_fpcr(env, tmp);
1422 break;
1423 case 64:
1424 env->pc = tmp;
1425 break;
1426 case 66:
1427 env->unique = tmp;
1428 break;
1429 case 31:
1430 case 65:
1431 /* 31 really is the zero register; 65 is unassigned in the
1432 gdb protocol, but is still required to occupy 8 bytes. */
1433 break;
1434 default:
1435 return 0;
1436 }
1437 return 8;
1438 }
1439 #elif defined (TARGET_S390X)
1440
1441 #define NUM_CORE_REGS S390_NUM_TOTAL_REGS
1442
1443 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1444 {
1445 switch (n) {
1446 case S390_PSWM_REGNUM: GET_REGL(env->psw.mask); break;
1447 case S390_PSWA_REGNUM: GET_REGL(env->psw.addr); break;
1448 case S390_R0_REGNUM ... S390_R15_REGNUM:
1449 GET_REGL(env->regs[n-S390_R0_REGNUM]); break;
1450 case S390_A0_REGNUM ... S390_A15_REGNUM:
1451 GET_REG32(env->aregs[n-S390_A0_REGNUM]); break;
1452 case S390_FPC_REGNUM: GET_REG32(env->fpc); break;
1453 case S390_F0_REGNUM ... S390_F15_REGNUM:
1454 /* XXX */
1455 break;
1456 case S390_PC_REGNUM: GET_REGL(env->psw.addr); break;
1457 case S390_CC_REGNUM:
1458 env->cc_op = calc_cc(env, env->cc_op, env->cc_src, env->cc_dst,
1459 env->cc_vr);
1460 GET_REG32(env->cc_op);
1461 break;
1462 }
1463
1464 return 0;
1465 }
1466
1467 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1468 {
1469 target_ulong tmpl;
1470 uint32_t tmp32;
1471 int r = 8;
1472 tmpl = ldtul_p(mem_buf);
1473 tmp32 = ldl_p(mem_buf);
1474
1475 switch (n) {
1476 case S390_PSWM_REGNUM: env->psw.mask = tmpl; break;
1477 case S390_PSWA_REGNUM: env->psw.addr = tmpl; break;
1478 case S390_R0_REGNUM ... S390_R15_REGNUM:
1479 env->regs[n-S390_R0_REGNUM] = tmpl; break;
1480 case S390_A0_REGNUM ... S390_A15_REGNUM:
1481 env->aregs[n-S390_A0_REGNUM] = tmp32; r=4; break;
1482 case S390_FPC_REGNUM: env->fpc = tmp32; r=4; break;
1483 case S390_F0_REGNUM ... S390_F15_REGNUM:
1484 /* XXX */
1485 break;
1486 case S390_PC_REGNUM: env->psw.addr = tmpl; break;
1487 case S390_CC_REGNUM: env->cc_op = tmp32; r=4; break;
1488 }
1489
1490 return r;
1491 }
1492 #elif defined (TARGET_LM32)
1493
1494 #include "hw/lm32_pic.h"
1495 #define NUM_CORE_REGS (32 + 7)
1496
1497 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1498 {
1499 if (n < 32) {
1500 GET_REG32(env->regs[n]);
1501 } else {
1502 switch (n) {
1503 case 32:
1504 GET_REG32(env->pc);
1505 break;
1506 /* FIXME: put in right exception ID */
1507 case 33:
1508 GET_REG32(0);
1509 break;
1510 case 34:
1511 GET_REG32(env->eba);
1512 break;
1513 case 35:
1514 GET_REG32(env->deba);
1515 break;
1516 case 36:
1517 GET_REG32(env->ie);
1518 break;
1519 case 37:
1520 GET_REG32(lm32_pic_get_im(env->pic_state));
1521 break;
1522 case 38:
1523 GET_REG32(lm32_pic_get_ip(env->pic_state));
1524 break;
1525 }
1526 }
1527 return 0;
1528 }
1529
1530 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1531 {
1532 uint32_t tmp;
1533
1534 if (n > NUM_CORE_REGS) {
1535 return 0;
1536 }
1537
1538 tmp = ldl_p(mem_buf);
1539
1540 if (n < 32) {
1541 env->regs[n] = tmp;
1542 } else {
1543 switch (n) {
1544 case 32:
1545 env->pc = tmp;
1546 break;
1547 case 34:
1548 env->eba = tmp;
1549 break;
1550 case 35:
1551 env->deba = tmp;
1552 break;
1553 case 36:
1554 env->ie = tmp;
1555 break;
1556 case 37:
1557 lm32_pic_set_im(env->pic_state, tmp);
1558 break;
1559 case 38:
1560 lm32_pic_set_ip(env->pic_state, tmp);
1561 break;
1562 }
1563 }
1564 return 4;
1565 }
1566 #elif defined(TARGET_XTENSA)
1567
1568 /* Use num_core_regs to see only non-privileged registers in an unmodified gdb.
1569 * Use num_regs to see all registers. gdb modification is required for that:
1570 * reset bit 0 in the 'flags' field of the registers definitions in the
1571 * gdb/xtensa-config.c inside gdb source tree or inside gdb overlay.
1572 */
1573 #define NUM_CORE_REGS (env->config->gdb_regmap.num_regs)
1574 #define num_g_regs NUM_CORE_REGS
1575
1576 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1577 {
1578 const XtensaGdbReg *reg = env->config->gdb_regmap.reg + n;
1579
1580 if (n < 0 || n >= env->config->gdb_regmap.num_regs) {
1581 return 0;
1582 }
1583
1584 switch (reg->type) {
1585 case 9: /*pc*/
1586 GET_REG32(env->pc);
1587 break;
1588
1589 case 1: /*ar*/
1590 xtensa_sync_phys_from_window(env);
1591 GET_REG32(env->phys_regs[(reg->targno & 0xff) % env->config->nareg]);
1592 break;
1593
1594 case 2: /*SR*/
1595 GET_REG32(env->sregs[reg->targno & 0xff]);
1596 break;
1597
1598 case 3: /*UR*/
1599 GET_REG32(env->uregs[reg->targno & 0xff]);
1600 break;
1601
1602 case 8: /*a*/
1603 GET_REG32(env->regs[reg->targno & 0x0f]);
1604 break;
1605
1606 default:
1607 qemu_log("%s from reg %d of unsupported type %d\n",
1608 __func__, n, reg->type);
1609 return 0;
1610 }
1611 }
1612
1613 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1614 {
1615 uint32_t tmp;
1616 const XtensaGdbReg *reg = env->config->gdb_regmap.reg + n;
1617
1618 if (n < 0 || n >= env->config->gdb_regmap.num_regs) {
1619 return 0;
1620 }
1621
1622 tmp = ldl_p(mem_buf);
1623
1624 switch (reg->type) {
1625 case 9: /*pc*/
1626 env->pc = tmp;
1627 break;
1628
1629 case 1: /*ar*/
1630 env->phys_regs[(reg->targno & 0xff) % env->config->nareg] = tmp;
1631 xtensa_sync_window_from_phys(env);
1632 break;
1633
1634 case 2: /*SR*/
1635 env->sregs[reg->targno & 0xff] = tmp;
1636 break;
1637
1638 case 3: /*UR*/
1639 env->uregs[reg->targno & 0xff] = tmp;
1640 break;
1641
1642 case 8: /*a*/
1643 env->regs[reg->targno & 0x0f] = tmp;
1644 break;
1645
1646 default:
1647 qemu_log("%s to reg %d of unsupported type %d\n",
1648 __func__, n, reg->type);
1649 return 0;
1650 }
1651
1652 return 4;
1653 }
1654 #else
1655
1656 #define NUM_CORE_REGS 0
1657
1658 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
1659 {
1660 return 0;
1661 }
1662
1663 static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
1664 {
1665 return 0;
1666 }
1667
1668 #endif
1669
1670 #if !defined(TARGET_XTENSA)
1671 static int num_g_regs = NUM_CORE_REGS;
1672 #endif
1673
1674 #ifdef GDB_CORE_XML
1675 /* Encode data using the encoding for 'x' packets. */
1676 static int memtox(char *buf, const char *mem, int len)
1677 {
1678 char *p = buf;
1679 char c;
1680
1681 while (len--) {
1682 c = *(mem++);
1683 switch (c) {
1684 case '#': case '$': case '*': case '}':
1685 *(p++) = '}';
1686 *(p++) = c ^ 0x20;
1687 break;
1688 default:
1689 *(p++) = c;
1690 break;
1691 }
1692 }
1693 return p - buf;
1694 }
1695
1696 static const char *get_feature_xml(const char *p, const char **newp)
1697 {
1698 size_t len;
1699 int i;
1700 const char *name;
1701 static char target_xml[1024];
1702
1703 len = 0;
1704 while (p[len] && p[len] != ':')
1705 len++;
1706 *newp = p + len;
1707
1708 name = NULL;
1709 if (strncmp(p, "target.xml", len) == 0) {
1710 /* Generate the XML description for this CPU. */
1711 if (!target_xml[0]) {
1712 GDBRegisterState *r;
1713
1714 snprintf(target_xml, sizeof(target_xml),
1715 "<?xml version=\"1.0\"?>"
1716 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
1717 "<target>"
1718 "<xi:include href=\"%s\"/>",
1719 GDB_CORE_XML);
1720
1721 for (r = first_cpu->gdb_regs; r; r = r->next) {
1722 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
1723 pstrcat(target_xml, sizeof(target_xml), r->xml);
1724 pstrcat(target_xml, sizeof(target_xml), "\"/>");
1725 }
1726 pstrcat(target_xml, sizeof(target_xml), "</target>");
1727 }
1728 return target_xml;
1729 }
1730 for (i = 0; ; i++) {
1731 name = xml_builtin[i][0];
1732 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
1733 break;
1734 }
1735 return name ? xml_builtin[i][1] : NULL;
1736 }
1737 #endif
1738
1739 static int gdb_read_register(CPUState *env, uint8_t *mem_buf, int reg)
1740 {
1741 GDBRegisterState *r;
1742
1743 if (reg < NUM_CORE_REGS)
1744 return cpu_gdb_read_register(env, mem_buf, reg);
1745
1746 for (r = env->gdb_regs; r; r = r->next) {
1747 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
1748 return r->get_reg(env, mem_buf, reg - r->base_reg);
1749 }
1750 }
1751 return 0;
1752 }
1753
1754 static int gdb_write_register(CPUState *env, uint8_t *mem_buf, int reg)
1755 {
1756 GDBRegisterState *r;
1757
1758 if (reg < NUM_CORE_REGS)
1759 return cpu_gdb_write_register(env, mem_buf, reg);
1760
1761 for (r = env->gdb_regs; r; r = r->next) {
1762 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
1763 return r->set_reg(env, mem_buf, reg - r->base_reg);
1764 }
1765 }
1766 return 0;
1767 }
1768
1769 #if !defined(TARGET_XTENSA)
1770 /* Register a supplemental set of CPU registers. If g_pos is nonzero it
1771 specifies the first register number and these registers are included in
1772 a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
1773 gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
1774 */
1775
1776 void gdb_register_coprocessor(CPUState * env,
1777 gdb_reg_cb get_reg, gdb_reg_cb set_reg,
1778 int num_regs, const char *xml, int g_pos)
1779 {
1780 GDBRegisterState *s;
1781 GDBRegisterState **p;
1782 static int last_reg = NUM_CORE_REGS;
1783
1784 p = &env->gdb_regs;
1785 while (*p) {
1786 /* Check for duplicates. */
1787 if (strcmp((*p)->xml, xml) == 0)
1788 return;
1789 p = &(*p)->next;
1790 }
1791
1792 s = g_new0(GDBRegisterState, 1);
1793 s->base_reg = last_reg;
1794 s->num_regs = num_regs;
1795 s->get_reg = get_reg;
1796 s->set_reg = set_reg;
1797 s->xml = xml;
1798
1799 /* Add to end of list. */
1800 last_reg += num_regs;
1801 *p = s;
1802 if (g_pos) {
1803 if (g_pos != s->base_reg) {
1804 fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"
1805 "Expected %d got %d\n", xml, g_pos, s->base_reg);
1806 } else {
1807 num_g_regs = last_reg;
1808 }
1809 }
1810 }
1811 #endif
1812
1813 #ifndef CONFIG_USER_ONLY
1814 static const int xlat_gdb_type[] = {
1815 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
1816 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
1817 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
1818 };
1819 #endif
1820
1821 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
1822 {
1823 CPUState *env;
1824 int err = 0;
1825
1826 if (kvm_enabled())
1827 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
1828
1829 switch (type) {
1830 case GDB_BREAKPOINT_SW:
1831 case GDB_BREAKPOINT_HW:
1832 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1833 err = cpu_breakpoint_insert(env, addr, BP_GDB, NULL);
1834 if (err)
1835 break;
1836 }
1837 return err;
1838 #ifndef CONFIG_USER_ONLY
1839 case GDB_WATCHPOINT_WRITE:
1840 case GDB_WATCHPOINT_READ:
1841 case GDB_WATCHPOINT_ACCESS:
1842 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1843 err = cpu_watchpoint_insert(env, addr, len, xlat_gdb_type[type],
1844 NULL);
1845 if (err)
1846 break;
1847 }
1848 return err;
1849 #endif
1850 default:
1851 return -ENOSYS;
1852 }
1853 }
1854
1855 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
1856 {
1857 CPUState *env;
1858 int err = 0;
1859
1860 if (kvm_enabled())
1861 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
1862
1863 switch (type) {
1864 case GDB_BREAKPOINT_SW:
1865 case GDB_BREAKPOINT_HW:
1866 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1867 err = cpu_breakpoint_remove(env, addr, BP_GDB);
1868 if (err)
1869 break;
1870 }
1871 return err;
1872 #ifndef CONFIG_USER_ONLY
1873 case GDB_WATCHPOINT_WRITE:
1874 case GDB_WATCHPOINT_READ:
1875 case GDB_WATCHPOINT_ACCESS:
1876 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1877 err = cpu_watchpoint_remove(env, addr, len, xlat_gdb_type[type]);
1878 if (err)
1879 break;
1880 }
1881 return err;
1882 #endif
1883 default:
1884 return -ENOSYS;
1885 }
1886 }
1887
1888 static void gdb_breakpoint_remove_all(void)
1889 {
1890 CPUState *env;
1891
1892 if (kvm_enabled()) {
1893 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
1894 return;
1895 }
1896
1897 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1898 cpu_breakpoint_remove_all(env, BP_GDB);
1899 #ifndef CONFIG_USER_ONLY
1900 cpu_watchpoint_remove_all(env, BP_GDB);
1901 #endif
1902 }
1903 }
1904
1905 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
1906 {
1907 #if defined(TARGET_I386)
1908 cpu_synchronize_state(s->c_cpu);
1909 s->c_cpu->eip = pc;
1910 #elif defined (TARGET_PPC)
1911 s->c_cpu->nip = pc;
1912 #elif defined (TARGET_SPARC)
1913 s->c_cpu->pc = pc;
1914 s->c_cpu->npc = pc + 4;
1915 #elif defined (TARGET_ARM)
1916 s->c_cpu->regs[15] = pc;
1917 #elif defined (TARGET_SH4)
1918 s->c_cpu->pc = pc;
1919 #elif defined (TARGET_MIPS)
1920 s->c_cpu->active_tc.PC = pc & ~(target_ulong)1;
1921 if (pc & 1) {
1922 s->c_cpu->hflags |= MIPS_HFLAG_M16;
1923 } else {
1924 s->c_cpu->hflags &= ~(MIPS_HFLAG_M16);
1925 }
1926 #elif defined (TARGET_MICROBLAZE)
1927 s->c_cpu->sregs[SR_PC] = pc;
1928 #elif defined (TARGET_CRIS)
1929 s->c_cpu->pc = pc;
1930 #elif defined (TARGET_ALPHA)
1931 s->c_cpu->pc = pc;
1932 #elif defined (TARGET_S390X)
1933 cpu_synchronize_state(s->c_cpu);
1934 s->c_cpu->psw.addr = pc;
1935 #elif defined (TARGET_LM32)
1936 s->c_cpu->pc = pc;
1937 #elif defined(TARGET_XTENSA)
1938 s->c_cpu->pc = pc;
1939 #endif
1940 }
1941
1942 static inline int gdb_id(CPUState *env)
1943 {
1944 #if defined(CONFIG_USER_ONLY) && defined(CONFIG_USE_NPTL)
1945 return env->host_tid;
1946 #else
1947 return env->cpu_index + 1;
1948 #endif
1949 }
1950
1951 static CPUState *find_cpu(uint32_t thread_id)
1952 {
1953 CPUState *env;
1954
1955 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1956 if (gdb_id(env) == thread_id) {
1957 return env;
1958 }
1959 }
1960
1961 return NULL;
1962 }
1963
1964 static int gdb_handle_packet(GDBState *s, const char *line_buf)
1965 {
1966 CPUState *env;
1967 const char *p;
1968 uint32_t thread;
1969 int ch, reg_size, type, res;
1970 char buf[MAX_PACKET_LENGTH];
1971 uint8_t mem_buf[MAX_PACKET_LENGTH];
1972 uint8_t *registers;
1973 target_ulong addr, len;
1974
1975 #ifdef DEBUG_GDB
1976 printf("command='%s'\n", line_buf);
1977 #endif
1978 p = line_buf;
1979 ch = *p++;
1980 switch(ch) {
1981 case '?':
1982 /* TODO: Make this return the correct value for user-mode. */
1983 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
1984 gdb_id(s->c_cpu));
1985 put_packet(s, buf);
1986 /* Remove all the breakpoints when this query is issued,
1987 * because gdb is doing and initial connect and the state
1988 * should be cleaned up.
1989 */
1990 gdb_breakpoint_remove_all();
1991 break;
1992 case 'c':
1993 if (*p != '\0') {
1994 addr = strtoull(p, (char **)&p, 16);
1995 gdb_set_cpu_pc(s, addr);
1996 }
1997 s->signal = 0;
1998 gdb_continue(s);
1999 return RS_IDLE;
2000 case 'C':
2001 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
2002 if (s->signal == -1)
2003 s->signal = 0;
2004 gdb_continue(s);
2005 return RS_IDLE;
2006 case 'v':
2007 if (strncmp(p, "Cont", 4) == 0) {
2008 int res_signal, res_thread;
2009
2010 p += 4;
2011 if (*p == '?') {
2012 put_packet(s, "vCont;c;C;s;S");
2013 break;
2014 }
2015 res = 0;
2016 res_signal = 0;
2017 res_thread = 0;
2018 while (*p) {
2019 int action, signal;
2020
2021 if (*p++ != ';') {
2022 res = 0;
2023 break;
2024 }
2025 action = *p++;
2026 signal = 0;
2027 if (action == 'C' || action == 'S') {
2028 signal = strtoul(p, (char **)&p, 16);
2029 } else if (action != 'c' && action != 's') {
2030 res = 0;
2031 break;
2032 }
2033 thread = 0;
2034 if (*p == ':') {
2035 thread = strtoull(p+1, (char **)&p, 16);
2036 }
2037 action = tolower(action);
2038 if (res == 0 || (res == 'c' && action == 's')) {
2039 res = action;
2040 res_signal = signal;
2041 res_thread = thread;
2042 }
2043 }
2044 if (res) {
2045 if (res_thread != -1 && res_thread != 0) {
2046 env = find_cpu(res_thread);
2047 if (env == NULL) {
2048 put_packet(s, "E22");
2049 break;
2050 }
2051 s->c_cpu = env;
2052 }
2053 if (res == 's') {
2054 cpu_single_step(s->c_cpu, sstep_flags);
2055 }
2056 s->signal = res_signal;
2057 gdb_continue(s);
2058 return RS_IDLE;
2059 }
2060 break;
2061 } else {
2062 goto unknown_command;
2063 }
2064 case 'k':
2065 /* Kill the target */
2066 fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
2067 exit(0);
2068 case 'D':
2069 /* Detach packet */
2070 gdb_breakpoint_remove_all();
2071 gdb_syscall_mode = GDB_SYS_DISABLED;
2072 gdb_continue(s);
2073 put_packet(s, "OK");
2074 break;
2075 case 's':
2076 if (*p != '\0') {
2077 addr = strtoull(p, (char **)&p, 16);
2078 gdb_set_cpu_pc(s, addr);
2079 }
2080 cpu_single_step(s->c_cpu, sstep_flags);
2081 gdb_continue(s);
2082 return RS_IDLE;
2083 case 'F':
2084 {
2085 target_ulong ret;
2086 target_ulong err;
2087
2088 ret = strtoull(p, (char **)&p, 16);
2089 if (*p == ',') {
2090 p++;
2091 err = strtoull(p, (char **)&p, 16);
2092 } else {
2093 err = 0;
2094 }
2095 if (*p == ',')
2096 p++;
2097 type = *p;
2098 if (gdb_current_syscall_cb)
2099 gdb_current_syscall_cb(s->c_cpu, ret, err);
2100 if (type == 'C') {
2101 put_packet(s, "T02");
2102 } else {
2103 gdb_continue(s);
2104 }
2105 }
2106 break;
2107 case 'g':
2108 cpu_synchronize_state(s->g_cpu);
2109 env = s->g_cpu;
2110 len = 0;
2111 for (addr = 0; addr < num_g_regs; addr++) {
2112 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
2113 len += reg_size;
2114 }
2115 memtohex(buf, mem_buf, len);
2116 put_packet(s, buf);
2117 break;
2118 case 'G':
2119 cpu_synchronize_state(s->g_cpu);
2120 env = s->g_cpu;
2121 registers = mem_buf;
2122 len = strlen(p) / 2;
2123 hextomem((uint8_t *)registers, p, len);
2124 for (addr = 0; addr < num_g_regs && len > 0; addr++) {
2125 reg_size = gdb_write_register(s->g_cpu, registers, addr);
2126 len -= reg_size;
2127 registers += reg_size;
2128 }
2129 put_packet(s, "OK");
2130 break;
2131 case 'm':
2132 addr = strtoull(p, (char **)&p, 16);
2133 if (*p == ',')
2134 p++;
2135 len = strtoull(p, NULL, 16);
2136 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, 0) != 0) {
2137 put_packet (s, "E14");
2138 } else {
2139 memtohex(buf, mem_buf, len);
2140 put_packet(s, buf);
2141 }
2142 break;
2143 case 'M':
2144 addr = strtoull(p, (char **)&p, 16);
2145 if (*p == ',')
2146 p++;
2147 len = strtoull(p, (char **)&p, 16);
2148 if (*p == ':')
2149 p++;
2150 hextomem(mem_buf, p, len);
2151 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, 1) != 0) {
2152 put_packet(s, "E14");
2153 } else {
2154 put_packet(s, "OK");
2155 }
2156 break;
2157 case 'p':
2158 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
2159 This works, but can be very slow. Anything new enough to
2160 understand XML also knows how to use this properly. */
2161 if (!gdb_has_xml)
2162 goto unknown_command;
2163 addr = strtoull(p, (char **)&p, 16);
2164 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
2165 if (reg_size) {
2166 memtohex(buf, mem_buf, reg_size);
2167 put_packet(s, buf);
2168 } else {
2169 put_packet(s, "E14");
2170 }
2171 break;
2172 case 'P':
2173 if (!gdb_has_xml)
2174 goto unknown_command;
2175 addr = strtoull(p, (char **)&p, 16);
2176 if (*p == '=')
2177 p++;
2178 reg_size = strlen(p) / 2;
2179 hextomem(mem_buf, p, reg_size);
2180 gdb_write_register(s->g_cpu, mem_buf, addr);
2181 put_packet(s, "OK");
2182 break;
2183 case 'Z':
2184 case 'z':
2185 type = strtoul(p, (char **)&p, 16);
2186 if (*p == ',')
2187 p++;
2188 addr = strtoull(p, (char **)&p, 16);
2189 if (*p == ',')
2190 p++;
2191 len = strtoull(p, (char **)&p, 16);
2192 if (ch == 'Z')
2193 res = gdb_breakpoint_insert(addr, len, type);
2194 else
2195 res = gdb_breakpoint_remove(addr, len, type);
2196 if (res >= 0)
2197 put_packet(s, "OK");
2198 else if (res == -ENOSYS)
2199 put_packet(s, "");
2200 else
2201 put_packet(s, "E22");
2202 break;
2203 case 'H':
2204 type = *p++;
2205 thread = strtoull(p, (char **)&p, 16);
2206 if (thread == -1 || thread == 0) {
2207 put_packet(s, "OK");
2208 break;
2209 }
2210 env = find_cpu(thread);
2211 if (env == NULL) {
2212 put_packet(s, "E22");
2213 break;
2214 }
2215 switch (type) {
2216 case 'c':
2217 s->c_cpu = env;
2218 put_packet(s, "OK");
2219 break;
2220 case 'g':
2221 s->g_cpu = env;
2222 put_packet(s, "OK");
2223 break;
2224 default:
2225 put_packet(s, "E22");
2226 break;
2227 }
2228 break;
2229 case 'T':
2230 thread = strtoull(p, (char **)&p, 16);
2231 env = find_cpu(thread);
2232
2233 if (env != NULL) {
2234 put_packet(s, "OK");
2235 } else {
2236 put_packet(s, "E22");
2237 }
2238 break;
2239 case 'q':
2240 case 'Q':
2241 /* parse any 'q' packets here */
2242 if (!strcmp(p,"qemu.sstepbits")) {
2243 /* Query Breakpoint bit definitions */
2244 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
2245 SSTEP_ENABLE,
2246 SSTEP_NOIRQ,
2247 SSTEP_NOTIMER);
2248 put_packet(s, buf);
2249 break;
2250 } else if (strncmp(p,"qemu.sstep",10) == 0) {
2251 /* Display or change the sstep_flags */
2252 p += 10;
2253 if (*p != '=') {
2254 /* Display current setting */
2255 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
2256 put_packet(s, buf);
2257 break;
2258 }
2259 p++;
2260 type = strtoul(p, (char **)&p, 16);
2261 sstep_flags = type;
2262 put_packet(s, "OK");
2263 break;
2264 } else if (strcmp(p,"C") == 0) {
2265 /* "Current thread" remains vague in the spec, so always return
2266 * the first CPU (gdb returns the first thread). */
2267 put_packet(s, "QC1");
2268 break;
2269 } else if (strcmp(p,"fThreadInfo") == 0) {
2270 s->query_cpu = first_cpu;
2271 goto report_cpuinfo;
2272 } else if (strcmp(p,"sThreadInfo") == 0) {
2273 report_cpuinfo:
2274 if (s->query_cpu) {
2275 snprintf(buf, sizeof(buf), "m%x", gdb_id(s->query_cpu));
2276 put_packet(s, buf);
2277 s->query_cpu = s->query_cpu->next_cpu;
2278 } else
2279 put_packet(s, "l");
2280 break;
2281 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
2282 thread = strtoull(p+16, (char **)&p, 16);
2283 env = find_cpu(thread);
2284 if (env != NULL) {
2285 cpu_synchronize_state(env);
2286 len = snprintf((char *)mem_buf, sizeof(mem_buf),
2287 "CPU#%d [%s]", env->cpu_index,
2288 env->halted ? "halted " : "running");
2289 memtohex(buf, mem_buf, len);
2290 put_packet(s, buf);
2291 }
2292 break;
2293 }
2294 #ifdef CONFIG_USER_ONLY
2295 else if (strncmp(p, "Offsets", 7) == 0) {
2296 TaskState *ts = s->c_cpu->opaque;
2297
2298 snprintf(buf, sizeof(buf),
2299 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
2300 ";Bss=" TARGET_ABI_FMT_lx,
2301 ts->info->code_offset,
2302 ts->info->data_offset,
2303 ts->info->data_offset);
2304 put_packet(s, buf);
2305 break;
2306 }
2307 #else /* !CONFIG_USER_ONLY */
2308 else if (strncmp(p, "Rcmd,", 5) == 0) {
2309 int len = strlen(p + 5);
2310
2311 if ((len % 2) != 0) {
2312 put_packet(s, "E01");
2313 break;
2314 }
2315 hextomem(mem_buf, p + 5, len);
2316 len = len / 2;
2317 mem_buf[len++] = 0;
2318 qemu_chr_be_write(s->mon_chr, mem_buf, len);
2319 put_packet(s, "OK");
2320 break;
2321 }
2322 #endif /* !CONFIG_USER_ONLY */
2323 if (strncmp(p, "Supported", 9) == 0) {
2324 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
2325 #ifdef GDB_CORE_XML
2326 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
2327 #endif
2328 put_packet(s, buf);
2329 break;
2330 }
2331 #ifdef GDB_CORE_XML
2332 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
2333 const char *xml;
2334 target_ulong total_len;
2335
2336 gdb_has_xml = 1;
2337 p += 19;
2338 xml = get_feature_xml(p, &p);
2339 if (!xml) {
2340 snprintf(buf, sizeof(buf), "E00");
2341 put_packet(s, buf);
2342 break;
2343 }
2344
2345 if (*p == ':')
2346 p++;
2347 addr = strtoul(p, (char **)&p, 16);
2348 if (*p == ',')
2349 p++;
2350 len = strtoul(p, (char **)&p, 16);
2351
2352 total_len = strlen(xml);
2353 if (addr > total_len) {
2354 snprintf(buf, sizeof(buf), "E00");
2355 put_packet(s, buf);
2356 break;
2357 }
2358 if (len > (MAX_PACKET_LENGTH - 5) / 2)
2359 len = (MAX_PACKET_LENGTH - 5) / 2;
2360 if (len < total_len - addr) {
2361 buf[0] = 'm';
2362 len = memtox(buf + 1, xml + addr, len);
2363 } else {
2364 buf[0] = 'l';
2365 len = memtox(buf + 1, xml + addr, total_len - addr);
2366 }
2367 put_packet_binary(s, buf, len + 1);
2368 break;
2369 }
2370 #endif
2371 /* Unrecognised 'q' command. */
2372 goto unknown_command;
2373
2374 default:
2375 unknown_command:
2376 /* put empty packet */
2377 buf[0] = '\0';
2378 put_packet(s, buf);
2379 break;
2380 }
2381 return RS_IDLE;
2382 }
2383
2384 void gdb_set_stop_cpu(CPUState *env)
2385 {
2386 gdbserver_state->c_cpu = env;
2387 gdbserver_state->g_cpu = env;
2388 }
2389
2390 #ifndef CONFIG_USER_ONLY
2391 static void gdb_vm_state_change(void *opaque, int running, RunState state)
2392 {
2393 GDBState *s = gdbserver_state;
2394 CPUState *env = s->c_cpu;
2395 char buf[256];
2396 const char *type;
2397 int ret;
2398
2399 if (running || s->state == RS_INACTIVE || s->state == RS_SYSCALL) {
2400 return;
2401 }
2402 switch (state) {
2403 case RUN_STATE_DEBUG:
2404 if (env->watchpoint_hit) {
2405 switch (env->watchpoint_hit->flags & BP_MEM_ACCESS) {
2406 case BP_MEM_READ:
2407 type = "r";
2408 break;
2409 case BP_MEM_ACCESS:
2410 type = "a";
2411 break;
2412 default:
2413 type = "";
2414 break;
2415 }
2416 snprintf(buf, sizeof(buf),
2417 "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
2418 GDB_SIGNAL_TRAP, gdb_id(env), type,
2419 env->watchpoint_hit->vaddr);
2420 env->watchpoint_hit = NULL;
2421 goto send_packet;
2422 }
2423 tb_flush(env);
2424 ret = GDB_SIGNAL_TRAP;
2425 break;
2426 case RUN_STATE_PAUSED:
2427 ret = GDB_SIGNAL_INT;
2428 break;
2429 case RUN_STATE_SHUTDOWN:
2430 ret = GDB_SIGNAL_QUIT;
2431 break;
2432 case RUN_STATE_IO_ERROR:
2433 ret = GDB_SIGNAL_IO;
2434 break;
2435 case RUN_STATE_WATCHDOG:
2436 ret = GDB_SIGNAL_ALRM;
2437 break;
2438 case RUN_STATE_INTERNAL_ERROR:
2439 ret = GDB_SIGNAL_ABRT;
2440 break;
2441 case RUN_STATE_SAVE_VM:
2442 case RUN_STATE_RESTORE_VM:
2443 return;
2444 case RUN_STATE_FINISH_MIGRATE:
2445 ret = GDB_SIGNAL_XCPU;
2446 break;
2447 default:
2448 ret = GDB_SIGNAL_UNKNOWN;
2449 break;
2450 }
2451 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, gdb_id(env));
2452
2453 send_packet:
2454 put_packet(s, buf);
2455
2456 /* disable single step if it was enabled */
2457 cpu_single_step(env, 0);
2458 }
2459 #endif
2460
2461 /* Send a gdb syscall request.
2462 This accepts limited printf-style format specifiers, specifically:
2463 %x - target_ulong argument printed in hex.
2464 %lx - 64-bit argument printed in hex.
2465 %s - string pointer (target_ulong) and length (int) pair. */
2466 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
2467 {
2468 va_list va;
2469 char buf[256];
2470 char *p;
2471 target_ulong addr;
2472 uint64_t i64;
2473 GDBState *s;
2474
2475 s = gdbserver_state;
2476 if (!s)
2477 return;
2478 gdb_current_syscall_cb = cb;
2479 s->state = RS_SYSCALL;
2480 #ifndef CONFIG_USER_ONLY
2481 vm_stop(RUN_STATE_DEBUG);
2482 #endif
2483 s->state = RS_IDLE;
2484 va_start(va, fmt);
2485 p = buf;
2486 *(p++) = 'F';
2487 while (*fmt) {
2488 if (*fmt == '%') {
2489 fmt++;
2490 switch (*fmt++) {
2491 case 'x':
2492 addr = va_arg(va, target_ulong);
2493 p += snprintf(p, &buf[sizeof(buf)] - p, TARGET_FMT_lx, addr);
2494 break;
2495 case 'l':
2496 if (*(fmt++) != 'x')
2497 goto bad_format;
2498 i64 = va_arg(va, uint64_t);
2499 p += snprintf(p, &buf[sizeof(buf)] - p, "%" PRIx64, i64);
2500 break;
2501 case 's':
2502 addr = va_arg(va, target_ulong);
2503 p += snprintf(p, &buf[sizeof(buf)] - p, TARGET_FMT_lx "/%x",
2504 addr, va_arg(va, int));
2505 break;
2506 default:
2507 bad_format:
2508 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
2509 fmt - 1);
2510 break;
2511 }
2512 } else {
2513 *(p++) = *(fmt++);
2514 }
2515 }
2516 *p = 0;
2517 va_end(va);
2518 put_packet(s, buf);
2519 #ifdef CONFIG_USER_ONLY
2520 gdb_handlesig(s->c_cpu, 0);
2521 #else
2522 cpu_exit(s->c_cpu);
2523 #endif
2524 }
2525
2526 static void gdb_read_byte(GDBState *s, int ch)
2527 {
2528 int i, csum;
2529 uint8_t reply;
2530
2531 #ifndef CONFIG_USER_ONLY
2532 if (s->last_packet_len) {
2533 /* Waiting for a response to the last packet. If we see the start
2534 of a new command then abandon the previous response. */
2535 if (ch == '-') {
2536 #ifdef DEBUG_GDB
2537 printf("Got NACK, retransmitting\n");
2538 #endif
2539 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
2540 }
2541 #ifdef DEBUG_GDB
2542 else if (ch == '+')
2543 printf("Got ACK\n");
2544 else
2545 printf("Got '%c' when expecting ACK/NACK\n", ch);
2546 #endif
2547 if (ch == '+' || ch == '$')
2548 s->last_packet_len = 0;
2549 if (ch != '$')
2550 return;
2551 }
2552 if (runstate_is_running()) {
2553 /* when the CPU is running, we cannot do anything except stop
2554 it when receiving a char */
2555 vm_stop(RUN_STATE_PAUSED);
2556 } else
2557 #endif
2558 {
2559 switch(s->state) {
2560 case RS_IDLE:
2561 if (ch == '$') {
2562 s->line_buf_index = 0;
2563 s->state = RS_GETLINE;
2564 }
2565 break;
2566 case RS_GETLINE:
2567 if (ch == '#') {
2568 s->state = RS_CHKSUM1;
2569 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2570 s->state = RS_IDLE;
2571 } else {
2572 s->line_buf[s->line_buf_index++] = ch;
2573 }
2574 break;
2575 case RS_CHKSUM1:
2576 s->line_buf[s->line_buf_index] = '\0';
2577 s->line_csum = fromhex(ch) << 4;
2578 s->state = RS_CHKSUM2;
2579 break;
2580 case RS_CHKSUM2:
2581 s->line_csum |= fromhex(ch);
2582 csum = 0;
2583 for(i = 0; i < s->line_buf_index; i++) {
2584 csum += s->line_buf[i];
2585 }
2586 if (s->line_csum != (csum & 0xff)) {
2587 reply = '-';
2588 put_buffer(s, &reply, 1);
2589 s->state = RS_IDLE;
2590 } else {
2591 reply = '+';
2592 put_buffer(s, &reply, 1);
2593 s->state = gdb_handle_packet(s, s->line_buf);
2594 }
2595 break;
2596 default:
2597 abort();
2598 }
2599 }
2600 }
2601
2602 /* Tell the remote gdb that the process has exited. */
2603 void gdb_exit(CPUState *env, int code)
2604 {
2605 GDBState *s;
2606 char buf[4];
2607
2608 s = gdbserver_state;
2609 if (!s) {
2610 return;
2611 }
2612 #ifdef CONFIG_USER_ONLY
2613 if (gdbserver_fd < 0 || s->fd < 0) {
2614 return;
2615 }
2616 #endif
2617
2618 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
2619 put_packet(s, buf);
2620
2621 #ifndef CONFIG_USER_ONLY
2622 if (s->chr) {
2623 qemu_chr_delete(s->chr);
2624 }
2625 #endif
2626 }
2627
2628 #ifdef CONFIG_USER_ONLY
2629 int
2630 gdb_queuesig (void)
2631 {
2632 GDBState *s;
2633
2634 s = gdbserver_state;
2635
2636 if (gdbserver_fd < 0 || s->fd < 0)
2637 return 0;
2638 else
2639 return 1;
2640 }
2641
2642 int
2643 gdb_handlesig (CPUState *env, int sig)
2644 {
2645 GDBState *s;
2646 char buf[256];
2647 int n;
2648
2649 s = gdbserver_state;
2650 if (gdbserver_fd < 0 || s->fd < 0)
2651 return sig;
2652
2653 /* disable single step if it was enabled */
2654 cpu_single_step(env, 0);
2655 tb_flush(env);
2656
2657 if (sig != 0)
2658 {
2659 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb (sig));
2660 put_packet(s, buf);
2661 }
2662 /* put_packet() might have detected that the peer terminated the
2663 connection. */
2664 if (s->fd < 0)
2665 return sig;
2666
2667 sig = 0;
2668 s->state = RS_IDLE;
2669 s->running_state = 0;
2670 while (s->running_state == 0) {
2671 n = read (s->fd, buf, 256);
2672 if (n > 0)
2673 {
2674 int i;
2675
2676 for (i = 0; i < n; i++)
2677 gdb_read_byte (s, buf[i]);
2678 }
2679 else if (n == 0 || errno != EAGAIN)
2680 {
2681 /* XXX: Connection closed. Should probably wait for another
2682 connection before continuing. */
2683 return sig;
2684 }
2685 }
2686 sig = s->signal;
2687 s->signal = 0;
2688 return sig;
2689 }
2690
2691 /* Tell the remote gdb that the process has exited due to SIG. */
2692 void gdb_signalled(CPUState *env, int sig)
2693 {
2694 GDBState *s;
2695 char buf[4];
2696
2697 s = gdbserver_state;
2698 if (gdbserver_fd < 0 || s->fd < 0)
2699 return;
2700
2701 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb (sig));
2702 put_packet(s, buf);
2703 }
2704
2705 static void gdb_accept(void)
2706 {
2707 GDBState *s;
2708 struct sockaddr_in sockaddr;
2709 socklen_t len;
2710 int val, fd;
2711
2712 for(;;) {
2713 len = sizeof(sockaddr);
2714 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
2715 if (fd < 0 && errno != EINTR) {
2716 perror("accept");
2717 return;
2718 } else if (fd >= 0) {
2719 #ifndef _WIN32
2720 fcntl(fd, F_SETFD, FD_CLOEXEC);
2721 #endif
2722 break;
2723 }
2724 }
2725
2726 /* set short latency */
2727 val = 1;
2728 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
2729
2730 s = g_malloc0(sizeof(GDBState));
2731 s->c_cpu = first_cpu;
2732 s->g_cpu = first_cpu;
2733 s->fd = fd;
2734 gdb_has_xml = 0;
2735
2736 gdbserver_state = s;
2737
2738 fcntl(fd, F_SETFL, O_NONBLOCK);
2739 }
2740
2741 static int gdbserver_open(int port)
2742 {
2743 struct sockaddr_in sockaddr;
2744 int fd, val, ret;
2745
2746 fd = socket(PF_INET, SOCK_STREAM, 0);
2747 if (fd < 0) {
2748 perror("socket");
2749 return -1;
2750 }
2751 #ifndef _WIN32
2752 fcntl(fd, F_SETFD, FD_CLOEXEC);
2753 #endif
2754
2755 /* allow fast reuse */
2756 val = 1;
2757 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
2758
2759 sockaddr.sin_family = AF_INET;
2760 sockaddr.sin_port = htons(port);
2761 sockaddr.sin_addr.s_addr = 0;
2762 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
2763 if (ret < 0) {
2764 perror("bind");
2765 close(fd);
2766 return -1;
2767 }
2768 ret = listen(fd, 0);
2769 if (ret < 0) {
2770 perror("listen");
2771 close(fd);
2772 return -1;
2773 }
2774 return fd;
2775 }
2776
2777 int gdbserver_start(int port)
2778 {
2779 gdbserver_fd = gdbserver_open(port);
2780 if (gdbserver_fd < 0)
2781 return -1;
2782 /* accept connections */
2783 gdb_accept();
2784 return 0;
2785 }
2786
2787 /* Disable gdb stub for child processes. */
2788 void gdbserver_fork(CPUState *env)
2789 {
2790 GDBState *s = gdbserver_state;
2791 if (gdbserver_fd < 0 || s->fd < 0)
2792 return;
2793 close(s->fd);
2794 s->fd = -1;
2795 cpu_breakpoint_remove_all(env, BP_GDB);
2796 cpu_watchpoint_remove_all(env, BP_GDB);
2797 }
2798 #else
2799 static int gdb_chr_can_receive(void *opaque)
2800 {
2801 /* We can handle an arbitrarily large amount of data.
2802 Pick the maximum packet size, which is as good as anything. */
2803 return MAX_PACKET_LENGTH;
2804 }
2805
2806 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
2807 {
2808 int i;
2809
2810 for (i = 0; i < size; i++) {
2811 gdb_read_byte(gdbserver_state, buf[i]);
2812 }
2813 }
2814
2815 static void gdb_chr_event(void *opaque, int event)
2816 {
2817 switch (event) {
2818 case CHR_EVENT_OPENED:
2819 vm_stop(RUN_STATE_PAUSED);
2820 gdb_has_xml = 0;
2821 break;
2822 default:
2823 break;
2824 }
2825 }
2826
2827 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
2828 {
2829 char buf[MAX_PACKET_LENGTH];
2830
2831 buf[0] = 'O';
2832 if (len > (MAX_PACKET_LENGTH/2) - 1)
2833 len = (MAX_PACKET_LENGTH/2) - 1;
2834 memtohex(buf + 1, (uint8_t *)msg, len);
2835 put_packet(s, buf);
2836 }
2837
2838 static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
2839 {
2840 const char *p = (const char *)buf;
2841 int max_sz;
2842
2843 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
2844 for (;;) {
2845 if (len <= max_sz) {
2846 gdb_monitor_output(gdbserver_state, p, len);
2847 break;
2848 }
2849 gdb_monitor_output(gdbserver_state, p, max_sz);
2850 p += max_sz;
2851 len -= max_sz;
2852 }
2853 return len;
2854 }
2855
2856 #ifndef _WIN32
2857 static void gdb_sigterm_handler(int signal)
2858 {
2859 if (runstate_is_running()) {
2860 vm_stop(RUN_STATE_PAUSED);
2861 }
2862 }
2863 #endif
2864
2865 int gdbserver_start(const char *device)
2866 {
2867 GDBState *s;
2868 char gdbstub_device_name[128];
2869 CharDriverState *chr = NULL;
2870 CharDriverState *mon_chr;
2871
2872 if (!device)
2873 return -1;
2874 if (strcmp(device, "none") != 0) {
2875 if (strstart(device, "tcp:", NULL)) {
2876 /* enforce required TCP attributes */
2877 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
2878 "%s,nowait,nodelay,server", device);
2879 device = gdbstub_device_name;
2880 }
2881 #ifndef _WIN32
2882 else if (strcmp(device, "stdio") == 0) {
2883 struct sigaction act;
2884
2885 memset(&act, 0, sizeof(act));
2886 act.sa_handler = gdb_sigterm_handler;
2887 sigaction(SIGINT, &act, NULL);
2888 }
2889 #endif
2890 chr = qemu_chr_new("gdb", device, NULL);
2891 if (!chr)
2892 return -1;
2893
2894 qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
2895 gdb_chr_event, NULL);
2896 }
2897
2898 s = gdbserver_state;
2899 if (!s) {
2900 s = g_malloc0(sizeof(GDBState));
2901 gdbserver_state = s;
2902
2903 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
2904
2905 /* Initialize a monitor terminal for gdb */
2906 mon_chr = g_malloc0(sizeof(*mon_chr));
2907 mon_chr->chr_write = gdb_monitor_write;
2908 monitor_init(mon_chr, 0);
2909 } else {
2910 if (s->chr)
2911 qemu_chr_delete(s->chr);
2912 mon_chr = s->mon_chr;
2913 memset(s, 0, sizeof(GDBState));
2914 }
2915 s->c_cpu = first_cpu;
2916 s->g_cpu = first_cpu;
2917 s->chr = chr;
2918 s->state = chr ? RS_IDLE : RS_INACTIVE;
2919 s->mon_chr = mon_chr;
2920
2921 return 0;
2922 }
2923 #endif