?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bswap: improve gluing
[qemu/opensuse.git] / gdbstub.c
blob6cd26f161939870305f1076e242087336278e140
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/monitor.h"
33 #include "char/char.h"
34 #include "sysemu/sysemu.h"
35 #include "exec/gdbstub.h"
36 #endif
37
38 #define MAX_PACKET_LENGTH 4096
39
40 #include "cpu.h"
41 #include "qemu/sockets.h"
42 #include "sysemu/kvm.h"
43 #include "qemu/bitops.h"
44
45 #ifndef TARGET_CPU_MEMORY_RW_DEBUG
46 static inline int target_memory_rw_debug(CPUArchState *env, target_ulong addr,
47 uint8_t *buf, int len, int is_write)
48 {
49 return cpu_memory_rw_debug(env, addr, buf, len, is_write);
50 }
51 #else
52 /* target_memory_rw_debug() defined in cpu.h */
53 #endif
54
55 enum {
56 GDB_SIGNAL_0 = 0,
57 GDB_SIGNAL_INT = 2,
58 GDB_SIGNAL_QUIT = 3,
59 GDB_SIGNAL_TRAP = 5,
60 GDB_SIGNAL_ABRT = 6,
61 GDB_SIGNAL_ALRM = 14,
62 GDB_SIGNAL_IO = 23,
63 GDB_SIGNAL_XCPU = 24,
64 GDB_SIGNAL_UNKNOWN = 143
65 };
66
67 #ifdef CONFIG_USER_ONLY
68
69 /* Map target signal numbers to GDB protocol signal numbers and vice
70 * versa. For user emulation's currently supported systems, we can
71 * assume most signals are defined.
72 */
73
74 static int gdb_signal_table[] = {
75 0,
76 TARGET_SIGHUP,
77 TARGET_SIGINT,
78 TARGET_SIGQUIT,
79 TARGET_SIGILL,
80 TARGET_SIGTRAP,
81 TARGET_SIGABRT,
82 -1, /* SIGEMT */
83 TARGET_SIGFPE,
84 TARGET_SIGKILL,
85 TARGET_SIGBUS,
86 TARGET_SIGSEGV,
87 TARGET_SIGSYS,
88 TARGET_SIGPIPE,
89 TARGET_SIGALRM,
90 TARGET_SIGTERM,
91 TARGET_SIGURG,
92 TARGET_SIGSTOP,
93 TARGET_SIGTSTP,
94 TARGET_SIGCONT,
95 TARGET_SIGCHLD,
96 TARGET_SIGTTIN,
97 TARGET_SIGTTOU,
98 TARGET_SIGIO,
99 TARGET_SIGXCPU,
100 TARGET_SIGXFSZ,
101 TARGET_SIGVTALRM,
102 TARGET_SIGPROF,
103 TARGET_SIGWINCH,
104 -1, /* SIGLOST */
105 TARGET_SIGUSR1,
106 TARGET_SIGUSR2,
107 #ifdef TARGET_SIGPWR
108 TARGET_SIGPWR,
109 #else
110 -1,
111 #endif
112 -1, /* SIGPOLL */
113 -1,
114 -1,
115 -1,
116 -1,
117 -1,
118 -1,
119 -1,
120 -1,
121 -1,
122 -1,
123 -1,
124 #ifdef __SIGRTMIN
125 __SIGRTMIN + 1,
126 __SIGRTMIN + 2,
127 __SIGRTMIN + 3,
128 __SIGRTMIN + 4,
129 __SIGRTMIN + 5,
130 __SIGRTMIN + 6,
131 __SIGRTMIN + 7,
132 __SIGRTMIN + 8,
133 __SIGRTMIN + 9,
134 __SIGRTMIN + 10,
135 __SIGRTMIN + 11,
136 __SIGRTMIN + 12,
137 __SIGRTMIN + 13,
138 __SIGRTMIN + 14,
139 __SIGRTMIN + 15,
140 __SIGRTMIN + 16,
141 __SIGRTMIN + 17,
142 __SIGRTMIN + 18,
143 __SIGRTMIN + 19,
144 __SIGRTMIN + 20,
145 __SIGRTMIN + 21,
146 __SIGRTMIN + 22,
147 __SIGRTMIN + 23,
148 __SIGRTMIN + 24,
149 __SIGRTMIN + 25,
150 __SIGRTMIN + 26,
151 __SIGRTMIN + 27,
152 __SIGRTMIN + 28,
153 __SIGRTMIN + 29,
154 __SIGRTMIN + 30,
155 __SIGRTMIN + 31,
156 -1, /* SIGCANCEL */
157 __SIGRTMIN,
158 __SIGRTMIN + 32,
159 __SIGRTMIN + 33,
160 __SIGRTMIN + 34,
161 __SIGRTMIN + 35,
162 __SIGRTMIN + 36,
163 __SIGRTMIN + 37,
164 __SIGRTMIN + 38,
165 __SIGRTMIN + 39,
166 __SIGRTMIN + 40,
167 __SIGRTMIN + 41,
168 __SIGRTMIN + 42,
169 __SIGRTMIN + 43,
170 __SIGRTMIN + 44,
171 __SIGRTMIN + 45,
172 __SIGRTMIN + 46,
173 __SIGRTMIN + 47,
174 __SIGRTMIN + 48,
175 __SIGRTMIN + 49,
176 __SIGRTMIN + 50,
177 __SIGRTMIN + 51,
178 __SIGRTMIN + 52,
179 __SIGRTMIN + 53,
180 __SIGRTMIN + 54,
181 __SIGRTMIN + 55,
182 __SIGRTMIN + 56,
183 __SIGRTMIN + 57,
184 __SIGRTMIN + 58,
185 __SIGRTMIN + 59,
186 __SIGRTMIN + 60,
187 __SIGRTMIN + 61,
188 __SIGRTMIN + 62,
189 __SIGRTMIN + 63,
190 __SIGRTMIN + 64,
191 __SIGRTMIN + 65,
192 __SIGRTMIN + 66,
193 __SIGRTMIN + 67,
194 __SIGRTMIN + 68,
195 __SIGRTMIN + 69,
196 __SIGRTMIN + 70,
197 __SIGRTMIN + 71,
198 __SIGRTMIN + 72,
199 __SIGRTMIN + 73,
200 __SIGRTMIN + 74,
201 __SIGRTMIN + 75,
202 __SIGRTMIN + 76,
203 __SIGRTMIN + 77,
204 __SIGRTMIN + 78,
205 __SIGRTMIN + 79,
206 __SIGRTMIN + 80,
207 __SIGRTMIN + 81,
208 __SIGRTMIN + 82,
209 __SIGRTMIN + 83,
210 __SIGRTMIN + 84,
211 __SIGRTMIN + 85,
212 __SIGRTMIN + 86,
213 __SIGRTMIN + 87,
214 __SIGRTMIN + 88,
215 __SIGRTMIN + 89,
216 __SIGRTMIN + 90,
217 __SIGRTMIN + 91,
218 __SIGRTMIN + 92,
219 __SIGRTMIN + 93,
220 __SIGRTMIN + 94,
221 __SIGRTMIN + 95,
222 -1, /* SIGINFO */
223 -1, /* UNKNOWN */
224 -1, /* DEFAULT */
225 -1,
226 -1,
227 -1,
228 -1,
229 -1,
230 -1
231 #endif
232 };
233 #else
234 /* In system mode we only need SIGINT and SIGTRAP; other signals
235 are not yet supported. */
236
237 enum {
238 TARGET_SIGINT = 2,
239 TARGET_SIGTRAP = 5
240 };
241
242 static int gdb_signal_table[] = {
243 -1,
244 -1,
245 TARGET_SIGINT,
246 -1,
247 -1,
248 TARGET_SIGTRAP
249 };
250 #endif
251
252 #ifdef CONFIG_USER_ONLY
253 static int target_signal_to_gdb (int sig)
254 {
255 int i;
256 for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
257 if (gdb_signal_table[i] == sig)
258 return i;
259 return GDB_SIGNAL_UNKNOWN;
260 }
261 #endif
262
263 static int gdb_signal_to_target (int sig)
264 {
265 if (sig < ARRAY_SIZE (gdb_signal_table))
266 return gdb_signal_table[sig];
267 else
268 return -1;
269 }
270
271 //#define DEBUG_GDB
272
273 typedef struct GDBRegisterState {
274 int base_reg;
275 int num_regs;
276 gdb_reg_cb get_reg;
277 gdb_reg_cb set_reg;
278 const char *xml;
279 struct GDBRegisterState *next;
280 } GDBRegisterState;
281
282 enum RSState {
283 RS_INACTIVE,
284 RS_IDLE,
285 RS_GETLINE,
286 RS_CHKSUM1,
287 RS_CHKSUM2,
288 };
289 typedef struct GDBState {
290 CPUArchState *c_cpu; /* current CPU for step/continue ops */
291 CPUArchState *g_cpu; /* current CPU for other ops */
292 CPUArchState *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 char syscall_buf[256];
308 gdb_syscall_complete_cb current_syscall_cb;
309 } GDBState;
310
311 /* By default use no IRQs and no timers while single stepping so as to
312 * make single stepping like an ICE HW step.
313 */
314 static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
315
316 static GDBState *gdbserver_state;
317
318 /* This is an ugly hack to cope with both new and old gdb.
319 If gdb sends qXfer:features:read then assume we're talking to a newish
320 gdb that understands target descriptions. */
321 static int gdb_has_xml;
322
323 #ifdef CONFIG_USER_ONLY
324 /* XXX: This is not thread safe. Do we care? */
325 static int gdbserver_fd = -1;
326
327 static int get_char(GDBState *s)
328 {
329 uint8_t ch;
330 int ret;
331
332 for(;;) {
333 ret = qemu_recv(s->fd, &ch, 1, 0);
334 if (ret < 0) {
335 if (errno == ECONNRESET)
336 s->fd = -1;
337 if (errno != EINTR && errno != EAGAIN)
338 return -1;
339 } else if (ret == 0) {
340 close(s->fd);
341 s->fd = -1;
342 return -1;
343 } else {
344 break;
345 }
346 }
347 return ch;
348 }
349 #endif
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(CPUX86State *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(CPUX86State *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(CPUX86State *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(CPUPPCState *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(CPUPPCState *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(CPUSPARCState *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(CPUSPARCState *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(CPUARMState *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(CPUARMState *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(CPUM68KState *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(CPUM68KState *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(CPUMIPSState *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(CPUMIPSState *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_OPENRISC)
1160
1161 #define NUM_CORE_REGS (32 + 3)
1162
1163 static int cpu_gdb_read_register(CPUOpenRISCState *env, uint8_t *mem_buf, int n)
1164 {
1165 if (n < 32) {
1166 GET_REG32(env->gpr[n]);
1167 } else {
1168 switch (n) {
1169 case 32: /* PPC */
1170 GET_REG32(env->ppc);
1171 break;
1172
1173 case 33: /* NPC */
1174 GET_REG32(env->npc);
1175 break;
1176
1177 case 34: /* SR */
1178 GET_REG32(env->sr);
1179 break;
1180
1181 default:
1182 break;
1183 }
1184 }
1185 return 0;
1186 }
1187
1188 static int cpu_gdb_write_register(CPUOpenRISCState *env,
1189 uint8_t *mem_buf, int n)
1190 {
1191 uint32_t tmp;
1192
1193 if (n > NUM_CORE_REGS) {
1194 return 0;
1195 }
1196
1197 tmp = ldl_p(mem_buf);
1198
1199 if (n < 32) {
1200 env->gpr[n] = tmp;
1201 } else {
1202 switch (n) {
1203 case 32: /* PPC */
1204 env->ppc = tmp;
1205 break;
1206
1207 case 33: /* NPC */
1208 env->npc = tmp;
1209 break;
1210
1211 case 34: /* SR */
1212 env->sr = tmp;
1213 break;
1214
1215 default:
1216 break;
1217 }
1218 }
1219 return 4;
1220 }
1221 #elif defined (TARGET_SH4)
1222
1223 /* Hint: Use "set architecture sh4" in GDB to see fpu registers */
1224 /* FIXME: We should use XML for this. */
1225
1226 #define NUM_CORE_REGS 59
1227
1228 static int cpu_gdb_read_register(CPUSH4State *env, uint8_t *mem_buf, int n)
1229 {
1230 switch (n) {
1231 case 0 ... 7:
1232 if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
1233 GET_REGL(env->gregs[n + 16]);
1234 } else {
1235 GET_REGL(env->gregs[n]);
1236 }
1237 case 8 ... 15:
1238 GET_REGL(env->gregs[n]);
1239 case 16:
1240 GET_REGL(env->pc);
1241 case 17:
1242 GET_REGL(env->pr);
1243 case 18:
1244 GET_REGL(env->gbr);
1245 case 19:
1246 GET_REGL(env->vbr);
1247 case 20:
1248 GET_REGL(env->mach);
1249 case 21:
1250 GET_REGL(env->macl);
1251 case 22:
1252 GET_REGL(env->sr);
1253 case 23:
1254 GET_REGL(env->fpul);
1255 case 24:
1256 GET_REGL(env->fpscr);
1257 case 25 ... 40:
1258 if (env->fpscr & FPSCR_FR) {
1259 stfl_p(mem_buf, env->fregs[n - 9]);
1260 } else {
1261 stfl_p(mem_buf, env->fregs[n - 25]);
1262 }
1263 return 4;
1264 case 41:
1265 GET_REGL(env->ssr);
1266 case 42:
1267 GET_REGL(env->spc);
1268 case 43 ... 50:
1269 GET_REGL(env->gregs[n - 43]);
1270 case 51 ... 58:
1271 GET_REGL(env->gregs[n - (51 - 16)]);
1272 }
1273
1274 return 0;
1275 }
1276
1277 static int cpu_gdb_write_register(CPUSH4State *env, uint8_t *mem_buf, int n)
1278 {
1279 switch (n) {
1280 case 0 ... 7:
1281 if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
1282 env->gregs[n + 16] = ldl_p(mem_buf);
1283 } else {
1284 env->gregs[n] = ldl_p(mem_buf);
1285 }
1286 break;
1287 case 8 ... 15:
1288 env->gregs[n] = ldl_p(mem_buf);
1289 break;
1290 case 16:
1291 env->pc = ldl_p(mem_buf);
1292 break;
1293 case 17:
1294 env->pr = ldl_p(mem_buf);
1295 break;
1296 case 18:
1297 env->gbr = ldl_p(mem_buf);
1298 break;
1299 case 19:
1300 env->vbr = ldl_p(mem_buf);
1301 break;
1302 case 20:
1303 env->mach = ldl_p(mem_buf);
1304 break;
1305 case 21:
1306 env->macl = ldl_p(mem_buf);
1307 break;
1308 case 22:
1309 env->sr = ldl_p(mem_buf);
1310 break;
1311 case 23:
1312 env->fpul = ldl_p(mem_buf);
1313 break;
1314 case 24:
1315 env->fpscr = ldl_p(mem_buf);
1316 break;
1317 case 25 ... 40:
1318 if (env->fpscr & FPSCR_FR) {
1319 env->fregs[n - 9] = ldfl_p(mem_buf);
1320 } else {
1321 env->fregs[n - 25] = ldfl_p(mem_buf);
1322 }
1323 break;
1324 case 41:
1325 env->ssr = ldl_p(mem_buf);
1326 break;
1327 case 42:
1328 env->spc = ldl_p(mem_buf);
1329 break;
1330 case 43 ... 50:
1331 env->gregs[n - 43] = ldl_p(mem_buf);
1332 break;
1333 case 51 ... 58:
1334 env->gregs[n - (51 - 16)] = ldl_p(mem_buf);
1335 break;
1336 default: return 0;
1337 }
1338
1339 return 4;
1340 }
1341 #elif defined (TARGET_MICROBLAZE)
1342
1343 #define NUM_CORE_REGS (32 + 5)
1344
1345 static int cpu_gdb_read_register(CPUMBState *env, uint8_t *mem_buf, int n)
1346 {
1347 if (n < 32) {
1348 GET_REG32(env->regs[n]);
1349 } else {
1350 GET_REG32(env->sregs[n - 32]);
1351 }
1352 return 0;
1353 }
1354
1355 static int cpu_gdb_write_register(CPUMBState *env, uint8_t *mem_buf, int n)
1356 {
1357 uint32_t tmp;
1358
1359 if (n > NUM_CORE_REGS)
1360 return 0;
1361
1362 tmp = ldl_p(mem_buf);
1363
1364 if (n < 32) {
1365 env->regs[n] = tmp;
1366 } else {
1367 env->sregs[n - 32] = tmp;
1368 }
1369 return 4;
1370 }
1371 #elif defined (TARGET_CRIS)
1372
1373 #define NUM_CORE_REGS 49
1374
1375 static int
1376 read_register_crisv10(CPUCRISState *env, uint8_t *mem_buf, int n)
1377 {
1378 if (n < 15) {
1379 GET_REG32(env->regs[n]);
1380 }
1381
1382 if (n == 15) {
1383 GET_REG32(env->pc);
1384 }
1385
1386 if (n < 32) {
1387 switch (n) {
1388 case 16:
1389 GET_REG8(env->pregs[n - 16]);
1390 break;
1391 case 17:
1392 GET_REG8(env->pregs[n - 16]);
1393 break;
1394 case 20:
1395 case 21:
1396 GET_REG16(env->pregs[n - 16]);
1397 break;
1398 default:
1399 if (n >= 23) {
1400 GET_REG32(env->pregs[n - 16]);
1401 }
1402 break;
1403 }
1404 }
1405 return 0;
1406 }
1407
1408 static int cpu_gdb_read_register(CPUCRISState *env, uint8_t *mem_buf, int n)
1409 {
1410 uint8_t srs;
1411
1412 if (env->pregs[PR_VR] < 32)
1413 return read_register_crisv10(env, mem_buf, n);
1414
1415 srs = env->pregs[PR_SRS];
1416 if (n < 16) {
1417 GET_REG32(env->regs[n]);
1418 }
1419
1420 if (n >= 21 && n < 32) {
1421 GET_REG32(env->pregs[n - 16]);
1422 }
1423 if (n >= 33 && n < 49) {
1424 GET_REG32(env->sregs[srs][n - 33]);
1425 }
1426 switch (n) {
1427 case 16: GET_REG8(env->pregs[0]);
1428 case 17: GET_REG8(env->pregs[1]);
1429 case 18: GET_REG32(env->pregs[2]);
1430 case 19: GET_REG8(srs);
1431 case 20: GET_REG16(env->pregs[4]);
1432 case 32: GET_REG32(env->pc);
1433 }
1434
1435 return 0;
1436 }
1437
1438 static int cpu_gdb_write_register(CPUCRISState *env, uint8_t *mem_buf, int n)
1439 {
1440 uint32_t tmp;
1441
1442 if (n > 49)
1443 return 0;
1444
1445 tmp = ldl_p(mem_buf);
1446
1447 if (n < 16) {
1448 env->regs[n] = tmp;
1449 }
1450
1451 if (n >= 21 && n < 32) {
1452 env->pregs[n - 16] = tmp;
1453 }
1454
1455 /* FIXME: Should support function regs be writable? */
1456 switch (n) {
1457 case 16: return 1;
1458 case 17: return 1;
1459 case 18: env->pregs[PR_PID] = tmp; break;
1460 case 19: return 1;
1461 case 20: return 2;
1462 case 32: env->pc = tmp; break;
1463 }
1464
1465 return 4;
1466 }
1467 #elif defined (TARGET_ALPHA)
1468
1469 #define NUM_CORE_REGS 67
1470
1471 static int cpu_gdb_read_register(CPUAlphaState *env, uint8_t *mem_buf, int n)
1472 {
1473 uint64_t val;
1474 CPU_DoubleU d;
1475
1476 switch (n) {
1477 case 0 ... 30:
1478 val = env->ir[n];
1479 break;
1480 case 32 ... 62:
1481 d.d = env->fir[n - 32];
1482 val = d.ll;
1483 break;
1484 case 63:
1485 val = cpu_alpha_load_fpcr(env);
1486 break;
1487 case 64:
1488 val = env->pc;
1489 break;
1490 case 66:
1491 val = env->unique;
1492 break;
1493 case 31:
1494 case 65:
1495 /* 31 really is the zero register; 65 is unassigned in the
1496 gdb protocol, but is still required to occupy 8 bytes. */
1497 val = 0;
1498 break;
1499 default:
1500 return 0;
1501 }
1502 GET_REGL(val);
1503 }
1504
1505 static int cpu_gdb_write_register(CPUAlphaState *env, uint8_t *mem_buf, int n)
1506 {
1507 target_ulong tmp = ldtul_p(mem_buf);
1508 CPU_DoubleU d;
1509
1510 switch (n) {
1511 case 0 ... 30:
1512 env->ir[n] = tmp;
1513 break;
1514 case 32 ... 62:
1515 d.ll = tmp;
1516 env->fir[n - 32] = d.d;
1517 break;
1518 case 63:
1519 cpu_alpha_store_fpcr(env, tmp);
1520 break;
1521 case 64:
1522 env->pc = tmp;
1523 break;
1524 case 66:
1525 env->unique = tmp;
1526 break;
1527 case 31:
1528 case 65:
1529 /* 31 really is the zero register; 65 is unassigned in the
1530 gdb protocol, but is still required to occupy 8 bytes. */
1531 break;
1532 default:
1533 return 0;
1534 }
1535 return 8;
1536 }
1537 #elif defined (TARGET_S390X)
1538
1539 #define NUM_CORE_REGS S390_NUM_REGS
1540
1541 static int cpu_gdb_read_register(CPUS390XState *env, uint8_t *mem_buf, int n)
1542 {
1543 uint64_t val;
1544 int cc_op;
1545
1546 switch (n) {
1547 case S390_PSWM_REGNUM:
1548 cc_op = calc_cc(env, env->cc_op, env->cc_src, env->cc_dst, env->cc_vr);
1549 val = deposit64(env->psw.mask, 44, 2, cc_op);
1550 GET_REGL(val);
1551 break;
1552 case S390_PSWA_REGNUM:
1553 GET_REGL(env->psw.addr);
1554 break;
1555 case S390_R0_REGNUM ... S390_R15_REGNUM:
1556 GET_REGL(env->regs[n-S390_R0_REGNUM]);
1557 break;
1558 case S390_A0_REGNUM ... S390_A15_REGNUM:
1559 GET_REG32(env->aregs[n-S390_A0_REGNUM]);
1560 break;
1561 case S390_FPC_REGNUM:
1562 GET_REG32(env->fpc);
1563 break;
1564 case S390_F0_REGNUM ... S390_F15_REGNUM:
1565 GET_REG64(env->fregs[n-S390_F0_REGNUM].ll);
1566 break;
1567 }
1568
1569 return 0;
1570 }
1571
1572 static int cpu_gdb_write_register(CPUS390XState *env, uint8_t *mem_buf, int n)
1573 {
1574 target_ulong tmpl;
1575 uint32_t tmp32;
1576 int r = 8;
1577 tmpl = ldtul_p(mem_buf);
1578 tmp32 = ldl_p(mem_buf);
1579
1580 switch (n) {
1581 case S390_PSWM_REGNUM:
1582 env->psw.mask = tmpl;
1583 env->cc_op = extract64(tmpl, 44, 2);
1584 break;
1585 case S390_PSWA_REGNUM:
1586 env->psw.addr = tmpl;
1587 break;
1588 case S390_R0_REGNUM ... S390_R15_REGNUM:
1589 env->regs[n-S390_R0_REGNUM] = tmpl;
1590 break;
1591 case S390_A0_REGNUM ... S390_A15_REGNUM:
1592 env->aregs[n-S390_A0_REGNUM] = tmp32;
1593 r = 4;
1594 break;
1595 case S390_FPC_REGNUM:
1596 env->fpc = tmp32;
1597 r = 4;
1598 break;
1599 case S390_F0_REGNUM ... S390_F15_REGNUM:
1600 env->fregs[n-S390_F0_REGNUM].ll = tmpl;
1601 break;
1602 default:
1603 return 0;
1604 }
1605 return r;
1606 }
1607 #elif defined (TARGET_LM32)
1608
1609 #include "hw/lm32_pic.h"
1610 #define NUM_CORE_REGS (32 + 7)
1611
1612 static int cpu_gdb_read_register(CPULM32State *env, uint8_t *mem_buf, int n)
1613 {
1614 if (n < 32) {
1615 GET_REG32(env->regs[n]);
1616 } else {
1617 switch (n) {
1618 case 32:
1619 GET_REG32(env->pc);
1620 break;
1621 /* FIXME: put in right exception ID */
1622 case 33:
1623 GET_REG32(0);
1624 break;
1625 case 34:
1626 GET_REG32(env->eba);
1627 break;
1628 case 35:
1629 GET_REG32(env->deba);
1630 break;
1631 case 36:
1632 GET_REG32(env->ie);
1633 break;
1634 case 37:
1635 GET_REG32(lm32_pic_get_im(env->pic_state));
1636 break;
1637 case 38:
1638 GET_REG32(lm32_pic_get_ip(env->pic_state));
1639 break;
1640 }
1641 }
1642 return 0;
1643 }
1644
1645 static int cpu_gdb_write_register(CPULM32State *env, uint8_t *mem_buf, int n)
1646 {
1647 uint32_t tmp;
1648
1649 if (n > NUM_CORE_REGS) {
1650 return 0;
1651 }
1652
1653 tmp = ldl_p(mem_buf);
1654
1655 if (n < 32) {
1656 env->regs[n] = tmp;
1657 } else {
1658 switch (n) {
1659 case 32:
1660 env->pc = tmp;
1661 break;
1662 case 34:
1663 env->eba = tmp;
1664 break;
1665 case 35:
1666 env->deba = tmp;
1667 break;
1668 case 36:
1669 env->ie = tmp;
1670 break;
1671 case 37:
1672 lm32_pic_set_im(env->pic_state, tmp);
1673 break;
1674 case 38:
1675 lm32_pic_set_ip(env->pic_state, tmp);
1676 break;
1677 }
1678 }
1679 return 4;
1680 }
1681 #elif defined(TARGET_XTENSA)
1682
1683 /* Use num_core_regs to see only non-privileged registers in an unmodified gdb.
1684 * Use num_regs to see all registers. gdb modification is required for that:
1685 * reset bit 0 in the 'flags' field of the registers definitions in the
1686 * gdb/xtensa-config.c inside gdb source tree or inside gdb overlay.
1687 */
1688 #define NUM_CORE_REGS (env->config->gdb_regmap.num_regs)
1689 #define num_g_regs NUM_CORE_REGS
1690
1691 static int cpu_gdb_read_register(CPUXtensaState *env, uint8_t *mem_buf, int n)
1692 {
1693 const XtensaGdbReg *reg = env->config->gdb_regmap.reg + n;
1694
1695 if (n < 0 || n >= env->config->gdb_regmap.num_regs) {
1696 return 0;
1697 }
1698
1699 switch (reg->type) {
1700 case 9: /*pc*/
1701 GET_REG32(env->pc);
1702 break;
1703
1704 case 1: /*ar*/
1705 xtensa_sync_phys_from_window(env);
1706 GET_REG32(env->phys_regs[(reg->targno & 0xff) % env->config->nareg]);
1707 break;
1708
1709 case 2: /*SR*/
1710 GET_REG32(env->sregs[reg->targno & 0xff]);
1711 break;
1712
1713 case 3: /*UR*/
1714 GET_REG32(env->uregs[reg->targno & 0xff]);
1715 break;
1716
1717 case 4: /*f*/
1718 GET_REG32(float32_val(env->fregs[reg->targno & 0x0f]));
1719 break;
1720
1721 case 8: /*a*/
1722 GET_REG32(env->regs[reg->targno & 0x0f]);
1723 break;
1724
1725 default:
1726 qemu_log("%s from reg %d of unsupported type %d\n",
1727 __func__, n, reg->type);
1728 return 0;
1729 }
1730 }
1731
1732 static int cpu_gdb_write_register(CPUXtensaState *env, uint8_t *mem_buf, int n)
1733 {
1734 uint32_t tmp;
1735 const XtensaGdbReg *reg = env->config->gdb_regmap.reg + n;
1736
1737 if (n < 0 || n >= env->config->gdb_regmap.num_regs) {
1738 return 0;
1739 }
1740
1741 tmp = ldl_p(mem_buf);
1742
1743 switch (reg->type) {
1744 case 9: /*pc*/
1745 env->pc = tmp;
1746 break;
1747
1748 case 1: /*ar*/
1749 env->phys_regs[(reg->targno & 0xff) % env->config->nareg] = tmp;
1750 xtensa_sync_window_from_phys(env);
1751 break;
1752
1753 case 2: /*SR*/
1754 env->sregs[reg->targno & 0xff] = tmp;
1755 break;
1756
1757 case 3: /*UR*/
1758 env->uregs[reg->targno & 0xff] = tmp;
1759 break;
1760
1761 case 4: /*f*/
1762 env->fregs[reg->targno & 0x0f] = make_float32(tmp);
1763 break;
1764
1765 case 8: /*a*/
1766 env->regs[reg->targno & 0x0f] = tmp;
1767 break;
1768
1769 default:
1770 qemu_log("%s to reg %d of unsupported type %d\n",
1771 __func__, n, reg->type);
1772 return 0;
1773 }
1774
1775 return 4;
1776 }
1777 #else
1778
1779 #define NUM_CORE_REGS 0
1780
1781 static int cpu_gdb_read_register(CPUArchState *env, uint8_t *mem_buf, int n)
1782 {
1783 return 0;
1784 }
1785
1786 static int cpu_gdb_write_register(CPUArchState *env, uint8_t *mem_buf, int n)
1787 {
1788 return 0;
1789 }
1790
1791 #endif
1792
1793 #if !defined(TARGET_XTENSA)
1794 static int num_g_regs = NUM_CORE_REGS;
1795 #endif
1796
1797 #ifdef GDB_CORE_XML
1798 /* Encode data using the encoding for 'x' packets. */
1799 static int memtox(char *buf, const char *mem, int len)
1800 {
1801 char *p = buf;
1802 char c;
1803
1804 while (len--) {
1805 c = *(mem++);
1806 switch (c) {
1807 case '#': case '$': case '*': case '}':
1808 *(p++) = '}';
1809 *(p++) = c ^ 0x20;
1810 break;
1811 default:
1812 *(p++) = c;
1813 break;
1814 }
1815 }
1816 return p - buf;
1817 }
1818
1819 static const char *get_feature_xml(const char *p, const char **newp)
1820 {
1821 size_t len;
1822 int i;
1823 const char *name;
1824 static char target_xml[1024];
1825
1826 len = 0;
1827 while (p[len] && p[len] != ':')
1828 len++;
1829 *newp = p + len;
1830
1831 name = NULL;
1832 if (strncmp(p, "target.xml", len) == 0) {
1833 /* Generate the XML description for this CPU. */
1834 if (!target_xml[0]) {
1835 GDBRegisterState *r;
1836
1837 snprintf(target_xml, sizeof(target_xml),
1838 "<?xml version=\"1.0\"?>"
1839 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
1840 "<target>"
1841 "<xi:include href=\"%s\"/>",
1842 GDB_CORE_XML);
1843
1844 for (r = first_cpu->gdb_regs; r; r = r->next) {
1845 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
1846 pstrcat(target_xml, sizeof(target_xml), r->xml);
1847 pstrcat(target_xml, sizeof(target_xml), "\"/>");
1848 }
1849 pstrcat(target_xml, sizeof(target_xml), "</target>");
1850 }
1851 return target_xml;
1852 }
1853 for (i = 0; ; i++) {
1854 name = xml_builtin[i][0];
1855 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
1856 break;
1857 }
1858 return name ? xml_builtin[i][1] : NULL;
1859 }
1860 #endif
1861
1862 static int gdb_read_register(CPUArchState *env, uint8_t *mem_buf, int reg)
1863 {
1864 GDBRegisterState *r;
1865
1866 if (reg < NUM_CORE_REGS)
1867 return cpu_gdb_read_register(env, mem_buf, reg);
1868
1869 for (r = env->gdb_regs; r; r = r->next) {
1870 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
1871 return r->get_reg(env, mem_buf, reg - r->base_reg);
1872 }
1873 }
1874 return 0;
1875 }
1876
1877 static int gdb_write_register(CPUArchState *env, uint8_t *mem_buf, int reg)
1878 {
1879 GDBRegisterState *r;
1880
1881 if (reg < NUM_CORE_REGS)
1882 return cpu_gdb_write_register(env, mem_buf, reg);
1883
1884 for (r = env->gdb_regs; r; r = r->next) {
1885 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
1886 return r->set_reg(env, mem_buf, reg - r->base_reg);
1887 }
1888 }
1889 return 0;
1890 }
1891
1892 #if !defined(TARGET_XTENSA)
1893 /* Register a supplemental set of CPU registers. If g_pos is nonzero it
1894 specifies the first register number and these registers are included in
1895 a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
1896 gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
1897 */
1898
1899 void gdb_register_coprocessor(CPUArchState * env,
1900 gdb_reg_cb get_reg, gdb_reg_cb set_reg,
1901 int num_regs, const char *xml, int g_pos)
1902 {
1903 GDBRegisterState *s;
1904 GDBRegisterState **p;
1905 static int last_reg = NUM_CORE_REGS;
1906
1907 p = &env->gdb_regs;
1908 while (*p) {
1909 /* Check for duplicates. */
1910 if (strcmp((*p)->xml, xml) == 0)
1911 return;
1912 p = &(*p)->next;
1913 }
1914
1915 s = g_new0(GDBRegisterState, 1);
1916 s->base_reg = last_reg;
1917 s->num_regs = num_regs;
1918 s->get_reg = get_reg;
1919 s->set_reg = set_reg;
1920 s->xml = xml;
1921
1922 /* Add to end of list. */
1923 last_reg += num_regs;
1924 *p = s;
1925 if (g_pos) {
1926 if (g_pos != s->base_reg) {
1927 fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"
1928 "Expected %d got %d\n", xml, g_pos, s->base_reg);
1929 } else {
1930 num_g_regs = last_reg;
1931 }
1932 }
1933 }
1934 #endif
1935
1936 #ifndef CONFIG_USER_ONLY
1937 static const int xlat_gdb_type[] = {
1938 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
1939 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
1940 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
1941 };
1942 #endif
1943
1944 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
1945 {
1946 CPUArchState *env;
1947 int err = 0;
1948
1949 if (kvm_enabled())
1950 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
1951
1952 switch (type) {
1953 case GDB_BREAKPOINT_SW:
1954 case GDB_BREAKPOINT_HW:
1955 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1956 err = cpu_breakpoint_insert(env, addr, BP_GDB, NULL);
1957 if (err)
1958 break;
1959 }
1960 return err;
1961 #ifndef CONFIG_USER_ONLY
1962 case GDB_WATCHPOINT_WRITE:
1963 case GDB_WATCHPOINT_READ:
1964 case GDB_WATCHPOINT_ACCESS:
1965 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1966 err = cpu_watchpoint_insert(env, addr, len, xlat_gdb_type[type],
1967 NULL);
1968 if (err)
1969 break;
1970 }
1971 return err;
1972 #endif
1973 default:
1974 return -ENOSYS;
1975 }
1976 }
1977
1978 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
1979 {
1980 CPUArchState *env;
1981 int err = 0;
1982
1983 if (kvm_enabled())
1984 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
1985
1986 switch (type) {
1987 case GDB_BREAKPOINT_SW:
1988 case GDB_BREAKPOINT_HW:
1989 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1990 err = cpu_breakpoint_remove(env, addr, BP_GDB);
1991 if (err)
1992 break;
1993 }
1994 return err;
1995 #ifndef CONFIG_USER_ONLY
1996 case GDB_WATCHPOINT_WRITE:
1997 case GDB_WATCHPOINT_READ:
1998 case GDB_WATCHPOINT_ACCESS:
1999 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2000 err = cpu_watchpoint_remove(env, addr, len, xlat_gdb_type[type]);
2001 if (err)
2002 break;
2003 }
2004 return err;
2005 #endif
2006 default:
2007 return -ENOSYS;
2008 }
2009 }
2010
2011 static void gdb_breakpoint_remove_all(void)
2012 {
2013 CPUArchState *env;
2014
2015 if (kvm_enabled()) {
2016 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
2017 return;
2018 }
2019
2020 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2021 cpu_breakpoint_remove_all(env, BP_GDB);
2022 #ifndef CONFIG_USER_ONLY
2023 cpu_watchpoint_remove_all(env, BP_GDB);
2024 #endif
2025 }
2026 }
2027
2028 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
2029 {
2030 cpu_synchronize_state(s->c_cpu);
2031 #if defined(TARGET_I386)
2032 s->c_cpu->eip = pc;
2033 #elif defined (TARGET_PPC)
2034 s->c_cpu->nip = pc;
2035 #elif defined (TARGET_SPARC)
2036 s->c_cpu->pc = pc;
2037 s->c_cpu->npc = pc + 4;
2038 #elif defined (TARGET_ARM)
2039 s->c_cpu->regs[15] = pc;
2040 #elif defined (TARGET_SH4)
2041 s->c_cpu->pc = pc;
2042 #elif defined (TARGET_MIPS)
2043 s->c_cpu->active_tc.PC = pc & ~(target_ulong)1;
2044 if (pc & 1) {
2045 s->c_cpu->hflags |= MIPS_HFLAG_M16;
2046 } else {
2047 s->c_cpu->hflags &= ~(MIPS_HFLAG_M16);
2048 }
2049 #elif defined (TARGET_MICROBLAZE)
2050 s->c_cpu->sregs[SR_PC] = pc;
2051 #elif defined(TARGET_OPENRISC)
2052 s->c_cpu->pc = pc;
2053 #elif defined (TARGET_CRIS)
2054 s->c_cpu->pc = pc;
2055 #elif defined (TARGET_ALPHA)
2056 s->c_cpu->pc = pc;
2057 #elif defined (TARGET_S390X)
2058 s->c_cpu->psw.addr = pc;
2059 #elif defined (TARGET_LM32)
2060 s->c_cpu->pc = pc;
2061 #elif defined(TARGET_XTENSA)
2062 s->c_cpu->pc = pc;
2063 #endif
2064 }
2065
2066 static CPUArchState *find_cpu(uint32_t thread_id)
2067 {
2068 CPUArchState *env;
2069
2070 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2071 if (cpu_index(env) == thread_id) {
2072 return env;
2073 }
2074 }
2075
2076 return NULL;
2077 }
2078
2079 static int gdb_handle_packet(GDBState *s, const char *line_buf)
2080 {
2081 CPUArchState *env;
2082 const char *p;
2083 uint32_t thread;
2084 int ch, reg_size, type, res;
2085 char buf[MAX_PACKET_LENGTH];
2086 uint8_t mem_buf[MAX_PACKET_LENGTH];
2087 uint8_t *registers;
2088 target_ulong addr, len;
2089
2090 #ifdef DEBUG_GDB
2091 printf("command='%s'\n", line_buf);
2092 #endif
2093 p = line_buf;
2094 ch = *p++;
2095 switch(ch) {
2096 case '?':
2097 /* TODO: Make this return the correct value for user-mode. */
2098 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
2099 cpu_index(s->c_cpu));
2100 put_packet(s, buf);
2101 /* Remove all the breakpoints when this query is issued,
2102 * because gdb is doing and initial connect and the state
2103 * should be cleaned up.
2104 */
2105 gdb_breakpoint_remove_all();
2106 break;
2107 case 'c':
2108 if (*p != '\0') {
2109 addr = strtoull(p, (char **)&p, 16);
2110 gdb_set_cpu_pc(s, addr);
2111 }
2112 s->signal = 0;
2113 gdb_continue(s);
2114 return RS_IDLE;
2115 case 'C':
2116 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
2117 if (s->signal == -1)
2118 s->signal = 0;
2119 gdb_continue(s);
2120 return RS_IDLE;
2121 case 'v':
2122 if (strncmp(p, "Cont", 4) == 0) {
2123 int res_signal, res_thread;
2124
2125 p += 4;
2126 if (*p == '?') {
2127 put_packet(s, "vCont;c;C;s;S");
2128 break;
2129 }
2130 res = 0;
2131 res_signal = 0;
2132 res_thread = 0;
2133 while (*p) {
2134 int action, signal;
2135
2136 if (*p++ != ';') {
2137 res = 0;
2138 break;
2139 }
2140 action = *p++;
2141 signal = 0;
2142 if (action == 'C' || action == 'S') {
2143 signal = strtoul(p, (char **)&p, 16);
2144 } else if (action != 'c' && action != 's') {
2145 res = 0;
2146 break;
2147 }
2148 thread = 0;
2149 if (*p == ':') {
2150 thread = strtoull(p+1, (char **)&p, 16);
2151 }
2152 action = tolower(action);
2153 if (res == 0 || (res == 'c' && action == 's')) {
2154 res = action;
2155 res_signal = signal;
2156 res_thread = thread;
2157 }
2158 }
2159 if (res) {
2160 if (res_thread != -1 && res_thread != 0) {
2161 env = find_cpu(res_thread);
2162 if (env == NULL) {
2163 put_packet(s, "E22");
2164 break;
2165 }
2166 s->c_cpu = env;
2167 }
2168 if (res == 's') {
2169 cpu_single_step(s->c_cpu, sstep_flags);
2170 }
2171 s->signal = res_signal;
2172 gdb_continue(s);
2173 return RS_IDLE;
2174 }
2175 break;
2176 } else {
2177 goto unknown_command;
2178 }
2179 case 'k':
2180 #ifdef CONFIG_USER_ONLY
2181 /* Kill the target */
2182 fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
2183 exit(0);
2184 #endif
2185 case 'D':
2186 /* Detach packet */
2187 gdb_breakpoint_remove_all();
2188 gdb_syscall_mode = GDB_SYS_DISABLED;
2189 gdb_continue(s);
2190 put_packet(s, "OK");
2191 break;
2192 case 's':
2193 if (*p != '\0') {
2194 addr = strtoull(p, (char **)&p, 16);
2195 gdb_set_cpu_pc(s, addr);
2196 }
2197 cpu_single_step(s->c_cpu, sstep_flags);
2198 gdb_continue(s);
2199 return RS_IDLE;
2200 case 'F':
2201 {
2202 target_ulong ret;
2203 target_ulong err;
2204
2205 ret = strtoull(p, (char **)&p, 16);
2206 if (*p == ',') {
2207 p++;
2208 err = strtoull(p, (char **)&p, 16);
2209 } else {
2210 err = 0;
2211 }
2212 if (*p == ',')
2213 p++;
2214 type = *p;
2215 if (s->current_syscall_cb) {
2216 s->current_syscall_cb(s->c_cpu, ret, err);
2217 s->current_syscall_cb = NULL;
2218 }
2219 if (type == 'C') {
2220 put_packet(s, "T02");
2221 } else {
2222 gdb_continue(s);
2223 }
2224 }
2225 break;
2226 case 'g':
2227 cpu_synchronize_state(s->g_cpu);
2228 env = s->g_cpu;
2229 len = 0;
2230 for (addr = 0; addr < num_g_regs; addr++) {
2231 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
2232 len += reg_size;
2233 }
2234 memtohex(buf, mem_buf, len);
2235 put_packet(s, buf);
2236 break;
2237 case 'G':
2238 cpu_synchronize_state(s->g_cpu);
2239 env = s->g_cpu;
2240 registers = mem_buf;
2241 len = strlen(p) / 2;
2242 hextomem((uint8_t *)registers, p, len);
2243 for (addr = 0; addr < num_g_regs && len > 0; addr++) {
2244 reg_size = gdb_write_register(s->g_cpu, registers, addr);
2245 len -= reg_size;
2246 registers += reg_size;
2247 }
2248 put_packet(s, "OK");
2249 break;
2250 case 'm':
2251 addr = strtoull(p, (char **)&p, 16);
2252 if (*p == ',')
2253 p++;
2254 len = strtoull(p, NULL, 16);
2255 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, 0) != 0) {
2256 put_packet (s, "E14");
2257 } else {
2258 memtohex(buf, mem_buf, len);
2259 put_packet(s, buf);
2260 }
2261 break;
2262 case 'M':
2263 addr = strtoull(p, (char **)&p, 16);
2264 if (*p == ',')
2265 p++;
2266 len = strtoull(p, (char **)&p, 16);
2267 if (*p == ':')
2268 p++;
2269 hextomem(mem_buf, p, len);
2270 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, 1) != 0) {
2271 put_packet(s, "E14");
2272 } else {
2273 put_packet(s, "OK");
2274 }
2275 break;
2276 case 'p':
2277 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
2278 This works, but can be very slow. Anything new enough to
2279 understand XML also knows how to use this properly. */
2280 if (!gdb_has_xml)
2281 goto unknown_command;
2282 addr = strtoull(p, (char **)&p, 16);
2283 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
2284 if (reg_size) {
2285 memtohex(buf, mem_buf, reg_size);
2286 put_packet(s, buf);
2287 } else {
2288 put_packet(s, "E14");
2289 }
2290 break;
2291 case 'P':
2292 if (!gdb_has_xml)
2293 goto unknown_command;
2294 addr = strtoull(p, (char **)&p, 16);
2295 if (*p == '=')
2296 p++;
2297 reg_size = strlen(p) / 2;
2298 hextomem(mem_buf, p, reg_size);
2299 gdb_write_register(s->g_cpu, mem_buf, addr);
2300 put_packet(s, "OK");
2301 break;
2302 case 'Z':
2303 case 'z':
2304 type = strtoul(p, (char **)&p, 16);
2305 if (*p == ',')
2306 p++;
2307 addr = strtoull(p, (char **)&p, 16);
2308 if (*p == ',')
2309 p++;
2310 len = strtoull(p, (char **)&p, 16);
2311 if (ch == 'Z')
2312 res = gdb_breakpoint_insert(addr, len, type);
2313 else
2314 res = gdb_breakpoint_remove(addr, len, type);
2315 if (res >= 0)
2316 put_packet(s, "OK");
2317 else if (res == -ENOSYS)
2318 put_packet(s, "");
2319 else
2320 put_packet(s, "E22");
2321 break;
2322 case 'H':
2323 type = *p++;
2324 thread = strtoull(p, (char **)&p, 16);
2325 if (thread == -1 || thread == 0) {
2326 put_packet(s, "OK");
2327 break;
2328 }
2329 env = find_cpu(thread);
2330 if (env == NULL) {
2331 put_packet(s, "E22");
2332 break;
2333 }
2334 switch (type) {
2335 case 'c':
2336 s->c_cpu = env;
2337 put_packet(s, "OK");
2338 break;
2339 case 'g':
2340 s->g_cpu = env;
2341 put_packet(s, "OK");
2342 break;
2343 default:
2344 put_packet(s, "E22");
2345 break;
2346 }
2347 break;
2348 case 'T':
2349 thread = strtoull(p, (char **)&p, 16);
2350 env = find_cpu(thread);
2351
2352 if (env != NULL) {
2353 put_packet(s, "OK");
2354 } else {
2355 put_packet(s, "E22");
2356 }
2357 break;
2358 case 'q':
2359 case 'Q':
2360 /* parse any 'q' packets here */
2361 if (!strcmp(p,"qemu.sstepbits")) {
2362 /* Query Breakpoint bit definitions */
2363 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
2364 SSTEP_ENABLE,
2365 SSTEP_NOIRQ,
2366 SSTEP_NOTIMER);
2367 put_packet(s, buf);
2368 break;
2369 } else if (strncmp(p,"qemu.sstep",10) == 0) {
2370 /* Display or change the sstep_flags */
2371 p += 10;
2372 if (*p != '=') {
2373 /* Display current setting */
2374 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
2375 put_packet(s, buf);
2376 break;
2377 }
2378 p++;
2379 type = strtoul(p, (char **)&p, 16);
2380 sstep_flags = type;
2381 put_packet(s, "OK");
2382 break;
2383 } else if (strcmp(p,"C") == 0) {
2384 /* "Current thread" remains vague in the spec, so always return
2385 * the first CPU (gdb returns the first thread). */
2386 put_packet(s, "QC1");
2387 break;
2388 } else if (strcmp(p,"fThreadInfo") == 0) {
2389 s->query_cpu = first_cpu;
2390 goto report_cpuinfo;
2391 } else if (strcmp(p,"sThreadInfo") == 0) {
2392 report_cpuinfo:
2393 if (s->query_cpu) {
2394 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
2395 put_packet(s, buf);
2396 s->query_cpu = s->query_cpu->next_cpu;
2397 } else
2398 put_packet(s, "l");
2399 break;
2400 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
2401 thread = strtoull(p+16, (char **)&p, 16);
2402 env = find_cpu(thread);
2403 if (env != NULL) {
2404 CPUState *cpu = ENV_GET_CPU(env);
2405 cpu_synchronize_state(env);
2406 len = snprintf((char *)mem_buf, sizeof(mem_buf),
2407 "CPU#%d [%s]", cpu->cpu_index,
2408 env->halted ? "halted " : "running");
2409 memtohex(buf, mem_buf, len);
2410 put_packet(s, buf);
2411 }
2412 break;
2413 }
2414 #ifdef CONFIG_USER_ONLY
2415 else if (strncmp(p, "Offsets", 7) == 0) {
2416 TaskState *ts = s->c_cpu->opaque;
2417
2418 snprintf(buf, sizeof(buf),
2419 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
2420 ";Bss=" TARGET_ABI_FMT_lx,
2421 ts->info->code_offset,
2422 ts->info->data_offset,
2423 ts->info->data_offset);
2424 put_packet(s, buf);
2425 break;
2426 }
2427 #else /* !CONFIG_USER_ONLY */
2428 else if (strncmp(p, "Rcmd,", 5) == 0) {
2429 int len = strlen(p + 5);
2430
2431 if ((len % 2) != 0) {
2432 put_packet(s, "E01");
2433 break;
2434 }
2435 hextomem(mem_buf, p + 5, len);
2436 len = len / 2;
2437 mem_buf[len++] = 0;
2438 qemu_chr_be_write(s->mon_chr, mem_buf, len);
2439 put_packet(s, "OK");
2440 break;
2441 }
2442 #endif /* !CONFIG_USER_ONLY */
2443 if (strncmp(p, "Supported", 9) == 0) {
2444 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
2445 #ifdef GDB_CORE_XML
2446 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
2447 #endif
2448 put_packet(s, buf);
2449 break;
2450 }
2451 #ifdef GDB_CORE_XML
2452 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
2453 const char *xml;
2454 target_ulong total_len;
2455
2456 gdb_has_xml = 1;
2457 p += 19;
2458 xml = get_feature_xml(p, &p);
2459 if (!xml) {
2460 snprintf(buf, sizeof(buf), "E00");
2461 put_packet(s, buf);
2462 break;
2463 }
2464
2465 if (*p == ':')
2466 p++;
2467 addr = strtoul(p, (char **)&p, 16);
2468 if (*p == ',')
2469 p++;
2470 len = strtoul(p, (char **)&p, 16);
2471
2472 total_len = strlen(xml);
2473 if (addr > total_len) {
2474 snprintf(buf, sizeof(buf), "E00");
2475 put_packet(s, buf);
2476 break;
2477 }
2478 if (len > (MAX_PACKET_LENGTH - 5) / 2)
2479 len = (MAX_PACKET_LENGTH - 5) / 2;
2480 if (len < total_len - addr) {
2481 buf[0] = 'm';
2482 len = memtox(buf + 1, xml + addr, len);
2483 } else {
2484 buf[0] = 'l';
2485 len = memtox(buf + 1, xml + addr, total_len - addr);
2486 }
2487 put_packet_binary(s, buf, len + 1);
2488 break;
2489 }
2490 #endif
2491 /* Unrecognised 'q' command. */
2492 goto unknown_command;
2493
2494 default:
2495 unknown_command:
2496 /* put empty packet */
2497 buf[0] = '\0';
2498 put_packet(s, buf);
2499 break;
2500 }
2501 return RS_IDLE;
2502 }
2503
2504 void gdb_set_stop_cpu(CPUArchState *env)
2505 {
2506 gdbserver_state->c_cpu = env;
2507 gdbserver_state->g_cpu = env;
2508 }
2509
2510 #ifndef CONFIG_USER_ONLY
2511 static void gdb_vm_state_change(void *opaque, int running, RunState state)
2512 {
2513 GDBState *s = gdbserver_state;
2514 CPUArchState *env = s->c_cpu;
2515 char buf[256];
2516 const char *type;
2517 int ret;
2518
2519 if (running || s->state == RS_INACTIVE) {
2520 return;
2521 }
2522 /* Is there a GDB syscall waiting to be sent? */
2523 if (s->current_syscall_cb) {
2524 put_packet(s, s->syscall_buf);
2525 return;
2526 }
2527 switch (state) {
2528 case RUN_STATE_DEBUG:
2529 if (env->watchpoint_hit) {
2530 switch (env->watchpoint_hit->flags & BP_MEM_ACCESS) {
2531 case BP_MEM_READ:
2532 type = "r";
2533 break;
2534 case BP_MEM_ACCESS:
2535 type = "a";
2536 break;
2537 default:
2538 type = "";
2539 break;
2540 }
2541 snprintf(buf, sizeof(buf),
2542 "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
2543 GDB_SIGNAL_TRAP, cpu_index(env), type,
2544 env->watchpoint_hit->vaddr);
2545 env->watchpoint_hit = NULL;
2546 goto send_packet;
2547 }
2548 tb_flush(env);
2549 ret = GDB_SIGNAL_TRAP;
2550 break;
2551 case RUN_STATE_PAUSED:
2552 ret = GDB_SIGNAL_INT;
2553 break;
2554 case RUN_STATE_SHUTDOWN:
2555 ret = GDB_SIGNAL_QUIT;
2556 break;
2557 case RUN_STATE_IO_ERROR:
2558 ret = GDB_SIGNAL_IO;
2559 break;
2560 case RUN_STATE_WATCHDOG:
2561 ret = GDB_SIGNAL_ALRM;
2562 break;
2563 case RUN_STATE_INTERNAL_ERROR:
2564 ret = GDB_SIGNAL_ABRT;
2565 break;
2566 case RUN_STATE_SAVE_VM:
2567 case RUN_STATE_RESTORE_VM:
2568 return;
2569 case RUN_STATE_FINISH_MIGRATE:
2570 ret = GDB_SIGNAL_XCPU;
2571 break;
2572 default:
2573 ret = GDB_SIGNAL_UNKNOWN;
2574 break;
2575 }
2576 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(env));
2577
2578 send_packet:
2579 put_packet(s, buf);
2580
2581 /* disable single step if it was enabled */
2582 cpu_single_step(env, 0);
2583 }
2584 #endif
2585
2586 /* Send a gdb syscall request.
2587 This accepts limited printf-style format specifiers, specifically:
2588 %x - target_ulong argument printed in hex.
2589 %lx - 64-bit argument printed in hex.
2590 %s - string pointer (target_ulong) and length (int) pair. */
2591 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
2592 {
2593 va_list va;
2594 char *p;
2595 char *p_end;
2596 target_ulong addr;
2597 uint64_t i64;
2598 GDBState *s;
2599
2600 s = gdbserver_state;
2601 if (!s)
2602 return;
2603 s->current_syscall_cb = cb;
2604 #ifndef CONFIG_USER_ONLY
2605 vm_stop(RUN_STATE_DEBUG);
2606 #endif
2607 va_start(va, fmt);
2608 p = s->syscall_buf;
2609 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
2610 *(p++) = 'F';
2611 while (*fmt) {
2612 if (*fmt == '%') {
2613 fmt++;
2614 switch (*fmt++) {
2615 case 'x':
2616 addr = va_arg(va, target_ulong);
2617 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
2618 break;
2619 case 'l':
2620 if (*(fmt++) != 'x')
2621 goto bad_format;
2622 i64 = va_arg(va, uint64_t);
2623 p += snprintf(p, p_end - p, "%" PRIx64, i64);
2624 break;
2625 case 's':
2626 addr = va_arg(va, target_ulong);
2627 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
2628 addr, va_arg(va, int));
2629 break;
2630 default:
2631 bad_format:
2632 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
2633 fmt - 1);
2634 break;
2635 }
2636 } else {
2637 *(p++) = *(fmt++);
2638 }
2639 }
2640 *p = 0;
2641 va_end(va);
2642 #ifdef CONFIG_USER_ONLY
2643 put_packet(s, s->syscall_buf);
2644 gdb_handlesig(s->c_cpu, 0);
2645 #else
2646 /* In this case wait to send the syscall packet until notification that
2647 the CPU has stopped. This must be done because if the packet is sent
2648 now the reply from the syscall request could be received while the CPU
2649 is still in the running state, which can cause packets to be dropped
2650 and state transition 'T' packets to be sent while the syscall is still
2651 being processed. */
2652 cpu_exit(s->c_cpu);
2653 #endif
2654 }
2655
2656 static void gdb_read_byte(GDBState *s, int ch)
2657 {
2658 int i, csum;
2659 uint8_t reply;
2660
2661 #ifndef CONFIG_USER_ONLY
2662 if (s->last_packet_len) {
2663 /* Waiting for a response to the last packet. If we see the start
2664 of a new command then abandon the previous response. */
2665 if (ch == '-') {
2666 #ifdef DEBUG_GDB
2667 printf("Got NACK, retransmitting\n");
2668 #endif
2669 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
2670 }
2671 #ifdef DEBUG_GDB
2672 else if (ch == '+')
2673 printf("Got ACK\n");
2674 else
2675 printf("Got '%c' when expecting ACK/NACK\n", ch);
2676 #endif
2677 if (ch == '+' || ch == '$')
2678 s->last_packet_len = 0;
2679 if (ch != '$')
2680 return;
2681 }
2682 if (runstate_is_running()) {
2683 /* when the CPU is running, we cannot do anything except stop
2684 it when receiving a char */
2685 vm_stop(RUN_STATE_PAUSED);
2686 } else
2687 #endif
2688 {
2689 switch(s->state) {
2690 case RS_IDLE:
2691 if (ch == '$') {
2692 s->line_buf_index = 0;
2693 s->state = RS_GETLINE;
2694 }
2695 break;
2696 case RS_GETLINE:
2697 if (ch == '#') {
2698 s->state = RS_CHKSUM1;
2699 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2700 s->state = RS_IDLE;
2701 } else {
2702 s->line_buf[s->line_buf_index++] = ch;
2703 }
2704 break;
2705 case RS_CHKSUM1:
2706 s->line_buf[s->line_buf_index] = '\0';
2707 s->line_csum = fromhex(ch) << 4;
2708 s->state = RS_CHKSUM2;
2709 break;
2710 case RS_CHKSUM2:
2711 s->line_csum |= fromhex(ch);
2712 csum = 0;
2713 for(i = 0; i < s->line_buf_index; i++) {
2714 csum += s->line_buf[i];
2715 }
2716 if (s->line_csum != (csum & 0xff)) {
2717 reply = '-';
2718 put_buffer(s, &reply, 1);
2719 s->state = RS_IDLE;
2720 } else {
2721 reply = '+';
2722 put_buffer(s, &reply, 1);
2723 s->state = gdb_handle_packet(s, s->line_buf);
2724 }
2725 break;
2726 default:
2727 abort();
2728 }
2729 }
2730 }
2731
2732 /* Tell the remote gdb that the process has exited. */
2733 void gdb_exit(CPUArchState *env, int code)
2734 {
2735 GDBState *s;
2736 char buf[4];
2737
2738 s = gdbserver_state;
2739 if (!s) {
2740 return;
2741 }
2742 #ifdef CONFIG_USER_ONLY
2743 if (gdbserver_fd < 0 || s->fd < 0) {
2744 return;
2745 }
2746 #endif
2747
2748 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
2749 put_packet(s, buf);
2750
2751 #ifndef CONFIG_USER_ONLY
2752 if (s->chr) {
2753 qemu_chr_delete(s->chr);
2754 }
2755 #endif
2756 }
2757
2758 #ifdef CONFIG_USER_ONLY
2759 int
2760 gdb_queuesig (void)
2761 {
2762 GDBState *s;
2763
2764 s = gdbserver_state;
2765
2766 if (gdbserver_fd < 0 || s->fd < 0)
2767 return 0;
2768 else
2769 return 1;
2770 }
2771
2772 int
2773 gdb_handlesig (CPUArchState *env, int sig)
2774 {
2775 GDBState *s;
2776 char buf[256];
2777 int n;
2778
2779 s = gdbserver_state;
2780 if (gdbserver_fd < 0 || s->fd < 0)
2781 return sig;
2782
2783 /* disable single step if it was enabled */
2784 cpu_single_step(env, 0);
2785 tb_flush(env);
2786
2787 if (sig != 0)
2788 {
2789 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb (sig));
2790 put_packet(s, buf);
2791 }
2792 /* put_packet() might have detected that the peer terminated the
2793 connection. */
2794 if (s->fd < 0)
2795 return sig;
2796
2797 sig = 0;
2798 s->state = RS_IDLE;
2799 s->running_state = 0;
2800 while (s->running_state == 0) {
2801 n = read (s->fd, buf, 256);
2802 if (n > 0)
2803 {
2804 int i;
2805
2806 for (i = 0; i < n; i++)
2807 gdb_read_byte (s, buf[i]);
2808 }
2809 else if (n == 0 || errno != EAGAIN)
2810 {
2811 /* XXX: Connection closed. Should probably wait for another
2812 connection before continuing. */
2813 return sig;
2814 }
2815 }
2816 sig = s->signal;
2817 s->signal = 0;
2818 return sig;
2819 }
2820
2821 /* Tell the remote gdb that the process has exited due to SIG. */
2822 void gdb_signalled(CPUArchState *env, int sig)
2823 {
2824 GDBState *s;
2825 char buf[4];
2826
2827 s = gdbserver_state;
2828 if (gdbserver_fd < 0 || s->fd < 0)
2829 return;
2830
2831 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb (sig));
2832 put_packet(s, buf);
2833 }
2834
2835 static void gdb_accept(void)
2836 {
2837 GDBState *s;
2838 struct sockaddr_in sockaddr;
2839 socklen_t len;
2840 int val, fd;
2841
2842 for(;;) {
2843 len = sizeof(sockaddr);
2844 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
2845 if (fd < 0 && errno != EINTR) {
2846 perror("accept");
2847 return;
2848 } else if (fd >= 0) {
2849 #ifndef _WIN32
2850 fcntl(fd, F_SETFD, FD_CLOEXEC);
2851 #endif
2852 break;
2853 }
2854 }
2855
2856 /* set short latency */
2857 val = 1;
2858 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
2859
2860 s = g_malloc0(sizeof(GDBState));
2861 s->c_cpu = first_cpu;
2862 s->g_cpu = first_cpu;
2863 s->fd = fd;
2864 gdb_has_xml = 0;
2865
2866 gdbserver_state = s;
2867
2868 fcntl(fd, F_SETFL, O_NONBLOCK);
2869 }
2870
2871 static int gdbserver_open(int port)
2872 {
2873 struct sockaddr_in sockaddr;
2874 int fd, val, ret;
2875
2876 fd = socket(PF_INET, SOCK_STREAM, 0);
2877 if (fd < 0) {
2878 perror("socket");
2879 return -1;
2880 }
2881 #ifndef _WIN32
2882 fcntl(fd, F_SETFD, FD_CLOEXEC);
2883 #endif
2884
2885 /* allow fast reuse */
2886 val = 1;
2887 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
2888
2889 sockaddr.sin_family = AF_INET;
2890 sockaddr.sin_port = htons(port);
2891 sockaddr.sin_addr.s_addr = 0;
2892 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
2893 if (ret < 0) {
2894 perror("bind");
2895 close(fd);
2896 return -1;
2897 }
2898 ret = listen(fd, 0);
2899 if (ret < 0) {
2900 perror("listen");
2901 close(fd);
2902 return -1;
2903 }
2904 return fd;
2905 }
2906
2907 int gdbserver_start(int port)
2908 {
2909 gdbserver_fd = gdbserver_open(port);
2910 if (gdbserver_fd < 0)
2911 return -1;
2912 /* accept connections */
2913 gdb_accept();
2914 return 0;
2915 }
2916
2917 /* Disable gdb stub for child processes. */
2918 void gdbserver_fork(CPUArchState *env)
2919 {
2920 GDBState *s = gdbserver_state;
2921 if (gdbserver_fd < 0 || s->fd < 0)
2922 return;
2923 close(s->fd);
2924 s->fd = -1;
2925 cpu_breakpoint_remove_all(env, BP_GDB);
2926 cpu_watchpoint_remove_all(env, BP_GDB);
2927 }
2928 #else
2929 static int gdb_chr_can_receive(void *opaque)
2930 {
2931 /* We can handle an arbitrarily large amount of data.
2932 Pick the maximum packet size, which is as good as anything. */
2933 return MAX_PACKET_LENGTH;
2934 }
2935
2936 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
2937 {
2938 int i;
2939
2940 for (i = 0; i < size; i++) {
2941 gdb_read_byte(gdbserver_state, buf[i]);
2942 }
2943 }
2944
2945 static void gdb_chr_event(void *opaque, int event)
2946 {
2947 switch (event) {
2948 case CHR_EVENT_OPENED:
2949 vm_stop(RUN_STATE_PAUSED);
2950 gdb_has_xml = 0;
2951 break;
2952 default:
2953 break;
2954 }
2955 }
2956
2957 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
2958 {
2959 char buf[MAX_PACKET_LENGTH];
2960
2961 buf[0] = 'O';
2962 if (len > (MAX_PACKET_LENGTH/2) - 1)
2963 len = (MAX_PACKET_LENGTH/2) - 1;
2964 memtohex(buf + 1, (uint8_t *)msg, len);
2965 put_packet(s, buf);
2966 }
2967
2968 static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
2969 {
2970 const char *p = (const char *)buf;
2971 int max_sz;
2972
2973 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
2974 for (;;) {
2975 if (len <= max_sz) {
2976 gdb_monitor_output(gdbserver_state, p, len);
2977 break;
2978 }
2979 gdb_monitor_output(gdbserver_state, p, max_sz);
2980 p += max_sz;
2981 len -= max_sz;
2982 }
2983 return len;
2984 }
2985
2986 #ifndef _WIN32
2987 static void gdb_sigterm_handler(int signal)
2988 {
2989 if (runstate_is_running()) {
2990 vm_stop(RUN_STATE_PAUSED);
2991 }
2992 }
2993 #endif
2994
2995 int gdbserver_start(const char *device)
2996 {
2997 GDBState *s;
2998 char gdbstub_device_name[128];
2999 CharDriverState *chr = NULL;
3000 CharDriverState *mon_chr;
3001
3002 if (!device)
3003 return -1;
3004 if (strcmp(device, "none") != 0) {
3005 if (strstart(device, "tcp:", NULL)) {
3006 /* enforce required TCP attributes */
3007 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
3008 "%s,nowait,nodelay,server", device);
3009 device = gdbstub_device_name;
3010 }
3011 #ifndef _WIN32
3012 else if (strcmp(device, "stdio") == 0) {
3013 struct sigaction act;
3014
3015 memset(&act, 0, sizeof(act));
3016 act.sa_handler = gdb_sigterm_handler;
3017 sigaction(SIGINT, &act, NULL);
3018 }
3019 #endif
3020 chr = qemu_chr_new("gdb", device, NULL);
3021 if (!chr)
3022 return -1;
3023
3024 qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
3025 gdb_chr_event, NULL);
3026 }
3027
3028 s = gdbserver_state;
3029 if (!s) {
3030 s = g_malloc0(sizeof(GDBState));
3031 gdbserver_state = s;
3032
3033 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
3034
3035 /* Initialize a monitor terminal for gdb */
3036 mon_chr = g_malloc0(sizeof(*mon_chr));
3037 mon_chr->chr_write = gdb_monitor_write;
3038 monitor_init(mon_chr, 0);
3039 } else {
3040 if (s->chr)
3041 qemu_chr_delete(s->chr);
3042 mon_chr = s->mon_chr;
3043 memset(s, 0, sizeof(GDBState));
3044 }
3045 s->c_cpu = first_cpu;
3046 s->g_cpu = first_cpu;
3047 s->chr = chr;
3048 s->state = chr ? RS_IDLE : RS_INACTIVE;
3049 s->mon_chr = mon_chr;
3050 s->current_syscall_cb = NULL;
3051
3052 return 0;
3053 }
3054 #endif
Patch queue for openSUSE QEMU