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