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