4 * Copyright (c) 2003-2005 Fabrice Bellard
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.
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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #ifdef CONFIG_USER_ONLY
32 #include "qemu-common.h"
33 #include "qemu-char.h"
39 #include "qemu_socket.h"
41 /* XXX: these constants may be independent of the host ones even for Unix */
61 typedef struct GDBState
{
62 CPUState
*env
; /* current CPU */
63 enum RSState state
; /* parsing state */
67 uint8_t last_packet
[4100];
69 #ifdef CONFIG_USER_ONLY
77 #ifdef CONFIG_USER_ONLY
78 /* XXX: This is not thread safe. Do we care? */
79 static int gdbserver_fd
= -1;
81 /* XXX: remove this hack. */
82 static GDBState gdbserver_state
;
84 static int get_char(GDBState
*s
)
90 ret
= recv(s
->fd
, &ch
, 1, 0);
92 if (errno
!= EINTR
&& errno
!= EAGAIN
)
94 } else if (ret
== 0) {
104 /* GDB stub state for use by semihosting syscalls. */
105 static GDBState
*gdb_syscall_state
;
106 static gdb_syscall_complete_cb gdb_current_syscall_cb
;
114 /* If gdb is connected when the first semihosting syscall occurs then use
115 remote gdb syscalls. Otherwise use native file IO. */
116 int use_gdb_syscalls(void)
118 if (gdb_syscall_mode
== GDB_SYS_UNKNOWN
) {
119 gdb_syscall_mode
= (gdb_syscall_state
? GDB_SYS_ENABLED
122 return gdb_syscall_mode
== GDB_SYS_ENABLED
;
125 static void put_buffer(GDBState
*s
, const uint8_t *buf
, int len
)
127 #ifdef CONFIG_USER_ONLY
131 ret
= send(s
->fd
, buf
, len
, 0);
133 if (errno
!= EINTR
&& errno
!= EAGAIN
)
141 qemu_chr_write(s
->chr
, buf
, len
);
145 static inline int fromhex(int v
)
147 if (v
>= '0' && v
<= '9')
149 else if (v
>= 'A' && v
<= 'F')
151 else if (v
>= 'a' && v
<= 'f')
157 static inline int tohex(int v
)
165 static void memtohex(char *buf
, const uint8_t *mem
, int len
)
170 for(i
= 0; i
< len
; i
++) {
172 *q
++ = tohex(c
>> 4);
173 *q
++ = tohex(c
& 0xf);
178 static void hextomem(uint8_t *mem
, const char *buf
, int len
)
182 for(i
= 0; i
< len
; i
++) {
183 mem
[i
] = (fromhex(buf
[0]) << 4) | fromhex(buf
[1]);
188 /* return -1 if error, 0 if OK */
189 static int put_packet(GDBState
*s
, char *buf
)
195 printf("reply='%s'\n", buf
);
205 for(i
= 0; i
< len
; i
++) {
209 *(p
++) = tohex((csum
>> 4) & 0xf);
210 *(p
++) = tohex((csum
) & 0xf);
212 s
->last_packet_len
= p
- s
->last_packet
;
213 put_buffer(s
, (uint8_t *)s
->last_packet
, s
->last_packet_len
);
215 #ifdef CONFIG_USER_ONLY
228 #if defined(TARGET_X86_64)
230 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
232 uint8_t *p
= mem_buf
;
235 #define PUTREG(x) do { \
236 target_ulong reg = tswapl(x); \
237 memcpy(p, ®, sizeof reg); \
240 #define PUTREG32(x) do { \
241 uint32_t reg = tswap32(x); \
242 memcpy(p, ®, sizeof reg); \
245 #define PUTREGF(x) do { \
246 memcpy(p, &(x), 10); \
250 PUTREG(env
->regs
[R_EAX
]);
251 PUTREG(env
->regs
[R_EBX
]);
252 PUTREG(env
->regs
[R_ECX
]);
253 PUTREG(env
->regs
[R_EDX
]);
254 PUTREG(env
->regs
[R_ESI
]);
255 PUTREG(env
->regs
[R_EDI
]);
256 PUTREG(env
->regs
[R_EBP
]);
257 PUTREG(env
->regs
[R_ESP
]);
258 PUTREG(env
->regs
[8]);
259 PUTREG(env
->regs
[9]);
260 PUTREG(env
->regs
[10]);
261 PUTREG(env
->regs
[11]);
262 PUTREG(env
->regs
[12]);
263 PUTREG(env
->regs
[13]);
264 PUTREG(env
->regs
[14]);
265 PUTREG(env
->regs
[15]);
268 PUTREG32(env
->eflags
);
269 PUTREG32(env
->segs
[R_CS
].selector
);
270 PUTREG32(env
->segs
[R_SS
].selector
);
271 PUTREG32(env
->segs
[R_DS
].selector
);
272 PUTREG32(env
->segs
[R_ES
].selector
);
273 PUTREG32(env
->segs
[R_FS
].selector
);
274 PUTREG32(env
->segs
[R_GS
].selector
);
275 /* XXX: convert floats */
276 for(i
= 0; i
< 8; i
++) {
277 PUTREGF(env
->fpregs
[i
]);
280 fpus
= (env
->fpus
& ~0x3800) | (env
->fpstt
& 0x7) << 11;
282 PUTREG32(0); /* XXX: convert tags */
283 PUTREG32(0); /* fiseg */
284 PUTREG32(0); /* fioff */
285 PUTREG32(0); /* foseg */
286 PUTREG32(0); /* fooff */
287 PUTREG32(0); /* fop */
296 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
298 uint8_t *p
= mem_buf
;
302 #define GETREG(x) do { \
304 memcpy(®, p, sizeof reg); \
308 #define GETREG32(x) do { \
310 memcpy(®, p, sizeof reg); \
314 #define GETREGF(x) do { \
315 memcpy(&(x), p, 10); \
319 GETREG(env
->regs
[R_EAX
]);
320 GETREG(env
->regs
[R_EBX
]);
321 GETREG(env
->regs
[R_ECX
]);
322 GETREG(env
->regs
[R_EDX
]);
323 GETREG(env
->regs
[R_ESI
]);
324 GETREG(env
->regs
[R_EDI
]);
325 GETREG(env
->regs
[R_EBP
]);
326 GETREG(env
->regs
[R_ESP
]);
327 GETREG(env
->regs
[8]);
328 GETREG(env
->regs
[9]);
329 GETREG(env
->regs
[10]);
330 GETREG(env
->regs
[11]);
331 GETREG(env
->regs
[12]);
332 GETREG(env
->regs
[13]);
333 GETREG(env
->regs
[14]);
334 GETREG(env
->regs
[15]);
337 GETREG32(env
->eflags
);
338 GETREG32(env
->segs
[R_CS
].selector
);
339 GETREG32(env
->segs
[R_SS
].selector
);
340 GETREG32(env
->segs
[R_DS
].selector
);
341 GETREG32(env
->segs
[R_ES
].selector
);
342 GETREG32(env
->segs
[R_FS
].selector
);
343 GETREG32(env
->segs
[R_GS
].selector
);
344 /* XXX: convert floats */
345 for(i
= 0; i
< 8; i
++) {
346 GETREGF(env
->fpregs
[i
]);
349 GETREG32(fpus
); /* XXX: convert fpus */
350 GETREG32(junk
); /* XXX: convert tags */
351 GETREG32(junk
); /* fiseg */
352 GETREG32(junk
); /* fioff */
353 GETREG32(junk
); /* foseg */
354 GETREG32(junk
); /* fooff */
355 GETREG32(junk
); /* fop */
362 #elif defined(TARGET_I386)
364 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
367 uint32_t *registers
= (uint32_t *)mem_buf
;
370 /* This corresponds with amd64_register_info[] in gdb/amd64-tdep.c */
371 uint64_t *registers64
= (uint64_t *)mem_buf
;
373 if (env
->hflags
& HF_CS64_MASK
) {
374 registers64
[0] = tswap64(env
->regs
[R_EAX
]);
375 registers64
[1] = tswap64(env
->regs
[R_EBX
]);
376 registers64
[2] = tswap64(env
->regs
[R_ECX
]);
377 registers64
[3] = tswap64(env
->regs
[R_EDX
]);
378 registers64
[4] = tswap64(env
->regs
[R_ESI
]);
379 registers64
[5] = tswap64(env
->regs
[R_EDI
]);
380 registers64
[6] = tswap64(env
->regs
[R_EBP
]);
381 registers64
[7] = tswap64(env
->regs
[R_ESP
]);
382 for(i
= 8; i
< 16; i
++) {
383 registers64
[i
] = tswap64(env
->regs
[i
]);
385 registers64
[16] = tswap64(env
->eip
);
387 registers
= (uint32_t *)®isters64
[17];
388 registers
[0] = tswap32(env
->eflags
);
389 registers
[1] = tswap32(env
->segs
[R_CS
].selector
);
390 registers
[2] = tswap32(env
->segs
[R_SS
].selector
);
391 registers
[3] = tswap32(env
->segs
[R_DS
].selector
);
392 registers
[4] = tswap32(env
->segs
[R_ES
].selector
);
393 registers
[5] = tswap32(env
->segs
[R_FS
].selector
);
394 registers
[6] = tswap32(env
->segs
[R_GS
].selector
);
395 /* XXX: convert floats */
396 for(i
= 0; i
< 8; i
++) {
397 memcpy(mem_buf
+ 16 * 8 + 7 * 4 + i
* 10, &env
->fpregs
[i
], 10);
399 registers
[27] = tswap32(env
->fpuc
); /* fctrl */
400 fpus
= (env
->fpus
& ~0x3800) | (env
->fpstt
& 0x7) << 11;
401 registers
[28] = tswap32(fpus
); /* fstat */
402 registers
[29] = 0; /* ftag */
403 registers
[30] = 0; /* fiseg */
404 registers
[31] = 0; /* fioff */
405 registers
[32] = 0; /* foseg */
406 registers
[33] = 0; /* fooff */
407 registers
[34] = 0; /* fop */
408 for(i
= 0; i
< 16; i
++) {
409 memcpy(mem_buf
+ 16 * 8 + 35 * 4 + i
* 16, &env
->xmm_regs
[i
], 16);
411 registers
[99] = tswap32(env
->mxcsr
);
413 return 8 * 17 + 4 * 7 + 10 * 8 + 4 * 8 + 16 * 16 + 4;
417 for(i
= 0; i
< 8; i
++) {
418 registers
[i
] = env
->regs
[i
];
420 registers
[8] = env
->eip
;
421 registers
[9] = env
->eflags
;
422 registers
[10] = env
->segs
[R_CS
].selector
;
423 registers
[11] = env
->segs
[R_SS
].selector
;
424 registers
[12] = env
->segs
[R_DS
].selector
;
425 registers
[13] = env
->segs
[R_ES
].selector
;
426 registers
[14] = env
->segs
[R_FS
].selector
;
427 registers
[15] = env
->segs
[R_GS
].selector
;
428 /* XXX: convert floats */
429 for(i
= 0; i
< 8; i
++) {
430 memcpy(mem_buf
+ 16 * 4 + i
* 10, &env
->fpregs
[i
], 10);
432 registers
[36] = env
->fpuc
;
433 fpus
= (env
->fpus
& ~0x3800) | (env
->fpstt
& 0x7) << 11;
434 registers
[37] = fpus
;
435 registers
[38] = 0; /* XXX: convert tags */
436 registers
[39] = 0; /* fiseg */
437 registers
[40] = 0; /* fioff */
438 registers
[41] = 0; /* foseg */
439 registers
[42] = 0; /* fooff */
440 registers
[43] = 0; /* fop */
442 for(i
= 0; i
< 16; i
++)
443 tswapls(®isters
[i
]);
444 for(i
= 36; i
< 44; i
++)
445 tswapls(®isters
[i
]);
449 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
451 uint32_t *registers
= (uint32_t *)mem_buf
;
454 for(i
= 0; i
< 8; i
++) {
455 env
->regs
[i
] = tswapl(registers
[i
]);
457 env
->eip
= tswapl(registers
[8]);
458 env
->eflags
= tswapl(registers
[9]);
459 #if defined(CONFIG_USER_ONLY)
460 #define LOAD_SEG(index, sreg)\
461 if (tswapl(registers[index]) != env->segs[sreg].selector)\
462 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
472 #elif defined (TARGET_PPC)
473 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
475 uint32_t *registers
= (uint32_t *)mem_buf
, tmp
;
479 for(i
= 0; i
< 32; i
++) {
480 registers
[i
] = tswapl(env
->gpr
[i
]);
483 for (i
= 0; i
< 32; i
++) {
484 registers
[(i
* 2) + 32] = tswapl(*((uint32_t *)&env
->fpr
[i
]));
485 registers
[(i
* 2) + 33] = tswapl(*((uint32_t *)&env
->fpr
[i
] + 1));
487 /* nip, msr, ccr, lnk, ctr, xer, mq */
488 registers
[96] = tswapl(env
->nip
);
489 registers
[97] = tswapl(env
->msr
);
491 for (i
= 0; i
< 8; i
++)
492 tmp
|= env
->crf
[i
] << (32 - ((i
+ 1) * 4));
493 registers
[98] = tswapl(tmp
);
494 registers
[99] = tswapl(env
->lr
);
495 registers
[100] = tswapl(env
->ctr
);
496 registers
[101] = tswapl(ppc_load_xer(env
));
502 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
504 uint32_t *registers
= (uint32_t *)mem_buf
;
508 for (i
= 0; i
< 32; i
++) {
509 env
->gpr
[i
] = tswapl(registers
[i
]);
512 for (i
= 0; i
< 32; i
++) {
513 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[(i
* 2) + 32]);
514 *((uint32_t *)&env
->fpr
[i
] + 1) = tswapl(registers
[(i
* 2) + 33]);
516 /* nip, msr, ccr, lnk, ctr, xer, mq */
517 env
->nip
= tswapl(registers
[96]);
518 ppc_store_msr(env
, tswapl(registers
[97]));
519 registers
[98] = tswapl(registers
[98]);
520 for (i
= 0; i
< 8; i
++)
521 env
->crf
[i
] = (registers
[98] >> (32 - ((i
+ 1) * 4))) & 0xF;
522 env
->lr
= tswapl(registers
[99]);
523 env
->ctr
= tswapl(registers
[100]);
524 ppc_store_xer(env
, tswapl(registers
[101]));
526 #elif defined (TARGET_SPARC)
527 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
529 target_ulong
*registers
= (target_ulong
*)mem_buf
;
533 for(i
= 0; i
< 8; i
++) {
534 registers
[i
] = tswapl(env
->gregs
[i
]);
536 /* fill in register window */
537 for(i
= 0; i
< 24; i
++) {
538 registers
[i
+ 8] = tswapl(env
->regwptr
[i
]);
540 #ifndef TARGET_SPARC64
542 for (i
= 0; i
< 32; i
++) {
543 registers
[i
+ 32] = tswapl(*((uint32_t *)&env
->fpr
[i
]));
545 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
546 registers
[64] = tswapl(env
->y
);
551 registers
[65] = tswapl(tmp
);
553 registers
[66] = tswapl(env
->wim
);
554 registers
[67] = tswapl(env
->tbr
);
555 registers
[68] = tswapl(env
->pc
);
556 registers
[69] = tswapl(env
->npc
);
557 registers
[70] = tswapl(env
->fsr
);
558 registers
[71] = 0; /* csr */
560 return 73 * sizeof(target_ulong
);
563 for (i
= 0; i
< 64; i
+= 2) {
566 tmp
= ((uint64_t)*(uint32_t *)&env
->fpr
[i
]) << 32;
567 tmp
|= *(uint32_t *)&env
->fpr
[i
+ 1];
568 registers
[i
/ 2 + 32] = tswap64(tmp
);
570 registers
[64] = tswapl(env
->pc
);
571 registers
[65] = tswapl(env
->npc
);
572 registers
[66] = tswapl(((uint64_t)GET_CCR(env
) << 32) |
573 ((env
->asi
& 0xff) << 24) |
574 ((env
->pstate
& 0xfff) << 8) |
576 registers
[67] = tswapl(env
->fsr
);
577 registers
[68] = tswapl(env
->fprs
);
578 registers
[69] = tswapl(env
->y
);
579 return 70 * sizeof(target_ulong
);
583 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
585 target_ulong
*registers
= (target_ulong
*)mem_buf
;
589 for(i
= 0; i
< 7; i
++) {
590 env
->gregs
[i
] = tswapl(registers
[i
]);
592 /* fill in register window */
593 for(i
= 0; i
< 24; i
++) {
594 env
->regwptr
[i
] = tswapl(registers
[i
+ 8]);
596 #ifndef TARGET_SPARC64
598 for (i
= 0; i
< 32; i
++) {
599 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[i
+ 32]);
601 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
602 env
->y
= tswapl(registers
[64]);
603 PUT_PSR(env
, tswapl(registers
[65]));
604 env
->wim
= tswapl(registers
[66]);
605 env
->tbr
= tswapl(registers
[67]);
606 env
->pc
= tswapl(registers
[68]);
607 env
->npc
= tswapl(registers
[69]);
608 env
->fsr
= tswapl(registers
[70]);
610 for (i
= 0; i
< 64; i
+= 2) {
613 tmp
= tswap64(registers
[i
/ 2 + 32]);
614 *((uint32_t *)&env
->fpr
[i
]) = tmp
>> 32;
615 *((uint32_t *)&env
->fpr
[i
+ 1]) = tmp
& 0xffffffff;
617 env
->pc
= tswapl(registers
[64]);
618 env
->npc
= tswapl(registers
[65]);
620 uint64_t tmp
= tswapl(registers
[66]);
622 PUT_CCR(env
, tmp
>> 32);
623 env
->asi
= (tmp
>> 24) & 0xff;
624 env
->pstate
= (tmp
>> 8) & 0xfff;
625 PUT_CWP64(env
, tmp
& 0xff);
627 env
->fsr
= tswapl(registers
[67]);
628 env
->fprs
= tswapl(registers
[68]);
629 env
->y
= tswapl(registers
[69]);
632 #elif defined (TARGET_ARM)
633 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
639 /* 16 core integer registers (4 bytes each). */
640 for (i
= 0; i
< 16; i
++)
642 *(uint32_t *)ptr
= tswapl(env
->regs
[i
]);
645 /* 8 FPA registers (12 bytes each), FPS (4 bytes).
646 Not yet implemented. */
647 memset (ptr
, 0, 8 * 12 + 4);
649 /* CPSR (4 bytes). */
650 *(uint32_t *)ptr
= tswapl (cpsr_read(env
));
653 return ptr
- mem_buf
;
656 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
662 /* Core integer registers. */
663 for (i
= 0; i
< 16; i
++)
665 env
->regs
[i
] = tswapl(*(uint32_t *)ptr
);
668 /* Ignore FPA regs and scr. */
670 cpsr_write (env
, tswapl(*(uint32_t *)ptr
), 0xffffffff);
672 #elif defined (TARGET_M68K)
673 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
681 for (i
= 0; i
< 8; i
++) {
682 *(uint32_t *)ptr
= tswapl(env
->dregs
[i
]);
686 for (i
= 0; i
< 8; i
++) {
687 *(uint32_t *)ptr
= tswapl(env
->aregs
[i
]);
690 *(uint32_t *)ptr
= tswapl(env
->sr
);
692 *(uint32_t *)ptr
= tswapl(env
->pc
);
694 /* F0-F7. The 68881/68040 have 12-bit extended precision registers.
695 ColdFire has 8-bit double precision registers. */
696 for (i
= 0; i
< 8; i
++) {
698 *(uint32_t *)ptr
= tswap32(u
.l
.upper
);
699 *(uint32_t *)ptr
= tswap32(u
.l
.lower
);
701 /* FP control regs (not implemented). */
702 memset (ptr
, 0, 3 * 4);
705 return ptr
- mem_buf
;
708 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
716 for (i
= 0; i
< 8; i
++) {
717 env
->dregs
[i
] = tswapl(*(uint32_t *)ptr
);
721 for (i
= 0; i
< 8; i
++) {
722 env
->aregs
[i
] = tswapl(*(uint32_t *)ptr
);
725 env
->sr
= tswapl(*(uint32_t *)ptr
);
727 env
->pc
= tswapl(*(uint32_t *)ptr
);
729 /* F0-F7. The 68881/68040 have 12-bit extended precision registers.
730 ColdFire has 8-bit double precision registers. */
731 for (i
= 0; i
< 8; i
++) {
732 u
.l
.upper
= tswap32(*(uint32_t *)ptr
);
733 u
.l
.lower
= tswap32(*(uint32_t *)ptr
);
736 /* FP control regs (not implemented). */
739 #elif defined (TARGET_MIPS)
740 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
746 for (i
= 0; i
< 32; i
++)
748 *(target_ulong
*)ptr
= tswapl(env
->gpr
[i
][env
->current_tc
]);
749 ptr
+= sizeof(target_ulong
);
752 *(target_ulong
*)ptr
= (int32_t)tswap32(env
->CP0_Status
);
753 ptr
+= sizeof(target_ulong
);
755 *(target_ulong
*)ptr
= tswapl(env
->LO
[0][env
->current_tc
]);
756 ptr
+= sizeof(target_ulong
);
758 *(target_ulong
*)ptr
= tswapl(env
->HI
[0][env
->current_tc
]);
759 ptr
+= sizeof(target_ulong
);
761 *(target_ulong
*)ptr
= tswapl(env
->CP0_BadVAddr
);
762 ptr
+= sizeof(target_ulong
);
764 *(target_ulong
*)ptr
= (int32_t)tswap32(env
->CP0_Cause
);
765 ptr
+= sizeof(target_ulong
);
767 *(target_ulong
*)ptr
= tswapl(env
->PC
[env
->current_tc
]);
768 ptr
+= sizeof(target_ulong
);
770 if (env
->CP0_Config1
& (1 << CP0C1_FP
))
772 for (i
= 0; i
< 32; i
++)
774 if (env
->CP0_Status
& (1 << CP0St_FR
))
775 *(target_ulong
*)ptr
= tswapl(env
->fpu
->fpr
[i
].d
);
777 *(target_ulong
*)ptr
= tswap32(env
->fpu
->fpr
[i
].w
[FP_ENDIAN_IDX
]);
778 ptr
+= sizeof(target_ulong
);
781 *(target_ulong
*)ptr
= (int32_t)tswap32(env
->fpu
->fcr31
);
782 ptr
+= sizeof(target_ulong
);
784 *(target_ulong
*)ptr
= (int32_t)tswap32(env
->fpu
->fcr0
);
785 ptr
+= sizeof(target_ulong
);
788 /* "fp", pseudo frame pointer. Not yet implemented in gdb. */
789 *(target_ulong
*)ptr
= 0;
790 ptr
+= sizeof(target_ulong
);
792 /* Registers for embedded use, we just pad them. */
793 for (i
= 0; i
< 16; i
++)
795 *(target_ulong
*)ptr
= 0;
796 ptr
+= sizeof(target_ulong
);
800 *(target_ulong
*)ptr
= (int32_t)tswap32(env
->CP0_PRid
);
801 ptr
+= sizeof(target_ulong
);
803 return ptr
- mem_buf
;
806 /* convert MIPS rounding mode in FCR31 to IEEE library */
807 static unsigned int ieee_rm
[] =
809 float_round_nearest_even
,
814 #define RESTORE_ROUNDING_MODE \
815 set_float_rounding_mode(ieee_rm[env->fpu->fcr31 & 3], &env->fpu->fp_status)
817 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
823 for (i
= 0; i
< 32; i
++)
825 env
->gpr
[i
][env
->current_tc
] = tswapl(*(target_ulong
*)ptr
);
826 ptr
+= sizeof(target_ulong
);
829 env
->CP0_Status
= tswapl(*(target_ulong
*)ptr
);
830 ptr
+= sizeof(target_ulong
);
832 env
->LO
[0][env
->current_tc
] = tswapl(*(target_ulong
*)ptr
);
833 ptr
+= sizeof(target_ulong
);
835 env
->HI
[0][env
->current_tc
] = tswapl(*(target_ulong
*)ptr
);
836 ptr
+= sizeof(target_ulong
);
838 env
->CP0_BadVAddr
= tswapl(*(target_ulong
*)ptr
);
839 ptr
+= sizeof(target_ulong
);
841 env
->CP0_Cause
= tswapl(*(target_ulong
*)ptr
);
842 ptr
+= sizeof(target_ulong
);
844 env
->PC
[env
->current_tc
] = tswapl(*(target_ulong
*)ptr
);
845 ptr
+= sizeof(target_ulong
);
847 if (env
->CP0_Config1
& (1 << CP0C1_FP
))
849 for (i
= 0; i
< 32; i
++)
851 if (env
->CP0_Status
& (1 << CP0St_FR
))
852 env
->fpu
->fpr
[i
].d
= tswapl(*(target_ulong
*)ptr
);
854 env
->fpu
->fpr
[i
].w
[FP_ENDIAN_IDX
] = tswapl(*(target_ulong
*)ptr
);
855 ptr
+= sizeof(target_ulong
);
858 env
->fpu
->fcr31
= tswapl(*(target_ulong
*)ptr
) & 0xFF83FFFF;
859 ptr
+= sizeof(target_ulong
);
861 /* The remaining registers are assumed to be read-only. */
863 /* set rounding mode */
864 RESTORE_ROUNDING_MODE
;
866 #ifndef CONFIG_SOFTFLOAT
867 /* no floating point exception for native float */
868 SET_FP_ENABLE(env
->fcr31
, 0);
872 #elif defined (TARGET_SH4)
874 /* Hint: Use "set architecture sh4" in GDB to see fpu registers */
876 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
878 uint32_t *ptr
= (uint32_t *)mem_buf
;
881 #define SAVE(x) *ptr++=tswapl(x)
882 if ((env
->sr
& (SR_MD
| SR_RB
)) == (SR_MD
| SR_RB
)) {
883 for (i
= 0; i
< 8; i
++) SAVE(env
->gregs
[i
+ 16]);
885 for (i
= 0; i
< 8; i
++) SAVE(env
->gregs
[i
]);
887 for (i
= 8; i
< 16; i
++) SAVE(env
->gregs
[i
]);
897 for (i
= 0; i
< 16; i
++)
898 SAVE(env
->fregs
[i
+ ((env
->fpscr
& FPSCR_FR
) ? 16 : 0)]);
901 for (i
= 0; i
< 8; i
++) SAVE(env
->gregs
[i
]);
902 for (i
= 0; i
< 8; i
++) SAVE(env
->gregs
[i
+ 16]);
903 return ((uint8_t *)ptr
- mem_buf
);
906 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
908 uint32_t *ptr
= (uint32_t *)mem_buf
;
911 #define LOAD(x) (x)=*ptr++;
912 if ((env
->sr
& (SR_MD
| SR_RB
)) == (SR_MD
| SR_RB
)) {
913 for (i
= 0; i
< 8; i
++) LOAD(env
->gregs
[i
+ 16]);
915 for (i
= 0; i
< 8; i
++) LOAD(env
->gregs
[i
]);
917 for (i
= 8; i
< 16; i
++) LOAD(env
->gregs
[i
]);
927 for (i
= 0; i
< 16; i
++)
928 LOAD(env
->fregs
[i
+ ((env
->fpscr
& FPSCR_FR
) ? 16 : 0)]);
931 for (i
= 0; i
< 8; i
++) LOAD(env
->gregs
[i
]);
932 for (i
= 0; i
< 8; i
++) LOAD(env
->gregs
[i
+ 16]);
934 #elif defined (TARGET_CRIS)
936 static int cris_save_32 (unsigned char *d
, uint32_t value
)
939 *d
++ = (value
>>= 8);
940 *d
++ = (value
>>= 8);
941 *d
++ = (value
>>= 8);
944 static int cris_save_16 (unsigned char *d
, uint32_t value
)
947 *d
++ = (value
>>= 8);
950 static int cris_save_8 (unsigned char *d
, uint32_t value
)
956 /* FIXME: this will bug on archs not supporting unaligned word accesses. */
957 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
959 uint8_t *ptr
= mem_buf
;
963 for (i
= 0; i
< 16; i
++)
964 ptr
+= cris_save_32 (ptr
, env
->regs
[i
]);
966 srs
= env
->pregs
[SR_SRS
];
968 ptr
+= cris_save_8 (ptr
, env
->pregs
[0]);
969 ptr
+= cris_save_8 (ptr
, env
->pregs
[1]);
970 ptr
+= cris_save_32 (ptr
, env
->pregs
[2]);
971 ptr
+= cris_save_8 (ptr
, srs
);
972 ptr
+= cris_save_16 (ptr
, env
->pregs
[4]);
974 for (i
= 5; i
< 16; i
++)
975 ptr
+= cris_save_32 (ptr
, env
->pregs
[i
]);
977 ptr
+= cris_save_32 (ptr
, env
->pc
);
979 for (i
= 0; i
< 16; i
++)
980 ptr
+= cris_save_32 (ptr
, env
->sregs
[srs
][i
]);
982 return ((uint8_t *)ptr
- mem_buf
);
985 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
987 uint32_t *ptr
= (uint32_t *)mem_buf
;
990 #define LOAD(x) (x)=*ptr++;
991 for (i
= 0; i
< 16; i
++) LOAD(env
->regs
[i
]);
995 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
1000 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
1006 static int gdb_handle_packet(GDBState
*s
, CPUState
*env
, const char *line_buf
)
1009 int ch
, reg_size
, type
;
1011 uint8_t mem_buf
[4096];
1012 uint32_t *registers
;
1013 target_ulong addr
, len
;
1016 printf("command='%s'\n", line_buf
);
1022 /* TODO: Make this return the correct value for user-mode. */
1023 snprintf(buf
, sizeof(buf
), "S%02x", SIGTRAP
);
1028 addr
= strtoull(p
, (char **)&p
, 16);
1029 #if defined(TARGET_I386)
1032 kvm_load_registers(env
);
1034 #elif defined (TARGET_PPC)
1036 #elif defined (TARGET_SPARC)
1038 env
->npc
= addr
+ 4;
1039 #elif defined (TARGET_ARM)
1040 env
->regs
[15] = addr
;
1041 #elif defined (TARGET_SH4)
1043 #elif defined (TARGET_MIPS)
1044 env
->PC
[env
->current_tc
] = addr
;
1045 #elif defined (TARGET_CRIS)
1049 #ifdef CONFIG_USER_ONLY
1050 s
->running_state
= 1;
1057 addr
= strtoull(p
, (char **)&p
, 16);
1058 #if defined(TARGET_I386)
1061 kvm_load_registers(env
);
1063 #elif defined (TARGET_PPC)
1065 #elif defined (TARGET_SPARC)
1067 env
->npc
= addr
+ 4;
1068 #elif defined (TARGET_ARM)
1069 env
->regs
[15] = addr
;
1070 #elif defined (TARGET_SH4)
1072 #elif defined (TARGET_MIPS)
1073 env
->PC
[env
->current_tc
] = addr
;
1074 #elif defined (TARGET_CRIS)
1078 cpu_single_step(env
, 1);
1079 #ifdef CONFIG_USER_ONLY
1080 s
->running_state
= 1;
1090 ret
= strtoull(p
, (char **)&p
, 16);
1093 err
= strtoull(p
, (char **)&p
, 16);
1100 if (gdb_current_syscall_cb
)
1101 gdb_current_syscall_cb(s
->env
, ret
, err
);
1103 put_packet(s
, "T02");
1105 #ifdef CONFIG_USER_ONLY
1106 s
->running_state
= 1;
1115 kvm_save_registers(env
);
1117 reg_size
= cpu_gdb_read_registers(env
, mem_buf
);
1118 memtohex(buf
, mem_buf
, reg_size
);
1122 registers
= (void *)mem_buf
;
1123 len
= strlen(p
) / 2;
1124 hextomem((uint8_t *)registers
, p
, len
);
1125 cpu_gdb_write_registers(env
, mem_buf
, len
);
1127 kvm_load_registers(env
);
1129 put_packet(s
, "OK");
1132 addr
= strtoull(p
, (char **)&p
, 16);
1135 len
= strtoull(p
, NULL
, 16);
1136 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 0) != 0) {
1137 put_packet (s
, "E14");
1139 memtohex(buf
, mem_buf
, len
);
1144 addr
= strtoull(p
, (char **)&p
, 16);
1147 len
= strtoull(p
, (char **)&p
, 16);
1150 hextomem(mem_buf
, p
, len
);
1151 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 1) != 0)
1152 put_packet(s
, "E14");
1154 put_packet(s
, "OK");
1157 type
= strtoul(p
, (char **)&p
, 16);
1160 addr
= strtoull(p
, (char **)&p
, 16);
1163 len
= strtoull(p
, (char **)&p
, 16);
1164 if (type
== 0 || type
== 1) {
1165 if (cpu_breakpoint_insert(env
, addr
) < 0)
1166 goto breakpoint_error
;
1167 put_packet(s
, "OK");
1168 #ifndef CONFIG_USER_ONLY
1169 } else if (type
== 2) {
1170 if (cpu_watchpoint_insert(env
, addr
) < 0)
1171 goto breakpoint_error
;
1172 put_packet(s
, "OK");
1176 put_packet(s
, "E22");
1180 type
= strtoul(p
, (char **)&p
, 16);
1183 addr
= strtoull(p
, (char **)&p
, 16);
1186 len
= strtoull(p
, (char **)&p
, 16);
1187 if (type
== 0 || type
== 1) {
1188 cpu_breakpoint_remove(env
, addr
);
1189 put_packet(s
, "OK");
1190 #ifndef CONFIG_USER_ONLY
1191 } else if (type
== 2) {
1192 cpu_watchpoint_remove(env
, addr
);
1193 put_packet(s
, "OK");
1196 goto breakpoint_error
;
1199 #ifdef CONFIG_LINUX_USER
1201 if (strncmp(p
, "Offsets", 7) == 0) {
1202 TaskState
*ts
= env
->opaque
;
1205 "Text=" TARGET_ABI_FMT_lx
";Data=" TARGET_ABI_FMT_lx
1206 ";Bss=" TARGET_ABI_FMT_lx
,
1207 ts
->info
->code_offset
,
1208 ts
->info
->data_offset
,
1209 ts
->info
->data_offset
);
1217 /* put empty packet */
1225 extern void tb_flush(CPUState
*env
);
1227 #ifndef CONFIG_USER_ONLY
1228 static void gdb_vm_stopped(void *opaque
, int reason
)
1230 GDBState
*s
= opaque
;
1234 if (s
->state
== RS_SYSCALL
)
1237 /* disable single step if it was enable */
1238 cpu_single_step(s
->env
, 0);
1240 if (reason
== EXCP_DEBUG
) {
1241 if (s
->env
->watchpoint_hit
) {
1242 snprintf(buf
, sizeof(buf
), "T%02xwatch:" TARGET_FMT_lx
";",
1244 s
->env
->watchpoint
[s
->env
->watchpoint_hit
- 1].vaddr
);
1246 s
->env
->watchpoint_hit
= 0;
1251 } else if (reason
== EXCP_INTERRUPT
) {
1256 snprintf(buf
, sizeof(buf
), "S%02x", ret
);
1261 /* Send a gdb syscall request.
1262 This accepts limited printf-style format specifiers, specifically:
1263 %x - target_ulong argument printed in hex.
1264 %lx - 64-bit argument printed in hex.
1265 %s - string pointer (target_ulong) and length (int) pair. */
1266 void gdb_do_syscall(gdb_syscall_complete_cb cb
, char *fmt
, ...)
1275 s
= gdb_syscall_state
;
1278 gdb_current_syscall_cb
= cb
;
1279 s
->state
= RS_SYSCALL
;
1280 #ifndef CONFIG_USER_ONLY
1281 vm_stop(EXCP_DEBUG
);
1292 addr
= va_arg(va
, target_ulong
);
1293 p
+= sprintf(p
, TARGET_FMT_lx
, addr
);
1296 if (*(fmt
++) != 'x')
1298 i64
= va_arg(va
, uint64_t);
1299 p
+= sprintf(p
, "%" PRIx64
, i64
);
1302 addr
= va_arg(va
, target_ulong
);
1303 p
+= sprintf(p
, TARGET_FMT_lx
"/%x", addr
, va_arg(va
, int));
1307 fprintf(stderr
, "gdbstub: Bad syscall format string '%s'\n",
1318 #ifdef CONFIG_USER_ONLY
1319 gdb_handlesig(s
->env
, 0);
1321 cpu_interrupt(s
->env
, CPU_INTERRUPT_EXIT
);
1325 static void gdb_read_byte(GDBState
*s
, int ch
)
1327 CPUState
*env
= s
->env
;
1331 #ifndef CONFIG_USER_ONLY
1332 if (s
->last_packet_len
) {
1333 /* Waiting for a response to the last packet. If we see the start
1334 of a new command then abandon the previous response. */
1337 printf("Got NACK, retransmitting\n");
1339 put_buffer(s
, (uint8_t *)s
->last_packet
, s
->last_packet_len
);
1343 printf("Got ACK\n");
1345 printf("Got '%c' when expecting ACK/NACK\n", ch
);
1347 if (ch
== '+' || ch
== '$')
1348 s
->last_packet_len
= 0;
1353 /* when the CPU is running, we cannot do anything except stop
1354 it when receiving a char */
1355 vm_stop(EXCP_INTERRUPT
);
1362 s
->line_buf_index
= 0;
1363 s
->state
= RS_GETLINE
;
1368 s
->state
= RS_CHKSUM1
;
1369 } else if (s
->line_buf_index
>= sizeof(s
->line_buf
) - 1) {
1372 s
->line_buf
[s
->line_buf_index
++] = ch
;
1376 s
->line_buf
[s
->line_buf_index
] = '\0';
1377 s
->line_csum
= fromhex(ch
) << 4;
1378 s
->state
= RS_CHKSUM2
;
1381 s
->line_csum
|= fromhex(ch
);
1383 for(i
= 0; i
< s
->line_buf_index
; i
++) {
1384 csum
+= s
->line_buf
[i
];
1386 if (s
->line_csum
!= (csum
& 0xff)) {
1388 put_buffer(s
, &reply
, 1);
1392 put_buffer(s
, &reply
, 1);
1393 s
->state
= gdb_handle_packet(s
, env
, s
->line_buf
);
1402 #ifdef CONFIG_USER_ONLY
1404 gdb_handlesig (CPUState
*env
, int sig
)
1410 if (gdbserver_fd
< 0)
1413 s
= &gdbserver_state
;
1415 /* disable single step if it was enabled */
1416 cpu_single_step(env
, 0);
1421 snprintf(buf
, sizeof(buf
), "S%02x", sig
);
1427 s
->running_state
= 0;
1428 while (s
->running_state
== 0) {
1429 n
= read (s
->fd
, buf
, 256);
1434 for (i
= 0; i
< n
; i
++)
1435 gdb_read_byte (s
, buf
[i
]);
1437 else if (n
== 0 || errno
!= EAGAIN
)
1439 /* XXX: Connection closed. Should probably wait for annother
1440 connection before continuing. */
1447 /* Tell the remote gdb that the process has exited. */
1448 void gdb_exit(CPUState
*env
, int code
)
1453 if (gdbserver_fd
< 0)
1456 s
= &gdbserver_state
;
1458 snprintf(buf
, sizeof(buf
), "W%02x", code
);
1463 static void gdb_accept(void *opaque
)
1466 struct sockaddr_in sockaddr
;
1471 len
= sizeof(sockaddr
);
1472 fd
= accept(gdbserver_fd
, (struct sockaddr
*)&sockaddr
, &len
);
1473 if (fd
< 0 && errno
!= EINTR
) {
1476 } else if (fd
>= 0) {
1481 /* set short latency */
1483 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
1485 s
= &gdbserver_state
;
1486 memset (s
, 0, sizeof (GDBState
));
1487 s
->env
= first_cpu
; /* XXX: allow to change CPU */
1490 gdb_syscall_state
= s
;
1492 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
1495 static int gdbserver_open(int port
)
1497 struct sockaddr_in sockaddr
;
1500 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
1506 /* allow fast reuse */
1508 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
1510 sockaddr
.sin_family
= AF_INET
;
1511 sockaddr
.sin_port
= htons(port
);
1512 sockaddr
.sin_addr
.s_addr
= 0;
1513 ret
= bind(fd
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
1518 ret
= listen(fd
, 0);
1526 int gdbserver_start(int port
)
1528 gdbserver_fd
= gdbserver_open(port
);
1529 if (gdbserver_fd
< 0)
1531 /* accept connections */
1536 static int gdb_chr_can_receive(void *opaque
)
1541 static void gdb_chr_receive(void *opaque
, const uint8_t *buf
, int size
)
1543 GDBState
*s
= opaque
;
1546 for (i
= 0; i
< size
; i
++) {
1547 gdb_read_byte(s
, buf
[i
]);
1551 static void gdb_chr_event(void *opaque
, int event
)
1554 case CHR_EVENT_RESET
:
1555 vm_stop(EXCP_INTERRUPT
);
1556 gdb_syscall_state
= opaque
;
1563 int gdbserver_start(const char *port
)
1566 char gdbstub_port_name
[128];
1569 CharDriverState
*chr
;
1571 if (!port
|| !*port
)
1574 port_num
= strtol(port
, &p
, 10);
1576 /* A numeric value is interpreted as a port number. */
1577 snprintf(gdbstub_port_name
, sizeof(gdbstub_port_name
),
1578 "tcp::%d,nowait,nodelay,server", port_num
);
1579 port
= gdbstub_port_name
;
1582 chr
= qemu_chr_open(port
);
1586 s
= qemu_mallocz(sizeof(GDBState
));
1590 s
->env
= first_cpu
; /* XXX: allow to change CPU */
1592 qemu_chr_add_handlers(chr
, gdb_chr_can_receive
, gdb_chr_receive
,
1594 qemu_add_vm_stop_handler(gdb_vm_stopped
, s
);