1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* See the GDB User Guide for details of the GDB remote protocol. */
27 #include "gdb_string.h"
33 #include "exceptions.h"
35 /*#include "terminal.h" */
38 #include "gdb-stabs.h"
39 #include "gdbthread.h"
43 #include "gdb_assert.h"
46 #include "cli/cli-decode.h"
47 #include "cli/cli-setshow.h"
48 #include "target-descriptions.h"
53 #include "event-loop.h"
54 #include "event-top.h"
60 #include "gdbcore.h" /* for exec_bfd */
62 #include "remote-fileio.h"
64 #include "memory-map.h"
66 /* The size to align memory write packets, when practical. The protocol
67 does not guarantee any alignment, and gdb will generate short
68 writes and unaligned writes, but even as a best-effort attempt this
69 can improve bulk transfers. For instance, if a write is misaligned
70 relative to the target's data bus, the stub may need to make an extra
71 round trip fetching data from the target. This doesn't make a
72 huge difference, but it's easy to do, so we try to be helpful.
74 The alignment chosen is arbitrary; usually data bus width is
75 important here, not the possibly larger cache line size. */
76 enum { REMOTE_ALIGN_WRITES
= 16 };
78 /* Prototypes for local functions. */
79 static void cleanup_sigint_signal_handler (void *dummy
);
80 static void initialize_sigint_signal_handler (void);
81 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
83 static void handle_remote_sigint (int);
84 static void handle_remote_sigint_twice (int);
85 static void async_remote_interrupt (gdb_client_data
);
86 void async_remote_interrupt_twice (gdb_client_data
);
88 static void remote_files_info (struct target_ops
*ignore
);
90 static void remote_prepare_to_store (struct regcache
*regcache
);
92 static void remote_fetch_registers (struct regcache
*regcache
, int regno
);
94 static void remote_resume (ptid_t ptid
, int step
,
95 enum target_signal siggnal
);
96 static void remote_async_resume (ptid_t ptid
, int step
,
97 enum target_signal siggnal
);
98 static void remote_open (char *name
, int from_tty
);
99 static void remote_async_open (char *name
, int from_tty
);
101 static void extended_remote_open (char *name
, int from_tty
);
102 static void extended_remote_async_open (char *name
, int from_tty
);
104 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
,
107 static void remote_close (int quitting
);
109 static void remote_store_registers (struct regcache
*regcache
, int regno
);
111 static void remote_mourn (void);
112 static void remote_async_mourn (void);
114 static void extended_remote_restart (void);
116 static void extended_remote_mourn (void);
118 static void remote_mourn_1 (struct target_ops
*);
120 static void remote_send (char **buf
, long *sizeof_buf_p
);
122 static int readchar (int timeout
);
124 static ptid_t
remote_wait (ptid_t ptid
,
125 struct target_waitstatus
*status
);
126 static ptid_t
remote_async_wait (ptid_t ptid
,
127 struct target_waitstatus
*status
);
129 static void remote_kill (void);
130 static void remote_async_kill (void);
132 static int tohex (int nib
);
134 static void remote_detach (char *args
, int from_tty
);
136 static void remote_interrupt (int signo
);
138 static void remote_interrupt_twice (int signo
);
140 static void interrupt_query (void);
142 static void set_thread (int, int);
144 static int remote_thread_alive (ptid_t
);
146 static void get_offsets (void);
148 static void skip_frame (void);
150 static long read_frame (char **buf_p
, long *sizeof_buf
);
152 static int hexnumlen (ULONGEST num
);
154 static void init_remote_ops (void);
156 static void init_extended_remote_ops (void);
158 static void remote_stop (void);
160 static int ishex (int ch
, int *val
);
162 static int stubhex (int ch
);
164 static int hexnumstr (char *, ULONGEST
);
166 static int hexnumnstr (char *, ULONGEST
, int);
168 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
170 static void print_packet (char *);
172 static unsigned long crc32 (unsigned char *, int, unsigned int);
174 static void compare_sections_command (char *, int);
176 static void packet_command (char *, int);
178 static int stub_unpack_int (char *buff
, int fieldlength
);
180 static ptid_t
remote_current_thread (ptid_t oldptid
);
182 static void remote_find_new_threads (void);
184 static void record_currthread (int currthread
);
186 static int fromhex (int a
);
188 static int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
190 static int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
192 static int putpkt_binary (char *buf
, int cnt
);
194 static void check_binary_download (CORE_ADDR addr
);
196 struct packet_config
;
198 static void show_packet_config_cmd (struct packet_config
*config
);
200 static void update_packet_config (struct packet_config
*config
);
202 static void set_remote_protocol_packet_cmd (char *args
, int from_tty
,
203 struct cmd_list_element
*c
);
205 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
207 struct cmd_list_element
*c
,
210 void _initialize_remote (void);
212 /* For "set remote" and "show remote". */
214 static struct cmd_list_element
*remote_set_cmdlist
;
215 static struct cmd_list_element
*remote_show_cmdlist
;
217 /* Description of the remote protocol state for the currently
218 connected target. This is per-target state, and independent of the
219 selected architecture. */
223 /* A buffer to use for incoming packets, and its current size. The
224 buffer is grown dynamically for larger incoming packets.
225 Outgoing packets may also be constructed in this buffer.
226 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
227 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
232 /* If we negotiated packet size explicitly (and thus can bypass
233 heuristics for the largest packet size that will not overflow
234 a buffer in the stub), this will be set to that packet size.
235 Otherwise zero, meaning to use the guessed size. */
236 long explicit_packet_size
;
239 /* This data could be associated with a target, but we do not always
240 have access to the current target when we need it, so for now it is
241 static. This will be fine for as long as only one target is in use
243 static struct remote_state remote_state
;
245 static struct remote_state
*
246 get_remote_state_raw (void)
248 return &remote_state
;
251 /* Description of the remote protocol for a given architecture. */
255 long offset
; /* Offset into G packet. */
256 long regnum
; /* GDB's internal register number. */
257 LONGEST pnum
; /* Remote protocol register number. */
258 int in_g_packet
; /* Always part of G packet. */
259 /* long size in bytes; == register_size (current_gdbarch, regnum);
261 /* char *name; == gdbarch_register_name (current_gdbarch, regnum);
265 struct remote_arch_state
267 /* Description of the remote protocol registers. */
268 long sizeof_g_packet
;
270 /* Description of the remote protocol registers indexed by REGNUM
271 (making an array gdbarch_num_regs in size). */
272 struct packet_reg
*regs
;
274 /* This is the size (in chars) of the first response to the ``g''
275 packet. It is used as a heuristic when determining the maximum
276 size of memory-read and memory-write packets. A target will
277 typically only reserve a buffer large enough to hold the ``g''
278 packet. The size does not include packet overhead (headers and
280 long actual_register_packet_size
;
282 /* This is the maximum size (in chars) of a non read/write packet.
283 It is also used as a cap on the size of read/write packets. */
284 long remote_packet_size
;
288 /* Handle for retreving the remote protocol data from gdbarch. */
289 static struct gdbarch_data
*remote_gdbarch_data_handle
;
291 static struct remote_arch_state
*
292 get_remote_arch_state (void)
294 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
297 /* Fetch the global remote target state. */
299 static struct remote_state
*
300 get_remote_state (void)
302 /* Make sure that the remote architecture state has been
303 initialized, because doing so might reallocate rs->buf. Any
304 function which calls getpkt also needs to be mindful of changes
305 to rs->buf, but this call limits the number of places which run
307 get_remote_arch_state ();
309 return get_remote_state_raw ();
313 compare_pnums (const void *lhs_
, const void *rhs_
)
315 const struct packet_reg
* const *lhs
= lhs_
;
316 const struct packet_reg
* const *rhs
= rhs_
;
318 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
320 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
327 init_remote_state (struct gdbarch
*gdbarch
)
329 int regnum
, num_remote_regs
, offset
;
330 struct remote_state
*rs
= get_remote_state_raw ();
331 struct remote_arch_state
*rsa
;
332 struct packet_reg
**remote_regs
;
334 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
336 /* Use the architecture to build a regnum<->pnum table, which will be
337 1:1 unless a feature set specifies otherwise. */
338 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
339 gdbarch_num_regs (current_gdbarch
),
341 for (regnum
= 0; regnum
< gdbarch_num_regs (current_gdbarch
); regnum
++)
343 struct packet_reg
*r
= &rsa
->regs
[regnum
];
345 if (register_size (current_gdbarch
, regnum
) == 0)
346 /* Do not try to fetch zero-sized (placeholder) registers. */
349 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
354 /* Define the g/G packet format as the contents of each register
355 with a remote protocol number, in order of ascending protocol
358 remote_regs
= alloca (gdbarch_num_regs (current_gdbarch
)
359 * sizeof (struct packet_reg
*));
360 for (num_remote_regs
= 0, regnum
= 0;
361 regnum
< gdbarch_num_regs (current_gdbarch
);
363 if (rsa
->regs
[regnum
].pnum
!= -1)
364 remote_regs
[num_remote_regs
++] = &rsa
->regs
[regnum
];
366 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
369 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
371 remote_regs
[regnum
]->in_g_packet
= 1;
372 remote_regs
[regnum
]->offset
= offset
;
373 offset
+= register_size (current_gdbarch
, remote_regs
[regnum
]->regnum
);
376 /* Record the maximum possible size of the g packet - it may turn out
378 rsa
->sizeof_g_packet
= offset
;
380 /* Default maximum number of characters in a packet body. Many
381 remote stubs have a hardwired buffer size of 400 bytes
382 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
383 as the maximum packet-size to ensure that the packet and an extra
384 NUL character can always fit in the buffer. This stops GDB
385 trashing stubs that try to squeeze an extra NUL into what is
386 already a full buffer (As of 1999-12-04 that was most stubs). */
387 rsa
->remote_packet_size
= 400 - 1;
389 /* This one is filled in when a ``g'' packet is received. */
390 rsa
->actual_register_packet_size
= 0;
392 /* Should rsa->sizeof_g_packet needs more space than the
393 default, adjust the size accordingly. Remember that each byte is
394 encoded as two characters. 32 is the overhead for the packet
395 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
396 (``$NN:G...#NN'') is a better guess, the below has been padded a
398 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
399 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
401 /* Make sure that the packet buffer is plenty big enough for
402 this architecture. */
403 if (rs
->buf_size
< rsa
->remote_packet_size
)
405 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
406 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
412 /* Return the current allowed size of a remote packet. This is
413 inferred from the current architecture, and should be used to
414 limit the length of outgoing packets. */
416 get_remote_packet_size (void)
418 struct remote_state
*rs
= get_remote_state ();
419 struct remote_arch_state
*rsa
= get_remote_arch_state ();
421 if (rs
->explicit_packet_size
)
422 return rs
->explicit_packet_size
;
424 return rsa
->remote_packet_size
;
427 static struct packet_reg
*
428 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
430 if (regnum
< 0 && regnum
>= gdbarch_num_regs (current_gdbarch
))
434 struct packet_reg
*r
= &rsa
->regs
[regnum
];
435 gdb_assert (r
->regnum
== regnum
);
440 static struct packet_reg
*
441 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
444 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
446 struct packet_reg
*r
= &rsa
->regs
[i
];
453 /* FIXME: graces/2002-08-08: These variables should eventually be
454 bound to an instance of the target object (as in gdbarch-tdep()),
455 when such a thing exists. */
457 /* This is set to the data address of the access causing the target
458 to stop for a watchpoint. */
459 static CORE_ADDR remote_watch_data_address
;
461 /* This is non-zero if target stopped for a watchpoint. */
462 static int remote_stopped_by_watchpoint_p
;
464 static struct target_ops remote_ops
;
466 static struct target_ops extended_remote_ops
;
468 /* Temporary target ops. Just like the remote_ops and
469 extended_remote_ops, but with asynchronous support. */
470 static struct target_ops remote_async_ops
;
472 static struct target_ops extended_async_remote_ops
;
474 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
475 ``forever'' still use the normal timeout mechanism. This is
476 currently used by the ASYNC code to guarentee that target reads
477 during the initial connect always time-out. Once getpkt has been
478 modified to return a timeout indication and, in turn
479 remote_wait()/wait_for_inferior() have gained a timeout parameter
481 static int wait_forever_enabled_p
= 1;
484 /* This variable chooses whether to send a ^C or a break when the user
485 requests program interruption. Although ^C is usually what remote
486 systems expect, and that is the default here, sometimes a break is
487 preferable instead. */
489 static int remote_break
;
491 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
492 remote_open knows that we don't have a file open when the program
494 static struct serial
*remote_desc
= NULL
;
496 /* This variable sets the number of bits in an address that are to be
497 sent in a memory ("M" or "m") packet. Normally, after stripping
498 leading zeros, the entire address would be sent. This variable
499 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
500 initial implementation of remote.c restricted the address sent in
501 memory packets to ``host::sizeof long'' bytes - (typically 32
502 bits). Consequently, for 64 bit targets, the upper 32 bits of an
503 address was never sent. Since fixing this bug may cause a break in
504 some remote targets this variable is principly provided to
505 facilitate backward compatibility. */
507 static int remote_address_size
;
509 /* Tempoary to track who currently owns the terminal. See
510 target_async_terminal_* for more details. */
512 static int remote_async_terminal_ours_p
;
515 /* User configurable variables for the number of characters in a
516 memory read/write packet. MIN (rsa->remote_packet_size,
517 rsa->sizeof_g_packet) is the default. Some targets need smaller
518 values (fifo overruns, et.al.) and some users need larger values
519 (speed up transfers). The variables ``preferred_*'' (the user
520 request), ``current_*'' (what was actually set) and ``forced_*''
521 (Positive - a soft limit, negative - a hard limit). */
523 struct memory_packet_config
530 /* Compute the current size of a read/write packet. Since this makes
531 use of ``actual_register_packet_size'' the computation is dynamic. */
534 get_memory_packet_size (struct memory_packet_config
*config
)
536 struct remote_state
*rs
= get_remote_state ();
537 struct remote_arch_state
*rsa
= get_remote_arch_state ();
539 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
540 law?) that some hosts don't cope very well with large alloca()
541 calls. Eventually the alloca() code will be replaced by calls to
542 xmalloc() and make_cleanups() allowing this restriction to either
543 be lifted or removed. */
544 #ifndef MAX_REMOTE_PACKET_SIZE
545 #define MAX_REMOTE_PACKET_SIZE 16384
547 /* NOTE: 20 ensures we can write at least one byte. */
548 #ifndef MIN_REMOTE_PACKET_SIZE
549 #define MIN_REMOTE_PACKET_SIZE 20
554 if (config
->size
<= 0)
555 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
557 what_they_get
= config
->size
;
561 what_they_get
= get_remote_packet_size ();
562 /* Limit the packet to the size specified by the user. */
564 && what_they_get
> config
->size
)
565 what_they_get
= config
->size
;
567 /* Limit it to the size of the targets ``g'' response unless we have
568 permission from the stub to use a larger packet size. */
569 if (rs
->explicit_packet_size
== 0
570 && rsa
->actual_register_packet_size
> 0
571 && what_they_get
> rsa
->actual_register_packet_size
)
572 what_they_get
= rsa
->actual_register_packet_size
;
574 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
575 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
576 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
577 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
579 /* Make sure there is room in the global buffer for this packet
580 (including its trailing NUL byte). */
581 if (rs
->buf_size
< what_they_get
+ 1)
583 rs
->buf_size
= 2 * what_they_get
;
584 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
587 return what_they_get
;
590 /* Update the size of a read/write packet. If they user wants
591 something really big then do a sanity check. */
594 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
596 int fixed_p
= config
->fixed_p
;
597 long size
= config
->size
;
599 error (_("Argument required (integer, `fixed' or `limited')."));
600 else if (strcmp (args
, "hard") == 0
601 || strcmp (args
, "fixed") == 0)
603 else if (strcmp (args
, "soft") == 0
604 || strcmp (args
, "limit") == 0)
609 size
= strtoul (args
, &end
, 0);
611 error (_("Invalid %s (bad syntax)."), config
->name
);
613 /* Instead of explicitly capping the size of a packet to
614 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
615 instead allowed to set the size to something arbitrarily
617 if (size
> MAX_REMOTE_PACKET_SIZE
)
618 error (_("Invalid %s (too large)."), config
->name
);
622 if (fixed_p
&& !config
->fixed_p
)
624 if (! query (_("The target may not be able to correctly handle a %s\n"
625 "of %ld bytes. Change the packet size? "),
627 error (_("Packet size not changed."));
629 /* Update the config. */
630 config
->fixed_p
= fixed_p
;
635 show_memory_packet_size (struct memory_packet_config
*config
)
637 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
639 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
640 get_memory_packet_size (config
));
642 printf_filtered (_("Packets are limited to %ld bytes.\n"),
643 get_memory_packet_size (config
));
646 static struct memory_packet_config memory_write_packet_config
=
648 "memory-write-packet-size",
652 set_memory_write_packet_size (char *args
, int from_tty
)
654 set_memory_packet_size (args
, &memory_write_packet_config
);
658 show_memory_write_packet_size (char *args
, int from_tty
)
660 show_memory_packet_size (&memory_write_packet_config
);
664 get_memory_write_packet_size (void)
666 return get_memory_packet_size (&memory_write_packet_config
);
669 static struct memory_packet_config memory_read_packet_config
=
671 "memory-read-packet-size",
675 set_memory_read_packet_size (char *args
, int from_tty
)
677 set_memory_packet_size (args
, &memory_read_packet_config
);
681 show_memory_read_packet_size (char *args
, int from_tty
)
683 show_memory_packet_size (&memory_read_packet_config
);
687 get_memory_read_packet_size (void)
689 long size
= get_memory_packet_size (&memory_read_packet_config
);
690 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
691 extra buffer size argument before the memory read size can be
692 increased beyond this. */
693 if (size
> get_remote_packet_size ())
694 size
= get_remote_packet_size ();
699 /* Generic configuration support for packets the stub optionally
700 supports. Allows the user to specify the use of the packet as well
701 as allowing GDB to auto-detect support in the remote stub. */
705 PACKET_SUPPORT_UNKNOWN
= 0,
714 enum auto_boolean detect
;
715 enum packet_support support
;
718 /* Analyze a packet's return value and update the packet config
729 update_packet_config (struct packet_config
*config
)
731 switch (config
->detect
)
733 case AUTO_BOOLEAN_TRUE
:
734 config
->support
= PACKET_ENABLE
;
736 case AUTO_BOOLEAN_FALSE
:
737 config
->support
= PACKET_DISABLE
;
739 case AUTO_BOOLEAN_AUTO
:
740 config
->support
= PACKET_SUPPORT_UNKNOWN
;
746 show_packet_config_cmd (struct packet_config
*config
)
748 char *support
= "internal-error";
749 switch (config
->support
)
755 support
= "disabled";
757 case PACKET_SUPPORT_UNKNOWN
:
761 switch (config
->detect
)
763 case AUTO_BOOLEAN_AUTO
:
764 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
765 config
->name
, support
);
767 case AUTO_BOOLEAN_TRUE
:
768 case AUTO_BOOLEAN_FALSE
:
769 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
770 config
->name
, support
);
776 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
777 const char *title
, int legacy
)
784 config
->title
= title
;
785 config
->detect
= AUTO_BOOLEAN_AUTO
;
786 config
->support
= PACKET_SUPPORT_UNKNOWN
;
787 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
789 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
791 /* set/show TITLE-packet {auto,on,off} */
792 cmd_name
= xstrprintf ("%s-packet", title
);
793 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
794 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
795 set_remote_protocol_packet_cmd
,
796 show_remote_protocol_packet_cmd
,
797 &remote_set_cmdlist
, &remote_show_cmdlist
);
798 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
802 legacy_name
= xstrprintf ("%s-packet", name
);
803 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
804 &remote_set_cmdlist
);
805 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
806 &remote_show_cmdlist
);
810 static enum packet_result
811 packet_check_result (const char *buf
)
815 /* The stub recognized the packet request. Check that the
816 operation succeeded. */
818 && isxdigit (buf
[1]) && isxdigit (buf
[2])
820 /* "Enn" - definitly an error. */
823 /* Always treat "E." as an error. This will be used for
824 more verbose error messages, such as E.memtypes. */
825 if (buf
[0] == 'E' && buf
[1] == '.')
828 /* The packet may or may not be OK. Just assume it is. */
832 /* The stub does not support the packet. */
833 return PACKET_UNKNOWN
;
836 static enum packet_result
837 packet_ok (const char *buf
, struct packet_config
*config
)
839 enum packet_result result
;
841 result
= packet_check_result (buf
);
846 /* The stub recognized the packet request. */
847 switch (config
->support
)
849 case PACKET_SUPPORT_UNKNOWN
:
851 fprintf_unfiltered (gdb_stdlog
,
852 "Packet %s (%s) is supported\n",
853 config
->name
, config
->title
);
854 config
->support
= PACKET_ENABLE
;
857 internal_error (__FILE__
, __LINE__
,
858 _("packet_ok: attempt to use a disabled packet"));
865 /* The stub does not support the packet. */
866 switch (config
->support
)
869 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
870 /* If the stub previously indicated that the packet was
871 supported then there is a protocol error.. */
872 error (_("Protocol error: %s (%s) conflicting enabled responses."),
873 config
->name
, config
->title
);
875 /* The user set it wrong. */
876 error (_("Enabled packet %s (%s) not recognized by stub"),
877 config
->name
, config
->title
);
879 case PACKET_SUPPORT_UNKNOWN
:
881 fprintf_unfiltered (gdb_stdlog
,
882 "Packet %s (%s) is NOT supported\n",
883 config
->name
, config
->title
);
884 config
->support
= PACKET_DISABLE
;
907 PACKET_qXfer_features
,
908 PACKET_qXfer_memory_map
,
909 PACKET_qXfer_spu_read
,
910 PACKET_qXfer_spu_write
,
917 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
920 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
921 struct cmd_list_element
*c
)
923 struct packet_config
*packet
;
925 for (packet
= remote_protocol_packets
;
926 packet
< &remote_protocol_packets
[PACKET_MAX
];
929 if (&packet
->detect
== c
->var
)
931 update_packet_config (packet
);
935 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
940 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
941 struct cmd_list_element
*c
,
944 struct packet_config
*packet
;
946 for (packet
= remote_protocol_packets
;
947 packet
< &remote_protocol_packets
[PACKET_MAX
];
950 if (&packet
->detect
== c
->var
)
952 show_packet_config_cmd (packet
);
956 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
960 /* Should we try one of the 'Z' requests? */
964 Z_PACKET_SOFTWARE_BP
,
965 Z_PACKET_HARDWARE_BP
,
972 /* For compatibility with older distributions. Provide a ``set remote
973 Z-packet ...'' command that updates all the Z packet types. */
975 static enum auto_boolean remote_Z_packet_detect
;
978 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
979 struct cmd_list_element
*c
)
982 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
984 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
985 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
990 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
991 struct cmd_list_element
*c
,
995 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
997 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1001 /* Should we try the 'ThreadInfo' query packet?
1003 This variable (NOT available to the user: auto-detect only!)
1004 determines whether GDB will use the new, simpler "ThreadInfo"
1005 query or the older, more complex syntax for thread queries.
1006 This is an auto-detect variable (set to true at each connect,
1007 and set to false when the target fails to recognize it). */
1009 static int use_threadinfo_query
;
1010 static int use_threadextra_query
;
1012 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1013 static struct async_signal_handler
*sigint_remote_twice_token
;
1014 static struct async_signal_handler
*sigint_remote_token
;
1016 /* These are pointers to hook functions that may be set in order to
1017 modify resume/wait behavior for a particular architecture. */
1019 void (*deprecated_target_resume_hook
) (void);
1020 void (*deprecated_target_wait_loop_hook
) (void);
1024 /* These are the threads which we last sent to the remote system.
1025 -1 for all or -2 for not sent yet. */
1026 static int general_thread
;
1027 static int continue_thread
;
1029 /* Call this function as a result of
1030 1) A halt indication (T packet) containing a thread id
1031 2) A direct query of currthread
1032 3) Successful execution of set thread
1036 record_currthread (int currthread
)
1038 general_thread
= currthread
;
1040 /* If this is a new thread, add it to GDB's thread list.
1041 If we leave it up to WFI to do this, bad things will happen. */
1042 if (!in_thread_list (pid_to_ptid (currthread
)))
1044 add_thread (pid_to_ptid (currthread
));
1045 ui_out_text (uiout
, "[New ");
1046 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
1047 ui_out_text (uiout
, "]\n");
1051 static char *last_pass_packet
;
1053 /* If 'QPassSignals' is supported, tell the remote stub what signals
1054 it can simply pass through to the inferior without reporting. */
1057 remote_pass_signals (void)
1059 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1061 char *pass_packet
, *p
;
1062 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1065 gdb_assert (numsigs
< 256);
1066 for (i
= 0; i
< numsigs
; i
++)
1068 if (signal_stop_state (i
) == 0
1069 && signal_print_state (i
) == 0
1070 && signal_pass_state (i
) == 1)
1073 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1074 strcpy (pass_packet
, "QPassSignals:");
1075 p
= pass_packet
+ strlen (pass_packet
);
1076 for (i
= 0; i
< numsigs
; i
++)
1078 if (signal_stop_state (i
) == 0
1079 && signal_print_state (i
) == 0
1080 && signal_pass_state (i
) == 1)
1083 *p
++ = tohex (i
>> 4);
1084 *p
++ = tohex (i
& 15);
1093 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1095 struct remote_state
*rs
= get_remote_state ();
1096 char *buf
= rs
->buf
;
1098 putpkt (pass_packet
);
1099 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1100 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1101 if (last_pass_packet
)
1102 xfree (last_pass_packet
);
1103 last_pass_packet
= pass_packet
;
1106 xfree (pass_packet
);
1110 #define MAGIC_NULL_PID 42000
1113 set_thread (int th
, int gen
)
1115 struct remote_state
*rs
= get_remote_state ();
1116 char *buf
= rs
->buf
;
1117 int state
= gen
? general_thread
: continue_thread
;
1123 buf
[1] = gen
? 'g' : 'c';
1124 if (th
== MAGIC_NULL_PID
)
1130 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
1132 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
1134 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1136 general_thread
= th
;
1138 continue_thread
= th
;
1141 /* Return nonzero if the thread TH is still alive on the remote system. */
1144 remote_thread_alive (ptid_t ptid
)
1146 struct remote_state
*rs
= get_remote_state ();
1147 int tid
= PIDGET (ptid
);
1150 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1152 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1154 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1155 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1158 /* About these extended threadlist and threadinfo packets. They are
1159 variable length packets but, the fields within them are often fixed
1160 length. They are redundent enough to send over UDP as is the
1161 remote protocol in general. There is a matching unit test module
1164 #define OPAQUETHREADBYTES 8
1166 /* a 64 bit opaque identifier */
1167 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1169 /* WARNING: This threadref data structure comes from the remote O.S.,
1170 libstub protocol encoding, and remote.c. it is not particularly
1173 /* Right now, the internal structure is int. We want it to be bigger.
1177 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1179 /* gdb_ext_thread_info is an internal GDB data structure which is
1180 equivalent to the reply of the remote threadinfo packet. */
1182 struct gdb_ext_thread_info
1184 threadref threadid
; /* External form of thread reference. */
1185 int active
; /* Has state interesting to GDB?
1187 char display
[256]; /* Brief state display, name,
1188 blocked/suspended. */
1189 char shortname
[32]; /* To be used to name threads. */
1190 char more_display
[256]; /* Long info, statistics, queue depth,
1194 /* The volume of remote transfers can be limited by submitting
1195 a mask containing bits specifying the desired information.
1196 Use a union of these values as the 'selection' parameter to
1197 get_thread_info. FIXME: Make these TAG names more thread specific.
1200 #define TAG_THREADID 1
1201 #define TAG_EXISTS 2
1202 #define TAG_DISPLAY 4
1203 #define TAG_THREADNAME 8
1204 #define TAG_MOREDISPLAY 16
1206 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1208 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1210 static char *unpack_nibble (char *buf
, int *val
);
1212 static char *pack_nibble (char *buf
, int nibble
);
1214 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1216 static char *unpack_byte (char *buf
, int *value
);
1218 static char *pack_int (char *buf
, int value
);
1220 static char *unpack_int (char *buf
, int *value
);
1222 static char *unpack_string (char *src
, char *dest
, int length
);
1224 static char *pack_threadid (char *pkt
, threadref
*id
);
1226 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1228 void int_to_threadref (threadref
*id
, int value
);
1230 static int threadref_to_int (threadref
*ref
);
1232 static void copy_threadref (threadref
*dest
, threadref
*src
);
1234 static int threadmatch (threadref
*dest
, threadref
*src
);
1236 static char *pack_threadinfo_request (char *pkt
, int mode
,
1239 static int remote_unpack_thread_info_response (char *pkt
,
1240 threadref
*expectedref
,
1241 struct gdb_ext_thread_info
1245 static int remote_get_threadinfo (threadref
*threadid
,
1246 int fieldset
, /*TAG mask */
1247 struct gdb_ext_thread_info
*info
);
1249 static char *pack_threadlist_request (char *pkt
, int startflag
,
1251 threadref
*nextthread
);
1253 static int parse_threadlist_response (char *pkt
,
1255 threadref
*original_echo
,
1256 threadref
*resultlist
,
1259 static int remote_get_threadlist (int startflag
,
1260 threadref
*nextthread
,
1264 threadref
*threadlist
);
1266 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1268 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1269 void *context
, int looplimit
);
1271 static int remote_newthread_step (threadref
*ref
, void *context
);
1273 /* Encode 64 bits in 16 chars of hex. */
1275 static const char hexchars
[] = "0123456789abcdef";
1278 ishex (int ch
, int *val
)
1280 if ((ch
>= 'a') && (ch
<= 'f'))
1282 *val
= ch
- 'a' + 10;
1285 if ((ch
>= 'A') && (ch
<= 'F'))
1287 *val
= ch
- 'A' + 10;
1290 if ((ch
>= '0') && (ch
<= '9'))
1301 if (ch
>= 'a' && ch
<= 'f')
1302 return ch
- 'a' + 10;
1303 if (ch
>= '0' && ch
<= '9')
1305 if (ch
>= 'A' && ch
<= 'F')
1306 return ch
- 'A' + 10;
1311 stub_unpack_int (char *buff
, int fieldlength
)
1318 nibble
= stubhex (*buff
++);
1322 retval
= retval
<< 4;
1328 unpack_varlen_hex (char *buff
, /* packet to parse */
1332 ULONGEST retval
= 0;
1334 while (ishex (*buff
, &nibble
))
1337 retval
= retval
<< 4;
1338 retval
|= nibble
& 0x0f;
1345 unpack_nibble (char *buf
, int *val
)
1347 ishex (*buf
++, val
);
1352 pack_nibble (char *buf
, int nibble
)
1354 *buf
++ = hexchars
[(nibble
& 0x0f)];
1359 pack_hex_byte (char *pkt
, int byte
)
1361 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1362 *pkt
++ = hexchars
[(byte
& 0xf)];
1367 unpack_byte (char *buf
, int *value
)
1369 *value
= stub_unpack_int (buf
, 2);
1374 pack_int (char *buf
, int value
)
1376 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1377 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1378 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1379 buf
= pack_hex_byte (buf
, (value
& 0xff));
1384 unpack_int (char *buf
, int *value
)
1386 *value
= stub_unpack_int (buf
, 8);
1390 #if 0 /* Currently unused, uncomment when needed. */
1391 static char *pack_string (char *pkt
, char *string
);
1394 pack_string (char *pkt
, char *string
)
1399 len
= strlen (string
);
1401 len
= 200; /* Bigger than most GDB packets, junk??? */
1402 pkt
= pack_hex_byte (pkt
, len
);
1406 if ((ch
== '\0') || (ch
== '#'))
1407 ch
= '*'; /* Protect encapsulation. */
1412 #endif /* 0 (unused) */
1415 unpack_string (char *src
, char *dest
, int length
)
1424 pack_threadid (char *pkt
, threadref
*id
)
1427 unsigned char *altid
;
1429 altid
= (unsigned char *) id
;
1430 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1432 pkt
= pack_hex_byte (pkt
, *altid
++);
1438 unpack_threadid (char *inbuf
, threadref
*id
)
1441 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1444 altref
= (char *) id
;
1446 while (inbuf
< limit
)
1448 x
= stubhex (*inbuf
++);
1449 y
= stubhex (*inbuf
++);
1450 *altref
++ = (x
<< 4) | y
;
1455 /* Externally, threadrefs are 64 bits but internally, they are still
1456 ints. This is due to a mismatch of specifications. We would like
1457 to use 64bit thread references internally. This is an adapter
1461 int_to_threadref (threadref
*id
, int value
)
1463 unsigned char *scan
;
1465 scan
= (unsigned char *) id
;
1471 *scan
++ = (value
>> 24) & 0xff;
1472 *scan
++ = (value
>> 16) & 0xff;
1473 *scan
++ = (value
>> 8) & 0xff;
1474 *scan
++ = (value
& 0xff);
1478 threadref_to_int (threadref
*ref
)
1481 unsigned char *scan
;
1487 value
= (value
<< 8) | ((*scan
++) & 0xff);
1492 copy_threadref (threadref
*dest
, threadref
*src
)
1495 unsigned char *csrc
, *cdest
;
1497 csrc
= (unsigned char *) src
;
1498 cdest
= (unsigned char *) dest
;
1505 threadmatch (threadref
*dest
, threadref
*src
)
1507 /* Things are broken right now, so just assume we got a match. */
1509 unsigned char *srcp
, *destp
;
1511 srcp
= (char *) src
;
1512 destp
= (char *) dest
;
1516 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1523 threadid:1, # always request threadid
1530 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1533 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1535 *pkt
++ = 'q'; /* Info Query */
1536 *pkt
++ = 'P'; /* process or thread info */
1537 pkt
= pack_int (pkt
, mode
); /* mode */
1538 pkt
= pack_threadid (pkt
, id
); /* threadid */
1539 *pkt
= '\0'; /* terminate */
1543 /* These values tag the fields in a thread info response packet. */
1544 /* Tagging the fields allows us to request specific fields and to
1545 add more fields as time goes by. */
1547 #define TAG_THREADID 1 /* Echo the thread identifier. */
1548 #define TAG_EXISTS 2 /* Is this process defined enough to
1549 fetch registers and its stack? */
1550 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1551 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1552 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1556 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1557 struct gdb_ext_thread_info
*info
)
1559 struct remote_state
*rs
= get_remote_state ();
1563 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1566 /* info->threadid = 0; FIXME: implement zero_threadref. */
1568 info
->display
[0] = '\0';
1569 info
->shortname
[0] = '\0';
1570 info
->more_display
[0] = '\0';
1572 /* Assume the characters indicating the packet type have been
1574 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1575 pkt
= unpack_threadid (pkt
, &ref
);
1578 warning (_("Incomplete response to threadinfo request."));
1579 if (!threadmatch (&ref
, expectedref
))
1580 { /* This is an answer to a different request. */
1581 warning (_("ERROR RMT Thread info mismatch."));
1584 copy_threadref (&info
->threadid
, &ref
);
1586 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1588 /* Packets are terminated with nulls. */
1589 while ((pkt
< limit
) && mask
&& *pkt
)
1591 pkt
= unpack_int (pkt
, &tag
); /* tag */
1592 pkt
= unpack_byte (pkt
, &length
); /* length */
1593 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1595 warning (_("ERROR RMT: threadinfo tag mismatch."));
1599 if (tag
== TAG_THREADID
)
1603 warning (_("ERROR RMT: length of threadid is not 16."));
1607 pkt
= unpack_threadid (pkt
, &ref
);
1608 mask
= mask
& ~TAG_THREADID
;
1611 if (tag
== TAG_EXISTS
)
1613 info
->active
= stub_unpack_int (pkt
, length
);
1615 mask
= mask
& ~(TAG_EXISTS
);
1618 warning (_("ERROR RMT: 'exists' length too long."));
1624 if (tag
== TAG_THREADNAME
)
1626 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1627 mask
= mask
& ~TAG_THREADNAME
;
1630 if (tag
== TAG_DISPLAY
)
1632 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1633 mask
= mask
& ~TAG_DISPLAY
;
1636 if (tag
== TAG_MOREDISPLAY
)
1638 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1639 mask
= mask
& ~TAG_MOREDISPLAY
;
1642 warning (_("ERROR RMT: unknown thread info tag."));
1643 break; /* Not a tag we know about. */
1649 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1650 struct gdb_ext_thread_info
*info
)
1652 struct remote_state
*rs
= get_remote_state ();
1655 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1657 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1658 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1663 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1666 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1667 threadref
*nextthread
)
1669 *pkt
++ = 'q'; /* info query packet */
1670 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1671 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1672 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1673 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1678 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1681 parse_threadlist_response (char *pkt
, int result_limit
,
1682 threadref
*original_echo
, threadref
*resultlist
,
1685 struct remote_state
*rs
= get_remote_state ();
1687 int count
, resultcount
, done
;
1690 /* Assume the 'q' and 'M chars have been stripped. */
1691 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1692 /* done parse past here */
1693 pkt
= unpack_byte (pkt
, &count
); /* count field */
1694 pkt
= unpack_nibble (pkt
, &done
);
1695 /* The first threadid is the argument threadid. */
1696 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1697 while ((count
-- > 0) && (pkt
< limit
))
1699 pkt
= unpack_threadid (pkt
, resultlist
++);
1700 if (resultcount
++ >= result_limit
)
1709 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1710 int *done
, int *result_count
, threadref
*threadlist
)
1712 struct remote_state
*rs
= get_remote_state ();
1713 static threadref echo_nextthread
;
1716 /* Trancate result limit to be smaller than the packet size. */
1717 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1718 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1720 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1722 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1725 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1728 if (!threadmatch (&echo_nextthread
, nextthread
))
1730 /* FIXME: This is a good reason to drop the packet. */
1731 /* Possably, there is a duplicate response. */
1733 retransmit immediatly - race conditions
1734 retransmit after timeout - yes
1736 wait for packet, then exit
1738 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1739 return 0; /* I choose simply exiting. */
1741 if (*result_count
<= 0)
1745 warning (_("RMT ERROR : failed to get remote thread list."));
1748 return result
; /* break; */
1750 if (*result_count
> result_limit
)
1753 warning (_("RMT ERROR: threadlist response longer than requested."));
1759 /* This is the interface between remote and threads, remotes upper
1762 /* remote_find_new_threads retrieves the thread list and for each
1763 thread in the list, looks up the thread in GDB's internal list,
1764 ading the thread if it does not already exist. This involves
1765 getting partial thread lists from the remote target so, polling the
1766 quit_flag is required. */
1769 /* About this many threadisds fit in a packet. */
1771 #define MAXTHREADLISTRESULTS 32
1774 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1777 int done
, i
, result_count
;
1781 static threadref nextthread
;
1782 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1787 if (loopcount
++ > looplimit
)
1790 warning (_("Remote fetch threadlist -infinite loop-."));
1793 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1794 &done
, &result_count
, resultthreadlist
))
1799 /* Clear for later iterations. */
1801 /* Setup to resume next batch of thread references, set nextthread. */
1802 if (result_count
>= 1)
1803 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1805 while (result_count
--)
1806 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1813 remote_newthread_step (threadref
*ref
, void *context
)
1817 ptid
= pid_to_ptid (threadref_to_int (ref
));
1819 if (!in_thread_list (ptid
))
1821 return 1; /* continue iterator */
1824 #define CRAZY_MAX_THREADS 1000
1827 remote_current_thread (ptid_t oldpid
)
1829 struct remote_state
*rs
= get_remote_state ();
1832 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1833 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1834 /* Use strtoul here, so we'll correctly parse values whose highest
1835 bit is set. The protocol carries them as a simple series of
1836 hex digits; in the absence of a sign, strtol will see such
1837 values as positive numbers out of range for signed 'long', and
1838 return LONG_MAX to indicate an overflow. */
1839 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1844 /* Find new threads for info threads command.
1845 * Original version, using John Metzler's thread protocol.
1849 remote_find_new_threads (void)
1851 remote_threadlist_iterator (remote_newthread_step
, 0,
1853 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1854 inferior_ptid
= remote_current_thread (inferior_ptid
);
1858 * Find all threads for info threads command.
1859 * Uses new thread protocol contributed by Cisco.
1860 * Falls back and attempts to use the older method (above)
1861 * if the target doesn't respond to the new method.
1865 remote_threads_info (void)
1867 struct remote_state
*rs
= get_remote_state ();
1871 if (remote_desc
== 0) /* paranoia */
1872 error (_("Command can only be used when connected to the remote target."));
1874 if (use_threadinfo_query
)
1876 putpkt ("qfThreadInfo");
1877 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1879 if (bufp
[0] != '\0') /* q packet recognized */
1881 while (*bufp
++ == 'm') /* reply contains one or more TID */
1885 /* Use strtoul here, so we'll correctly parse values
1886 whose highest bit is set. The protocol carries
1887 them as a simple series of hex digits; in the
1888 absence of a sign, strtol will see such values as
1889 positive numbers out of range for signed 'long',
1890 and return LONG_MAX to indicate an overflow. */
1891 tid
= strtoul (bufp
, &bufp
, 16);
1892 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1893 add_thread (pid_to_ptid (tid
));
1895 while (*bufp
++ == ','); /* comma-separated list */
1896 putpkt ("qsThreadInfo");
1897 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1904 /* Else fall back to old method based on jmetzler protocol. */
1905 use_threadinfo_query
= 0;
1906 remote_find_new_threads ();
1911 * Collect a descriptive string about the given thread.
1912 * The target may say anything it wants to about the thread
1913 * (typically info about its blocked / runnable state, name, etc.).
1914 * This string will appear in the info threads display.
1916 * Optional: targets are not required to implement this function.
1920 remote_threads_extra_info (struct thread_info
*tp
)
1922 struct remote_state
*rs
= get_remote_state ();
1926 struct gdb_ext_thread_info threadinfo
;
1927 static char display_buf
[100]; /* arbitrary... */
1928 int n
= 0; /* position in display_buf */
1930 if (remote_desc
== 0) /* paranoia */
1931 internal_error (__FILE__
, __LINE__
,
1932 _("remote_threads_extra_info"));
1934 if (use_threadextra_query
)
1936 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1939 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1940 if (rs
->buf
[0] != 0)
1942 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1943 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1944 display_buf
[result
] = '\0';
1949 /* If the above query fails, fall back to the old method. */
1950 use_threadextra_query
= 0;
1951 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1952 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1953 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1954 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1955 if (threadinfo
.active
)
1957 if (*threadinfo
.shortname
)
1958 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1959 " Name: %s,", threadinfo
.shortname
);
1960 if (*threadinfo
.display
)
1961 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1962 " State: %s,", threadinfo
.display
);
1963 if (*threadinfo
.more_display
)
1964 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1965 " Priority: %s", threadinfo
.more_display
);
1969 /* For purely cosmetic reasons, clear up trailing commas. */
1970 if (',' == display_buf
[n
-1])
1971 display_buf
[n
-1] = ' ';
1979 /* Restart the remote side; this is an extended protocol operation. */
1982 extended_remote_restart (void)
1984 struct remote_state
*rs
= get_remote_state ();
1986 /* Send the restart command; for reasons I don't understand the
1987 remote side really expects a number after the "R". */
1988 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1991 remote_fileio_reset ();
1993 /* Now query for status so this looks just like we restarted
1994 gdbserver from scratch. */
1996 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1999 /* Clean up connection to a remote debugger. */
2002 remote_close (int quitting
)
2005 serial_close (remote_desc
);
2009 /* Query the remote side for the text, data and bss offsets. */
2014 struct remote_state
*rs
= get_remote_state ();
2017 int lose
, num_segments
= 0, do_sections
, do_segments
;
2018 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
2019 struct section_offsets
*offs
;
2020 struct symfile_segment_data
*data
;
2022 if (symfile_objfile
== NULL
)
2025 putpkt ("qOffsets");
2026 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2029 if (buf
[0] == '\000')
2030 return; /* Return silently. Stub doesn't support
2034 warning (_("Remote failure reply: %s"), buf
);
2038 /* Pick up each field in turn. This used to be done with scanf, but
2039 scanf will make trouble if CORE_ADDR size doesn't match
2040 conversion directives correctly. The following code will work
2041 with any size of CORE_ADDR. */
2042 text_addr
= data_addr
= bss_addr
= 0;
2046 if (strncmp (ptr
, "Text=", 5) == 0)
2049 /* Don't use strtol, could lose on big values. */
2050 while (*ptr
&& *ptr
!= ';')
2051 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2053 if (strncmp (ptr
, ";Data=", 6) == 0)
2056 while (*ptr
&& *ptr
!= ';')
2057 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2062 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2065 while (*ptr
&& *ptr
!= ';')
2066 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2068 if (bss_addr
!= data_addr
)
2069 warning (_("Target reported unsupported offsets: %s"), buf
);
2074 else if (strncmp (ptr
, "TextSeg=", 8) == 0)
2077 /* Don't use strtol, could lose on big values. */
2078 while (*ptr
&& *ptr
!= ';')
2079 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2082 if (strncmp (ptr
, ";DataSeg=", 9) == 0)
2085 while (*ptr
&& *ptr
!= ';')
2086 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2094 error (_("Malformed response to offset query, %s"), buf
);
2095 else if (*ptr
!= '\0')
2096 warning (_("Target reported unsupported offsets: %s"), buf
);
2098 offs
= ((struct section_offsets
*)
2099 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2100 memcpy (offs
, symfile_objfile
->section_offsets
,
2101 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2103 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
2104 do_segments
= (data
!= NULL
);
2105 do_sections
= num_segments
== 0;
2107 /* Text= and Data= specify offsets for the text and data sections,
2108 but symfile_map_offsets_to_segments expects base addresses
2109 instead of offsets. If we have two segments, we can still
2110 try to relocate the whole segments instead of just ".text"
2112 if (num_segments
== 0)
2115 if (data
== NULL
|| data
->num_segments
!= 2)
2119 segments
[0] = data
->segment_bases
[0] + text_addr
;
2120 segments
[1] = data
->segment_bases
[1] + data_addr
;
2126 segments
[0] = text_addr
;
2127 segments
[1] = data_addr
;
2132 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
2133 offs
, num_segments
, segments
);
2135 if (ret
== 0 && !do_sections
)
2136 error (_("Can not handle qOffsets TextSeg response with this symbol file"));
2142 free_symfile_segment_data (data
);
2146 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2148 /* This is a temporary kludge to force data and bss to use the same offsets
2149 because that's what nlmconv does now. The real solution requires changes
2150 to the stub and remote.c that I don't have time to do right now. */
2152 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2153 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2156 objfile_relocate (symfile_objfile
, offs
);
2159 /* Stub for catch_exception. */
2162 remote_start_remote (struct ui_out
*uiout
, void *from_tty_p
)
2164 int from_tty
= * (int *) from_tty_p
;
2166 immediate_quit
++; /* Allow user to interrupt it. */
2168 /* Ack any packet which the remote side has already sent. */
2169 serial_write (remote_desc
, "+", 1);
2171 /* Let the stub know that we want it to return the thread. */
2174 inferior_ptid
= remote_current_thread (inferior_ptid
);
2176 get_offsets (); /* Get text, data & bss offsets. */
2178 putpkt ("?"); /* Initiate a query from remote machine. */
2181 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
2184 /* Open a connection to a remote debugger.
2185 NAME is the filename used for communication. */
2188 remote_open (char *name
, int from_tty
)
2190 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2193 /* Just like remote_open, but with asynchronous support. */
2195 remote_async_open (char *name
, int from_tty
)
2197 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2200 /* Open a connection to a remote debugger using the extended
2201 remote gdb protocol. NAME is the filename used for communication. */
2204 extended_remote_open (char *name
, int from_tty
)
2206 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2210 /* Just like extended_remote_open, but with asynchronous support. */
2212 extended_remote_async_open (char *name
, int from_tty
)
2214 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2215 1 /*extended_p */, 1 /* async_p */);
2218 /* Generic code for opening a connection to a remote target. */
2221 init_all_packet_configs (void)
2224 for (i
= 0; i
< PACKET_MAX
; i
++)
2225 update_packet_config (&remote_protocol_packets
[i
]);
2228 /* Symbol look-up. */
2231 remote_check_symbols (struct objfile
*objfile
)
2233 struct remote_state
*rs
= get_remote_state ();
2234 char *msg
, *reply
, *tmp
;
2235 struct minimal_symbol
*sym
;
2238 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2241 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2242 because we need both at the same time. */
2243 msg
= alloca (get_remote_packet_size ());
2245 /* Invite target to request symbol lookups. */
2247 putpkt ("qSymbol::");
2248 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2249 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2252 while (strncmp (reply
, "qSymbol:", 8) == 0)
2255 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2257 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2259 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2261 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2262 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2265 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2270 static struct serial
*
2271 remote_serial_open (char *name
)
2273 static int udp_warning
= 0;
2275 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2276 of in ser-tcp.c, because it is the remote protocol assuming that the
2277 serial connection is reliable and not the serial connection promising
2279 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2282 The remote protocol may be unreliable over UDP.\n\
2283 Some events may be lost, rendering further debugging impossible."));
2287 return serial_open (name
);
2290 /* This type describes each known response to the qSupported
2292 struct protocol_feature
2294 /* The name of this protocol feature. */
2297 /* The default for this protocol feature. */
2298 enum packet_support default_support
;
2300 /* The function to call when this feature is reported, or after
2301 qSupported processing if the feature is not supported.
2302 The first argument points to this structure. The second
2303 argument indicates whether the packet requested support be
2304 enabled, disabled, or probed (or the default, if this function
2305 is being called at the end of processing and this feature was
2306 not reported). The third argument may be NULL; if not NULL, it
2307 is a NUL-terminated string taken from the packet following
2308 this feature's name and an equals sign. */
2309 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2312 /* The corresponding packet for this feature. Only used if
2313 FUNC is remote_supported_packet. */
2318 remote_supported_packet (const struct protocol_feature
*feature
,
2319 enum packet_support support
,
2320 const char *argument
)
2324 warning (_("Remote qSupported response supplied an unexpected value for"
2325 " \"%s\"."), feature
->name
);
2329 if (remote_protocol_packets
[feature
->packet
].support
2330 == PACKET_SUPPORT_UNKNOWN
)
2331 remote_protocol_packets
[feature
->packet
].support
= support
;
2335 remote_packet_size (const struct protocol_feature
*feature
,
2336 enum packet_support support
, const char *value
)
2338 struct remote_state
*rs
= get_remote_state ();
2343 if (support
!= PACKET_ENABLE
)
2346 if (value
== NULL
|| *value
== '\0')
2348 warning (_("Remote target reported \"%s\" without a size."),
2354 packet_size
= strtol (value
, &value_end
, 16);
2355 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2357 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2358 feature
->name
, value
);
2362 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2364 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2365 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2366 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2369 /* Record the new maximum packet size. */
2370 rs
->explicit_packet_size
= packet_size
;
2373 static struct protocol_feature remote_protocol_features
[] = {
2374 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2375 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2376 PACKET_qXfer_auxv
},
2377 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2378 PACKET_qXfer_features
},
2379 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2380 PACKET_qXfer_memory_map
},
2381 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
2382 PACKET_qXfer_spu_read
},
2383 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
2384 PACKET_qXfer_spu_write
},
2385 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2386 PACKET_QPassSignals
},
2390 remote_query_supported (void)
2392 struct remote_state
*rs
= get_remote_state ();
2395 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2397 /* The packet support flags are handled differently for this packet
2398 than for most others. We treat an error, a disabled packet, and
2399 an empty response identically: any features which must be reported
2400 to be used will be automatically disabled. An empty buffer
2401 accomplishes this, since that is also the representation for a list
2402 containing no features. */
2405 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2407 putpkt ("qSupported");
2408 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2410 /* If an error occured, warn, but do not return - just reset the
2411 buffer to empty and go on to disable features. */
2412 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2415 warning (_("Remote failure reply: %s"), rs
->buf
);
2420 memset (seen
, 0, sizeof (seen
));
2425 enum packet_support is_supported
;
2426 char *p
, *end
, *name_end
, *value
;
2428 /* First separate out this item from the rest of the packet. If
2429 there's another item after this, we overwrite the separator
2430 (terminated strings are much easier to work with). */
2432 end
= strchr (p
, ';');
2435 end
= p
+ strlen (p
);
2445 warning (_("empty item in \"qSupported\" response"));
2450 name_end
= strchr (p
, '=');
2453 /* This is a name=value entry. */
2454 is_supported
= PACKET_ENABLE
;
2455 value
= name_end
+ 1;
2464 is_supported
= PACKET_ENABLE
;
2468 is_supported
= PACKET_DISABLE
;
2472 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2476 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2482 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2483 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2485 const struct protocol_feature
*feature
;
2488 feature
= &remote_protocol_features
[i
];
2489 feature
->func (feature
, is_supported
, value
);
2494 /* If we increased the packet size, make sure to increase the global
2495 buffer size also. We delay this until after parsing the entire
2496 qSupported packet, because this is the same buffer we were
2498 if (rs
->buf_size
< rs
->explicit_packet_size
)
2500 rs
->buf_size
= rs
->explicit_packet_size
;
2501 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2504 /* Handle the defaults for unmentioned features. */
2505 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2508 const struct protocol_feature
*feature
;
2510 feature
= &remote_protocol_features
[i
];
2511 feature
->func (feature
, feature
->default_support
, NULL
);
2517 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2518 int extended_p
, int async_p
)
2520 struct remote_state
*rs
= get_remote_state ();
2522 error (_("To open a remote debug connection, you need to specify what\n"
2523 "serial device is attached to the remote system\n"
2524 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2526 /* See FIXME above. */
2528 wait_forever_enabled_p
= 1;
2530 target_preopen (from_tty
);
2532 unpush_target (target
);
2534 /* Make sure we send the passed signals list the next time we resume. */
2535 xfree (last_pass_packet
);
2536 last_pass_packet
= NULL
;
2538 remote_fileio_reset ();
2539 reopen_exec_file ();
2542 remote_desc
= remote_serial_open (name
);
2544 perror_with_name (name
);
2546 if (baud_rate
!= -1)
2548 if (serial_setbaudrate (remote_desc
, baud_rate
))
2550 /* The requested speed could not be set. Error out to
2551 top level after closing remote_desc. Take care to
2552 set remote_desc to NULL to avoid closing remote_desc
2554 serial_close (remote_desc
);
2556 perror_with_name (name
);
2560 serial_raw (remote_desc
);
2562 /* If there is something sitting in the buffer we might take it as a
2563 response to a command, which would be bad. */
2564 serial_flush_input (remote_desc
);
2568 puts_filtered ("Remote debugging using ");
2569 puts_filtered (name
);
2570 puts_filtered ("\n");
2572 push_target (target
); /* Switch to using remote target now. */
2574 /* Reset the target state; these things will be queried either by
2575 remote_query_supported or as they are needed. */
2576 init_all_packet_configs ();
2577 rs
->explicit_packet_size
= 0;
2579 general_thread
= -2;
2580 continue_thread
= -2;
2582 /* Probe for ability to use "ThreadInfo" query, as required. */
2583 use_threadinfo_query
= 1;
2584 use_threadextra_query
= 1;
2586 /* The first packet we send to the target is the optional "supported
2587 packets" request. If the target can answer this, it will tell us
2588 which later probes to skip. */
2589 remote_query_supported ();
2591 /* Next, if the target can specify a description, read it. We do
2592 this before anything involving memory or registers. */
2593 target_find_description ();
2595 /* Without this, some commands which require an active target (such
2596 as kill) won't work. This variable serves (at least) double duty
2597 as both the pid of the target process (if it has such), and as a
2598 flag indicating that a target is active. These functions should
2599 be split out into seperate variables, especially since GDB will
2600 someday have a notion of debugging several processes. */
2602 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2606 /* With this target we start out by owning the terminal. */
2607 remote_async_terminal_ours_p
= 1;
2609 /* FIXME: cagney/1999-09-23: During the initial connection it is
2610 assumed that the target is already ready and able to respond to
2611 requests. Unfortunately remote_start_remote() eventually calls
2612 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2613 around this. Eventually a mechanism that allows
2614 wait_for_inferior() to expect/get timeouts will be
2616 wait_forever_enabled_p
= 0;
2619 /* First delete any symbols previously loaded from shared libraries. */
2620 no_shared_libraries (NULL
, 0);
2622 /* Start the remote connection. If error() or QUIT, discard this
2623 target (we'd otherwise be in an inconsistent state) and then
2624 propogate the error on up the exception chain. This ensures that
2625 the caller doesn't stumble along blindly assuming that the
2626 function succeeded. The CLI doesn't have this problem but other
2627 UI's, such as MI do.
2629 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2630 this function should return an error indication letting the
2631 caller restore the previous state. Unfortunately the command
2632 ``target remote'' is directly wired to this function making that
2633 impossible. On a positive note, the CLI side of this problem has
2634 been fixed - the function set_cmd_context() makes it possible for
2635 all the ``target ....'' commands to share a common callback
2636 function. See cli-dump.c. */
2638 struct gdb_exception ex
2639 = catch_exception (uiout
, remote_start_remote
, &from_tty
,
2645 wait_forever_enabled_p
= 1;
2646 throw_exception (ex
);
2651 wait_forever_enabled_p
= 1;
2655 /* Tell the remote that we are using the extended protocol. */
2657 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2660 if (exec_bfd
) /* No use without an exec file. */
2661 remote_check_symbols (symfile_objfile
);
2664 /* This takes a program previously attached to and detaches it. After
2665 this is done, GDB can be used to debug some other program. We
2666 better not have left any breakpoints in the target program or it'll
2667 die when it hits one. */
2670 remote_detach (char *args
, int from_tty
)
2672 struct remote_state
*rs
= get_remote_state ();
2675 error (_("Argument given to \"detach\" when remotely debugging."));
2677 /* Tell the remote target to detach. */
2678 strcpy (rs
->buf
, "D");
2680 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2682 if (rs
->buf
[0] == 'E')
2683 error (_("Can't detach process."));
2685 /* Unregister the file descriptor from the event loop. */
2686 if (target_is_async_p ())
2687 serial_async (remote_desc
, NULL
, 0);
2689 target_mourn_inferior ();
2691 puts_filtered ("Ending remote debugging.\n");
2694 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2697 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2700 error (_("Argument given to \"detach\" when remotely debugging."));
2702 /* Unregister the file descriptor from the event loop. */
2703 if (target_is_async_p ())
2704 serial_async (remote_desc
, NULL
, 0);
2706 target_mourn_inferior ();
2708 puts_filtered ("Ending remote debugging.\n");
2711 /* Convert hex digit A to a number. */
2716 if (a
>= '0' && a
<= '9')
2718 else if (a
>= 'a' && a
<= 'f')
2719 return a
- 'a' + 10;
2720 else if (a
>= 'A' && a
<= 'F')
2721 return a
- 'A' + 10;
2723 error (_("Reply contains invalid hex digit %d"), a
);
2727 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2731 for (i
= 0; i
< count
; i
++)
2733 if (hex
[0] == 0 || hex
[1] == 0)
2735 /* Hex string is short, or of uneven length.
2736 Return the count that has been converted so far. */
2739 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2745 /* Convert number NIB to a hex digit. */
2753 return 'a' + nib
- 10;
2757 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2760 /* May use a length, or a nul-terminated string as input. */
2762 count
= strlen ((char *) bin
);
2764 for (i
= 0; i
< count
; i
++)
2766 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2767 *hex
++ = tohex (*bin
++ & 0xf);
2773 /* Check for the availability of vCont. This function should also check
2777 remote_vcont_probe (struct remote_state
*rs
)
2781 strcpy (rs
->buf
, "vCont?");
2783 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2786 /* Make sure that the features we assume are supported. */
2787 if (strncmp (buf
, "vCont", 5) == 0)
2790 int support_s
, support_S
, support_c
, support_C
;
2796 while (p
&& *p
== ';')
2799 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2801 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2803 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2805 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2808 p
= strchr (p
, ';');
2811 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2812 BUF will make packet_ok disable the packet. */
2813 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2817 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2820 /* Resume the remote inferior by using a "vCont" packet. The thread
2821 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2822 resumed thread should be single-stepped and/or signalled. If PTID's
2823 PID is -1, then all threads are resumed; the thread to be stepped and/or
2824 signalled is given in the global INFERIOR_PTID. This function returns
2825 non-zero iff it resumes the inferior.
2827 This function issues a strict subset of all possible vCont commands at the
2831 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2833 struct remote_state
*rs
= get_remote_state ();
2834 int pid
= PIDGET (ptid
);
2835 char *buf
= NULL
, *outbuf
;
2836 struct cleanup
*old_cleanup
;
2838 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2839 remote_vcont_probe (rs
);
2841 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2844 /* If we could generate a wider range of packets, we'd have to worry
2845 about overflowing BUF. Should there be a generic
2846 "multi-part-packet" packet? */
2848 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2850 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2851 don't have any PID numbers the inferior will understand. Make sure
2852 to only send forms that do not specify a PID. */
2853 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2854 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2856 outbuf
= xstrprintf ("vCont;s");
2857 else if (siggnal
!= TARGET_SIGNAL_0
)
2858 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2860 outbuf
= xstrprintf ("vCont;c");
2864 /* Resume all threads, with preference for INFERIOR_PTID. */
2865 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2866 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2867 PIDGET (inferior_ptid
));
2869 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2870 else if (siggnal
!= TARGET_SIGNAL_0
)
2871 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2872 PIDGET (inferior_ptid
));
2874 outbuf
= xstrprintf ("vCont;c");
2878 /* Scheduler locking; resume only PTID. */
2879 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2880 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2882 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2883 else if (siggnal
!= TARGET_SIGNAL_0
)
2884 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2886 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2889 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2890 old_cleanup
= make_cleanup (xfree
, outbuf
);
2894 do_cleanups (old_cleanup
);
2899 /* Tell the remote machine to resume. */
2901 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2903 static int last_sent_step
;
2906 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2908 struct remote_state
*rs
= get_remote_state ();
2910 int pid
= PIDGET (ptid
);
2912 last_sent_signal
= siggnal
;
2913 last_sent_step
= step
;
2915 /* A hook for when we need to do something at the last moment before
2917 if (deprecated_target_resume_hook
)
2918 (*deprecated_target_resume_hook
) ();
2920 /* Update the inferior on signals to silently pass, if they've changed. */
2921 remote_pass_signals ();
2923 /* The vCont packet doesn't need to specify threads via Hc. */
2924 if (remote_vcont_resume (ptid
, step
, siggnal
))
2927 /* All other supported resume packets do use Hc, so call set_thread. */
2929 set_thread (0, 0); /* Run any thread. */
2931 set_thread (pid
, 0); /* Run this thread. */
2934 if (siggnal
!= TARGET_SIGNAL_0
)
2936 buf
[0] = step
? 'S' : 'C';
2937 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2938 buf
[2] = tohex (((int) siggnal
) & 0xf);
2942 strcpy (buf
, step
? "s" : "c");
2947 /* Same as remote_resume, but with async support. */
2949 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2951 remote_resume (ptid
, step
, siggnal
);
2953 /* We are about to start executing the inferior, let's register it
2954 with the event loop. NOTE: this is the one place where all the
2955 execution commands end up. We could alternatively do this in each
2956 of the execution commands in infcmd.c. */
2957 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2958 into infcmd.c in order to allow inferior function calls to work
2959 NOT asynchronously. */
2960 if (target_can_async_p ())
2961 target_async (inferior_event_handler
, 0);
2962 /* Tell the world that the target is now executing. */
2963 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2964 this? Instead, should the client of target just assume (for
2965 async targets) that the target is going to start executing? Is
2966 this information already found in the continuation block? */
2967 if (target_is_async_p ())
2968 target_executing
= 1;
2972 /* Set up the signal handler for SIGINT, while the target is
2973 executing, ovewriting the 'regular' SIGINT signal handler. */
2975 initialize_sigint_signal_handler (void)
2977 sigint_remote_token
=
2978 create_async_signal_handler (async_remote_interrupt
, NULL
);
2979 signal (SIGINT
, handle_remote_sigint
);
2982 /* Signal handler for SIGINT, while the target is executing. */
2984 handle_remote_sigint (int sig
)
2986 signal (sig
, handle_remote_sigint_twice
);
2987 sigint_remote_twice_token
=
2988 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2989 mark_async_signal_handler_wrapper (sigint_remote_token
);
2992 /* Signal handler for SIGINT, installed after SIGINT has already been
2993 sent once. It will take effect the second time that the user sends
2996 handle_remote_sigint_twice (int sig
)
2998 signal (sig
, handle_sigint
);
2999 sigint_remote_twice_token
=
3000 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
3001 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
3004 /* Perform the real interruption of the target execution, in response
3007 async_remote_interrupt (gdb_client_data arg
)
3010 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3015 /* Perform interrupt, if the first attempt did not succeed. Just give
3016 up on the target alltogether. */
3018 async_remote_interrupt_twice (gdb_client_data arg
)
3021 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
3022 /* Do something only if the target was not killed by the previous
3024 if (target_executing
)
3027 signal (SIGINT
, handle_remote_sigint
);
3031 /* Reinstall the usual SIGINT handlers, after the target has
3034 cleanup_sigint_signal_handler (void *dummy
)
3036 signal (SIGINT
, handle_sigint
);
3037 if (sigint_remote_twice_token
)
3038 delete_async_signal_handler (&sigint_remote_twice_token
);
3039 if (sigint_remote_token
)
3040 delete_async_signal_handler (&sigint_remote_token
);
3043 /* Send ^C to target to halt it. Target will respond, and send us a
3045 static void (*ofunc
) (int);
3047 /* The command line interface's stop routine. This function is installed
3048 as a signal handler for SIGINT. The first time a user requests a
3049 stop, we call remote_stop to send a break or ^C. If there is no
3050 response from the target (it didn't stop when the user requested it),
3051 we ask the user if he'd like to detach from the target. */
3053 remote_interrupt (int signo
)
3055 /* If this doesn't work, try more severe steps. */
3056 signal (signo
, remote_interrupt_twice
);
3059 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3064 /* The user typed ^C twice. */
3067 remote_interrupt_twice (int signo
)
3069 signal (signo
, ofunc
);
3071 signal (signo
, remote_interrupt
);
3074 /* This is the generic stop called via the target vector. When a target
3075 interrupt is requested, either by the command line or the GUI, we
3076 will eventually end up here. */
3080 /* Send a break or a ^C, depending on user preference. */
3082 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
3085 serial_send_break (remote_desc
);
3087 serial_write (remote_desc
, "\003", 1);
3090 /* Ask the user what to do when an interrupt is received. */
3093 interrupt_query (void)
3095 target_terminal_ours ();
3097 if (query ("Interrupted while waiting for the program.\n\
3098 Give up (and stop debugging it)? "))
3100 target_mourn_inferior ();
3101 deprecated_throw_reason (RETURN_QUIT
);
3104 target_terminal_inferior ();
3107 /* Enable/disable target terminal ownership. Most targets can use
3108 terminal groups to control terminal ownership. Remote targets are
3109 different in that explicit transfer of ownership to/from GDB/target
3113 remote_async_terminal_inferior (void)
3115 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3116 sync_execution here. This function should only be called when
3117 GDB is resuming the inferior in the forground. A background
3118 resume (``run&'') should leave GDB in control of the terminal and
3119 consequently should not call this code. */
3120 if (!sync_execution
)
3122 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3123 calls target_terminal_*() idenpotent. The event-loop GDB talking
3124 to an asynchronous target with a synchronous command calls this
3125 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3126 stops trying to transfer the terminal to the target when it
3127 shouldn't this guard can go away. */
3128 if (!remote_async_terminal_ours_p
)
3130 delete_file_handler (input_fd
);
3131 remote_async_terminal_ours_p
= 0;
3132 initialize_sigint_signal_handler ();
3133 /* NOTE: At this point we could also register our selves as the
3134 recipient of all input. Any characters typed could then be
3135 passed on down to the target. */
3139 remote_async_terminal_ours (void)
3141 /* See FIXME in remote_async_terminal_inferior. */
3142 if (!sync_execution
)
3144 /* See FIXME in remote_async_terminal_inferior. */
3145 if (remote_async_terminal_ours_p
)
3147 cleanup_sigint_signal_handler (NULL
);
3148 add_file_handler (input_fd
, stdin_event_handler
, 0);
3149 remote_async_terminal_ours_p
= 1;
3152 /* If nonzero, ignore the next kill. */
3157 remote_console_output (char *msg
)
3161 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3164 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3167 fputs_unfiltered (tb
, gdb_stdtarg
);
3169 gdb_flush (gdb_stdtarg
);
3172 /* Wait until the remote machine stops, then return,
3173 storing status in STATUS just as `wait' would.
3174 Returns "pid", which in the case of a multi-threaded
3175 remote OS, is the thread-id. */
3178 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3180 struct remote_state
*rs
= get_remote_state ();
3181 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3182 ULONGEST thread_num
= -1;
3185 status
->kind
= TARGET_WAITKIND_EXITED
;
3186 status
->value
.integer
= 0;
3192 ofunc
= signal (SIGINT
, remote_interrupt
);
3193 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3194 signal (SIGINT
, ofunc
);
3198 /* This is a hook for when we need to do something (perhaps the
3199 collection of trace data) every time the target stops. */
3200 if (deprecated_target_wait_loop_hook
)
3201 (*deprecated_target_wait_loop_hook
) ();
3203 remote_stopped_by_watchpoint_p
= 0;
3207 case 'E': /* Error of some sort. */
3208 warning (_("Remote failure reply: %s"), buf
);
3210 case 'F': /* File-I/O request. */
3211 remote_fileio_request (buf
);
3213 case 'T': /* Status with PC, SP, FP, ... */
3215 gdb_byte regs
[MAX_REGISTER_SIZE
];
3217 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3218 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3220 n... = register number
3221 r... = register contents
3223 p
= &buf
[3]; /* after Txx */
3232 /* If the packet contains a register number save it in
3233 pnum and set p1 to point to the character following
3234 it. Otherwise p1 points to p. */
3236 /* If this packet is an awatch packet, don't parse the
3237 'a' as a register number. */
3239 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3241 /* Read the ``P'' register number. */
3242 pnum
= strtol (p
, &p_temp
, 16);
3248 if (p1
== p
) /* No register number present here. */
3250 p1
= strchr (p
, ':');
3252 error (_("Malformed packet(a) (missing colon): %s\n\
3255 if (strncmp (p
, "thread", p1
- p
) == 0)
3257 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3258 record_currthread (thread_num
);
3261 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3262 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3263 || (strncmp (p
, "awatch", p1
- p
) == 0))
3265 remote_stopped_by_watchpoint_p
= 1;
3266 p
= unpack_varlen_hex (++p1
, &addr
);
3267 remote_watch_data_address
= (CORE_ADDR
)addr
;
3271 /* Silently skip unknown optional info. */
3272 p_temp
= strchr (p1
+ 1, ';');
3279 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3283 error (_("Malformed packet(b) (missing colon): %s\n\
3288 error (_("Remote sent bad register number %s: %s\n\
3290 phex_nz (pnum
, 0), p
, buf
);
3292 fieldsize
= hex2bin (p
, regs
,
3293 register_size (current_gdbarch
,
3296 if (fieldsize
< register_size (current_gdbarch
,
3298 warning (_("Remote reply is too short: %s"), buf
);
3299 regcache_raw_supply (get_current_regcache (),
3304 error (_("Remote register badly formatted: %s\nhere: %s"),
3309 case 'S': /* Old style status, just signal only. */
3310 status
->kind
= TARGET_WAITKIND_STOPPED
;
3311 status
->value
.sig
= (enum target_signal
)
3312 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3316 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3317 record_currthread (thread_num
);
3320 case 'W': /* Target exited. */
3322 /* The remote process exited. */
3323 status
->kind
= TARGET_WAITKIND_EXITED
;
3324 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3328 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3329 status
->value
.sig
= (enum target_signal
)
3330 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3334 case 'O': /* Console output. */
3335 remote_console_output (buf
+ 1);
3338 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3340 /* Zero length reply means that we tried 'S' or 'C' and
3341 the remote system doesn't support it. */
3342 target_terminal_ours_for_output ();
3344 ("Can't send signals to this remote system. %s not sent.\n",
3345 target_signal_to_name (last_sent_signal
));
3346 last_sent_signal
= TARGET_SIGNAL_0
;
3347 target_terminal_inferior ();
3349 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3350 putpkt ((char *) buf
);
3353 /* else fallthrough */
3355 warning (_("Invalid remote reply: %s"), buf
);
3360 if (thread_num
!= -1)
3362 return pid_to_ptid (thread_num
);
3364 return inferior_ptid
;
3367 /* Async version of remote_wait. */
3369 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3371 struct remote_state
*rs
= get_remote_state ();
3372 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3373 ULONGEST thread_num
= -1;
3376 status
->kind
= TARGET_WAITKIND_EXITED
;
3377 status
->value
.integer
= 0;
3379 remote_stopped_by_watchpoint_p
= 0;
3385 if (!target_is_async_p ())
3386 ofunc
= signal (SIGINT
, remote_interrupt
);
3387 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3388 _never_ wait for ever -> test on target_is_async_p().
3389 However, before we do that we need to ensure that the caller
3390 knows how to take the target into/out of async mode. */
3391 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3392 if (!target_is_async_p ())
3393 signal (SIGINT
, ofunc
);
3397 /* This is a hook for when we need to do something (perhaps the
3398 collection of trace data) every time the target stops. */
3399 if (deprecated_target_wait_loop_hook
)
3400 (*deprecated_target_wait_loop_hook
) ();
3404 case 'E': /* Error of some sort. */
3405 warning (_("Remote failure reply: %s"), buf
);
3407 case 'F': /* File-I/O request. */
3408 remote_fileio_request (buf
);
3410 case 'T': /* Status with PC, SP, FP, ... */
3412 gdb_byte regs
[MAX_REGISTER_SIZE
];
3414 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3415 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3417 n... = register number
3418 r... = register contents
3420 p
= &buf
[3]; /* after Txx */
3429 /* If the packet contains a register number, save it
3430 in pnum and set p1 to point to the character
3431 following it. Otherwise p1 points to p. */
3433 /* If this packet is an awatch packet, don't parse the 'a'
3434 as a register number. */
3436 if (!strncmp (p
, "awatch", strlen ("awatch")) != 0)
3438 /* Read the register number. */
3439 pnum
= strtol (p
, &p_temp
, 16);
3445 if (p1
== p
) /* No register number present here. */
3447 p1
= strchr (p
, ':');
3449 error (_("Malformed packet(a) (missing colon): %s\n\
3452 if (strncmp (p
, "thread", p1
- p
) == 0)
3454 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3455 record_currthread (thread_num
);
3458 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3459 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3460 || (strncmp (p
, "awatch", p1
- p
) == 0))
3462 remote_stopped_by_watchpoint_p
= 1;
3463 p
= unpack_varlen_hex (++p1
, &addr
);
3464 remote_watch_data_address
= (CORE_ADDR
)addr
;
3468 /* Silently skip unknown optional info. */
3469 p_temp
= strchr (p1
+ 1, ';');
3477 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3480 error (_("Malformed packet(b) (missing colon): %s\n\
3485 error (_("Remote sent bad register number %ld: %s\n\
3489 fieldsize
= hex2bin (p
, regs
,
3490 register_size (current_gdbarch
,
3493 if (fieldsize
< register_size (current_gdbarch
,
3495 warning (_("Remote reply is too short: %s"), buf
);
3496 regcache_raw_supply (get_current_regcache (),
3501 error (_("Remote register badly formatted: %s\nhere: %s"),
3506 case 'S': /* Old style status, just signal only. */
3507 status
->kind
= TARGET_WAITKIND_STOPPED
;
3508 status
->value
.sig
= (enum target_signal
)
3509 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3513 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3514 record_currthread (thread_num
);
3517 case 'W': /* Target exited. */
3519 /* The remote process exited. */
3520 status
->kind
= TARGET_WAITKIND_EXITED
;
3521 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3525 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3526 status
->value
.sig
= (enum target_signal
)
3527 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3531 case 'O': /* Console output. */
3532 remote_console_output (buf
+ 1);
3533 /* Return immediately to the event loop. The event loop will
3534 still be waiting on the inferior afterwards. */
3535 status
->kind
= TARGET_WAITKIND_IGNORE
;
3538 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3540 /* Zero length reply means that we tried 'S' or 'C' and
3541 the remote system doesn't support it. */
3542 target_terminal_ours_for_output ();
3544 ("Can't send signals to this remote system. %s not sent.\n",
3545 target_signal_to_name (last_sent_signal
));
3546 last_sent_signal
= TARGET_SIGNAL_0
;
3547 target_terminal_inferior ();
3549 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3550 putpkt ((char *) buf
);
3553 /* else fallthrough */
3555 warning (_("Invalid remote reply: %s"), buf
);
3560 if (thread_num
!= -1)
3562 return pid_to_ptid (thread_num
);
3564 return inferior_ptid
;
3567 /* Fetch a single register using a 'p' packet. */
3570 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3572 struct remote_state
*rs
= get_remote_state ();
3574 char regp
[MAX_REGISTER_SIZE
];
3577 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3580 if (reg
->pnum
== -1)
3585 p
+= hexnumstr (p
, reg
->pnum
);
3587 remote_send (&rs
->buf
, &rs
->buf_size
);
3591 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3595 case PACKET_UNKNOWN
:
3598 error (_("Could not fetch register \"%s\""),
3599 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3602 /* If this register is unfetchable, tell the regcache. */
3605 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3609 /* Otherwise, parse and supply the value. */
3615 error (_("fetch_register_using_p: early buf termination"));
3617 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3620 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3624 /* Fetch the registers included in the target's 'g' packet. */
3627 send_g_packet (void)
3629 struct remote_state
*rs
= get_remote_state ();
3634 sprintf (rs
->buf
, "g");
3635 remote_send (&rs
->buf
, &rs
->buf_size
);
3637 /* We can get out of synch in various cases. If the first character
3638 in the buffer is not a hex character, assume that has happened
3639 and try to fetch another packet to read. */
3640 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3641 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3642 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3643 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3646 fprintf_unfiltered (gdb_stdlog
,
3647 "Bad register packet; fetching a new packet\n");
3648 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3651 buf_len
= strlen (rs
->buf
);
3653 /* Sanity check the received packet. */
3654 if (buf_len
% 2 != 0)
3655 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3661 process_g_packet (struct regcache
*regcache
)
3663 struct remote_state
*rs
= get_remote_state ();
3664 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3669 buf_len
= strlen (rs
->buf
);
3671 /* Further sanity checks, with knowledge of the architecture. */
3672 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3673 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3675 /* Save the size of the packet sent to us by the target. It is used
3676 as a heuristic when determining the max size of packets that the
3677 target can safely receive. */
3678 if (rsa
->actual_register_packet_size
== 0)
3679 rsa
->actual_register_packet_size
= buf_len
;
3681 /* If this is smaller than we guessed the 'g' packet would be,
3682 update our records. A 'g' reply that doesn't include a register's
3683 value implies either that the register is not available, or that
3684 the 'p' packet must be used. */
3685 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3687 rsa
->sizeof_g_packet
= buf_len
/ 2;
3689 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3691 if (rsa
->regs
[i
].pnum
== -1)
3694 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3695 rsa
->regs
[i
].in_g_packet
= 0;
3697 rsa
->regs
[i
].in_g_packet
= 1;
3701 regs
= alloca (rsa
->sizeof_g_packet
);
3703 /* Unimplemented registers read as all bits zero. */
3704 memset (regs
, 0, rsa
->sizeof_g_packet
);
3706 /* Reply describes registers byte by byte, each byte encoded as two
3707 hex characters. Suck them all up, then supply them to the
3708 register cacheing/storage mechanism. */
3711 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3713 if (p
[0] == 0 || p
[1] == 0)
3714 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3715 internal_error (__FILE__
, __LINE__
,
3716 "unexpected end of 'g' packet reply");
3718 if (p
[0] == 'x' && p
[1] == 'x')
3719 regs
[i
] = 0; /* 'x' */
3721 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3727 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3729 struct packet_reg
*r
= &rsa
->regs
[i
];
3732 if (r
->offset
* 2 >= strlen (rs
->buf
))
3733 /* This shouldn't happen - we adjusted in_g_packet above. */
3734 internal_error (__FILE__
, __LINE__
,
3735 "unexpected end of 'g' packet reply");
3736 else if (rs
->buf
[r
->offset
* 2] == 'x')
3738 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3739 /* The register isn't available, mark it as such (at
3740 the same time setting the value to zero). */
3741 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3744 regcache_raw_supply (regcache
, r
->regnum
,
3752 fetch_registers_using_g (struct regcache
*regcache
)
3755 process_g_packet (regcache
);
3759 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3761 struct remote_state
*rs
= get_remote_state ();
3762 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3765 set_thread (PIDGET (inferior_ptid
), 1);
3769 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3770 gdb_assert (reg
!= NULL
);
3772 /* If this register might be in the 'g' packet, try that first -
3773 we are likely to read more than one register. If this is the
3774 first 'g' packet, we might be overly optimistic about its
3775 contents, so fall back to 'p'. */
3776 if (reg
->in_g_packet
)
3778 fetch_registers_using_g (regcache
);
3779 if (reg
->in_g_packet
)
3783 if (fetch_register_using_p (regcache
, reg
))
3786 /* This register is not available. */
3787 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3792 fetch_registers_using_g (regcache
);
3794 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3795 if (!rsa
->regs
[i
].in_g_packet
)
3796 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3798 /* This register is not available. */
3799 regcache_raw_supply (regcache
, i
, NULL
);
3803 /* Prepare to store registers. Since we may send them all (using a
3804 'G' request), we have to read out the ones we don't want to change
3808 remote_prepare_to_store (struct regcache
*regcache
)
3810 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3812 gdb_byte buf
[MAX_REGISTER_SIZE
];
3814 /* Make sure the entire registers array is valid. */
3815 switch (remote_protocol_packets
[PACKET_P
].support
)
3817 case PACKET_DISABLE
:
3818 case PACKET_SUPPORT_UNKNOWN
:
3819 /* Make sure all the necessary registers are cached. */
3820 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3821 if (rsa
->regs
[i
].in_g_packet
)
3822 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3829 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3830 packet was not recognized. */
3833 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3835 struct remote_state
*rs
= get_remote_state ();
3836 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3837 /* Try storing a single register. */
3838 char *buf
= rs
->buf
;
3839 gdb_byte regp
[MAX_REGISTER_SIZE
];
3842 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3845 if (reg
->pnum
== -1)
3848 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3849 p
= buf
+ strlen (buf
);
3850 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3851 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3852 remote_send (&rs
->buf
, &rs
->buf_size
);
3854 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3859 error (_("Could not write register \"%s\""),
3860 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3861 case PACKET_UNKNOWN
:
3864 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3868 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3869 contents of the register cache buffer. FIXME: ignores errors. */
3872 store_registers_using_G (const struct regcache
*regcache
)
3874 struct remote_state
*rs
= get_remote_state ();
3875 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3879 /* Extract all the registers in the regcache copying them into a
3883 regs
= alloca (rsa
->sizeof_g_packet
);
3884 memset (regs
, 0, rsa
->sizeof_g_packet
);
3885 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3887 struct packet_reg
*r
= &rsa
->regs
[i
];
3889 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3893 /* Command describes registers byte by byte,
3894 each byte encoded as two hex characters. */
3897 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3899 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3900 remote_send (&rs
->buf
, &rs
->buf_size
);
3903 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3904 of the register cache buffer. FIXME: ignores errors. */
3907 remote_store_registers (struct regcache
*regcache
, int regnum
)
3909 struct remote_state
*rs
= get_remote_state ();
3910 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3913 set_thread (PIDGET (inferior_ptid
), 1);
3917 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3918 gdb_assert (reg
!= NULL
);
3920 /* Always prefer to store registers using the 'P' packet if
3921 possible; we often change only a small number of registers.
3922 Sometimes we change a larger number; we'd need help from a
3923 higher layer to know to use 'G'. */
3924 if (store_register_using_P (regcache
, reg
))
3927 /* For now, don't complain if we have no way to write the
3928 register. GDB loses track of unavailable registers too
3929 easily. Some day, this may be an error. We don't have
3930 any way to read the register, either... */
3931 if (!reg
->in_g_packet
)
3934 store_registers_using_G (regcache
);
3938 store_registers_using_G (regcache
);
3940 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3941 if (!rsa
->regs
[i
].in_g_packet
)
3942 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
3943 /* See above for why we do not issue an error here. */
3948 /* Return the number of hex digits in num. */
3951 hexnumlen (ULONGEST num
)
3955 for (i
= 0; num
!= 0; i
++)
3961 /* Set BUF to the minimum number of hex digits representing NUM. */
3964 hexnumstr (char *buf
, ULONGEST num
)
3966 int len
= hexnumlen (num
);
3967 return hexnumnstr (buf
, num
, len
);
3971 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3974 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3980 for (i
= width
- 1; i
>= 0; i
--)
3982 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3989 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3992 remote_address_masked (CORE_ADDR addr
)
3994 int address_size
= remote_address_size
;
3995 /* If "remoteaddresssize" was not set, default to target address size. */
3997 address_size
= gdbarch_addr_bit (current_gdbarch
);
3999 if (address_size
> 0
4000 && address_size
< (sizeof (ULONGEST
) * 8))
4002 /* Only create a mask when that mask can safely be constructed
4003 in a ULONGEST variable. */
4005 mask
= (mask
<< address_size
) - 1;
4011 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
4012 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
4013 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
4014 (which may be more than *OUT_LEN due to escape characters). The
4015 total number of bytes in the output buffer will be at most
4019 remote_escape_output (const gdb_byte
*buffer
, int len
,
4020 gdb_byte
*out_buf
, int *out_len
,
4023 int input_index
, output_index
;
4026 for (input_index
= 0; input_index
< len
; input_index
++)
4028 gdb_byte b
= buffer
[input_index
];
4030 if (b
== '$' || b
== '#' || b
== '}')
4032 /* These must be escaped. */
4033 if (output_index
+ 2 > out_maxlen
)
4035 out_buf
[output_index
++] = '}';
4036 out_buf
[output_index
++] = b
^ 0x20;
4040 if (output_index
+ 1 > out_maxlen
)
4042 out_buf
[output_index
++] = b
;
4046 *out_len
= input_index
;
4047 return output_index
;
4050 /* Convert BUFFER, escaped data LEN bytes long, into binary data
4051 in OUT_BUF. Return the number of bytes written to OUT_BUF.
4052 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
4054 This function reverses remote_escape_output. It allows more
4055 escaped characters than that function does, in particular because
4056 '*' must be escaped to avoid the run-length encoding processing
4057 in reading packets. */
4060 remote_unescape_input (const gdb_byte
*buffer
, int len
,
4061 gdb_byte
*out_buf
, int out_maxlen
)
4063 int input_index
, output_index
;
4068 for (input_index
= 0; input_index
< len
; input_index
++)
4070 gdb_byte b
= buffer
[input_index
];
4072 if (output_index
+ 1 > out_maxlen
)
4074 warning (_("Received too much data from remote target;"
4075 " ignoring overflow."));
4076 return output_index
;
4081 out_buf
[output_index
++] = b
^ 0x20;
4087 out_buf
[output_index
++] = b
;
4091 error (_("Unmatched escape character in target response."));
4093 return output_index
;
4096 /* Determine whether the remote target supports binary downloading.
4097 This is accomplished by sending a no-op memory write of zero length
4098 to the target at the specified address. It does not suffice to send
4099 the whole packet, since many stubs strip the eighth bit and
4100 subsequently compute a wrong checksum, which causes real havoc with
4103 NOTE: This can still lose if the serial line is not eight-bit
4104 clean. In cases like this, the user should clear "remote
4108 check_binary_download (CORE_ADDR addr
)
4110 struct remote_state
*rs
= get_remote_state ();
4112 switch (remote_protocol_packets
[PACKET_X
].support
)
4114 case PACKET_DISABLE
:
4118 case PACKET_SUPPORT_UNKNOWN
:
4124 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4126 p
+= hexnumstr (p
, (ULONGEST
) 0);
4130 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4131 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4133 if (rs
->buf
[0] == '\0')
4136 fprintf_unfiltered (gdb_stdlog
,
4137 "binary downloading NOT suppported by target\n");
4138 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4143 fprintf_unfiltered (gdb_stdlog
,
4144 "binary downloading suppported by target\n");
4145 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4152 /* Write memory data directly to the remote machine.
4153 This does not inform the data cache; the data cache uses this.
4154 HEADER is the starting part of the packet.
4155 MEMADDR is the address in the remote memory space.
4156 MYADDR is the address of the buffer in our space.
4157 LEN is the number of bytes.
4158 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4159 should send data as binary ('X'), or hex-encoded ('M').
4161 The function creates packet of the form
4162 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4164 where encoding of <DATA> is termined by PACKET_FORMAT.
4166 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4169 Returns the number of bytes transferred, or 0 (setting errno) for
4170 error. Only transfer a single packet. */
4173 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4174 const gdb_byte
*myaddr
, int len
,
4175 char packet_format
, int use_length
)
4177 struct remote_state
*rs
= get_remote_state ();
4187 if (packet_format
!= 'X' && packet_format
!= 'M')
4188 internal_error (__FILE__
, __LINE__
,
4189 "remote_write_bytes_aux: bad packet format");
4194 payload_size
= get_memory_write_packet_size ();
4196 /* The packet buffer will be large enough for the payload;
4197 get_memory_packet_size ensures this. */
4200 /* Compute the size of the actual payload by subtracting out the
4201 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4203 payload_size
-= strlen ("$,:#NN");
4205 /* The comma won't be used. */
4207 header_length
= strlen (header
);
4208 payload_size
-= header_length
;
4209 payload_size
-= hexnumlen (memaddr
);
4211 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4213 strcat (rs
->buf
, header
);
4214 p
= rs
->buf
+ strlen (header
);
4216 /* Compute a best guess of the number of bytes actually transfered. */
4217 if (packet_format
== 'X')
4219 /* Best guess at number of bytes that will fit. */
4220 todo
= min (len
, payload_size
);
4222 payload_size
-= hexnumlen (todo
);
4223 todo
= min (todo
, payload_size
);
4227 /* Num bytes that will fit. */
4228 todo
= min (len
, payload_size
/ 2);
4230 payload_size
-= hexnumlen (todo
);
4231 todo
= min (todo
, payload_size
/ 2);
4235 internal_error (__FILE__
, __LINE__
,
4236 _("minumum packet size too small to write data"));
4238 /* If we already need another packet, then try to align the end
4239 of this packet to a useful boundary. */
4240 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4241 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4243 /* Append "<memaddr>". */
4244 memaddr
= remote_address_masked (memaddr
);
4245 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4252 /* Append <len>. Retain the location/size of <len>. It may need to
4253 be adjusted once the packet body has been created. */
4255 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4263 /* Append the packet body. */
4264 if (packet_format
== 'X')
4266 /* Binary mode. Send target system values byte by byte, in
4267 increasing byte addresses. Only escape certain critical
4269 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4272 /* If not all TODO bytes fit, then we'll need another packet. Make
4273 a second try to keep the end of the packet aligned. Don't do
4274 this if the packet is tiny. */
4275 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4279 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4281 if (new_nr_bytes
!= nr_bytes
)
4282 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4287 p
+= payload_length
;
4288 if (use_length
&& nr_bytes
< todo
)
4290 /* Escape chars have filled up the buffer prematurely,
4291 and we have actually sent fewer bytes than planned.
4292 Fix-up the length field of the packet. Use the same
4293 number of characters as before. */
4294 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4295 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4300 /* Normal mode: Send target system values byte by byte, in
4301 increasing byte addresses. Each byte is encoded as a two hex
4303 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4307 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4308 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4310 if (rs
->buf
[0] == 'E')
4312 /* There is no correspondance between what the remote protocol
4313 uses for errors and errno codes. We would like a cleaner way
4314 of representing errors (big enough to include errno codes,
4315 bfd_error codes, and others). But for now just return EIO. */
4320 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4321 fewer bytes than we'd planned. */
4325 /* Write memory data directly to the remote machine.
4326 This does not inform the data cache; the data cache uses this.
4327 MEMADDR is the address in the remote memory space.
4328 MYADDR is the address of the buffer in our space.
4329 LEN is the number of bytes.
4331 Returns number of bytes transferred, or 0 (setting errno) for
4332 error. Only transfer a single packet. */
4335 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4337 char *packet_format
= 0;
4339 /* Check whether the target supports binary download. */
4340 check_binary_download (memaddr
);
4342 switch (remote_protocol_packets
[PACKET_X
].support
)
4345 packet_format
= "X";
4347 case PACKET_DISABLE
:
4348 packet_format
= "M";
4350 case PACKET_SUPPORT_UNKNOWN
:
4351 internal_error (__FILE__
, __LINE__
,
4352 _("remote_write_bytes: bad internal state"));
4354 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4357 return remote_write_bytes_aux (packet_format
,
4358 memaddr
, myaddr
, len
, packet_format
[0], 1);
4361 /* Read memory data directly from the remote machine.
4362 This does not use the data cache; the data cache uses this.
4363 MEMADDR is the address in the remote memory space.
4364 MYADDR is the address of the buffer in our space.
4365 LEN is the number of bytes.
4367 Returns number of bytes transferred, or 0 for error. */
4369 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4370 remote targets) shouldn't attempt to read the entire buffer.
4371 Instead it should read a single packet worth of data and then
4372 return the byte size of that packet to the caller. The caller (its
4373 caller and its callers caller ;-) already contains code for
4374 handling partial reads. */
4377 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4379 struct remote_state
*rs
= get_remote_state ();
4380 int max_buf_size
; /* Max size of packet output buffer. */
4386 max_buf_size
= get_memory_read_packet_size ();
4387 /* The packet buffer will be large enough for the payload;
4388 get_memory_packet_size ensures this. */
4397 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4399 /* construct "m"<memaddr>","<len>" */
4400 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4401 memaddr
= remote_address_masked (memaddr
);
4404 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4406 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4410 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4412 if (rs
->buf
[0] == 'E'
4413 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4414 && rs
->buf
[3] == '\0')
4416 /* There is no correspondance between what the remote
4417 protocol uses for errors and errno codes. We would like
4418 a cleaner way of representing errors (big enough to
4419 include errno codes, bfd_error codes, and others). But
4420 for now just return EIO. */
4425 /* Reply describes memory byte by byte,
4426 each byte encoded as two hex characters. */
4429 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4431 /* Reply is short. This means that we were able to read
4432 only part of what we wanted to. */
4433 return i
+ (origlen
- len
);
4442 /* Read or write LEN bytes from inferior memory at MEMADDR,
4443 transferring to or from debugger address BUFFER. Write to inferior
4444 if SHOULD_WRITE is nonzero. Returns length of data written or
4445 read; 0 for error. TARGET is unused. */
4448 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4449 int should_write
, struct mem_attrib
*attrib
,
4450 struct target_ops
*target
)
4455 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4457 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4462 /* Sends a packet with content determined by the printf format string
4463 FORMAT and the remaining arguments, then gets the reply. Returns
4464 whether the packet was a success, a failure, or unknown. */
4467 remote_send_printf (const char *format
, ...)
4469 struct remote_state
*rs
= get_remote_state ();
4470 int max_size
= get_remote_packet_size ();
4473 va_start (ap
, format
);
4476 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4477 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4479 if (putpkt (rs
->buf
) < 0)
4480 error (_("Communication problem with target."));
4483 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4485 return packet_check_result (rs
->buf
);
4489 restore_remote_timeout (void *p
)
4491 int value
= *(int *)p
;
4492 remote_timeout
= value
;
4495 /* Flash writing can take quite some time. We'll set
4496 effectively infinite timeout for flash operations.
4497 In future, we'll need to decide on a better approach. */
4498 static const int remote_flash_timeout
= 1000;
4501 remote_flash_erase (struct target_ops
*ops
,
4502 ULONGEST address
, LONGEST length
)
4504 int saved_remote_timeout
= remote_timeout
;
4505 enum packet_result ret
;
4507 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4508 &saved_remote_timeout
);
4509 remote_timeout
= remote_flash_timeout
;
4511 ret
= remote_send_printf ("vFlashErase:%s,%s",
4516 case PACKET_UNKNOWN
:
4517 error (_("Remote target does not support flash erase"));
4519 error (_("Error erasing flash with vFlashErase packet"));
4524 do_cleanups (back_to
);
4528 remote_flash_write (struct target_ops
*ops
,
4529 ULONGEST address
, LONGEST length
,
4530 const gdb_byte
*data
)
4532 int saved_remote_timeout
= remote_timeout
;
4534 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4535 &saved_remote_timeout
);
4537 remote_timeout
= remote_flash_timeout
;
4538 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4539 do_cleanups (back_to
);
4545 remote_flash_done (struct target_ops
*ops
)
4547 int saved_remote_timeout
= remote_timeout
;
4549 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4550 &saved_remote_timeout
);
4552 remote_timeout
= remote_flash_timeout
;
4553 ret
= remote_send_printf ("vFlashDone");
4554 do_cleanups (back_to
);
4558 case PACKET_UNKNOWN
:
4559 error (_("Remote target does not support vFlashDone"));
4561 error (_("Error finishing flash operation"));
4568 remote_files_info (struct target_ops
*ignore
)
4570 puts_filtered ("Debugging a target over a serial line.\n");
4573 /* Stuff for dealing with the packets which are part of this protocol.
4574 See comment at top of file for details. */
4576 /* Read a single character from the remote end. */
4579 readchar (int timeout
)
4583 ch
= serial_readchar (remote_desc
, timeout
);
4588 switch ((enum serial_rc
) ch
)
4591 target_mourn_inferior ();
4592 error (_("Remote connection closed"));
4595 perror_with_name (_("Remote communication error"));
4597 case SERIAL_TIMEOUT
:
4603 /* Send the command in *BUF to the remote machine, and read the reply
4604 into *BUF. Report an error if we get an error reply. Resize
4605 *BUF using xrealloc if necessary to hold the result, and update
4609 remote_send (char **buf
,
4613 getpkt (buf
, sizeof_buf
, 0);
4615 if ((*buf
)[0] == 'E')
4616 error (_("Remote failure reply: %s"), *buf
);
4619 /* Display a null-terminated packet on stdout, for debugging, using C
4623 print_packet (char *buf
)
4625 puts_filtered ("\"");
4626 fputstr_filtered (buf
, '"', gdb_stdout
);
4627 puts_filtered ("\"");
4633 return putpkt_binary (buf
, strlen (buf
));
4636 /* Send a packet to the remote machine, with error checking. The data
4637 of the packet is in BUF. The string in BUF can be at most
4638 get_remote_packet_size () - 5 to account for the $, # and checksum,
4639 and for a possible /0 if we are debugging (remote_debug) and want
4640 to print the sent packet as a string. */
4643 putpkt_binary (char *buf
, int cnt
)
4646 unsigned char csum
= 0;
4647 char *buf2
= alloca (cnt
+ 6);
4653 /* Copy the packet into buffer BUF2, encapsulating it
4654 and giving it a checksum. */
4659 for (i
= 0; i
< cnt
; i
++)
4665 *p
++ = tohex ((csum
>> 4) & 0xf);
4666 *p
++ = tohex (csum
& 0xf);
4668 /* Send it over and over until we get a positive ack. */
4672 int started_error_output
= 0;
4677 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4678 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4679 fprintf_unfiltered (gdb_stdlog
, "...");
4680 gdb_flush (gdb_stdlog
);
4682 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4683 perror_with_name (_("putpkt: write failed"));
4685 /* Read until either a timeout occurs (-2) or '+' is read. */
4688 ch
= readchar (remote_timeout
);
4696 case SERIAL_TIMEOUT
:
4698 if (started_error_output
)
4700 putchar_unfiltered ('\n');
4701 started_error_output
= 0;
4710 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4714 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4715 case SERIAL_TIMEOUT
:
4719 break; /* Retransmit buffer. */
4723 fprintf_unfiltered (gdb_stdlog
,
4724 "Packet instead of Ack, ignoring it\n");
4725 /* It's probably an old response sent because an ACK
4726 was lost. Gobble up the packet and ack it so it
4727 doesn't get retransmitted when we resend this
4730 serial_write (remote_desc
, "+", 1);
4731 continue; /* Now, go look for +. */
4736 if (!started_error_output
)
4738 started_error_output
= 1;
4739 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4741 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4745 break; /* Here to retransmit. */
4749 /* This is wrong. If doing a long backtrace, the user should be
4750 able to get out next time we call QUIT, without anything as
4751 violent as interrupt_query. If we want to provide a way out of
4752 here without getting to the next QUIT, it should be based on
4753 hitting ^C twice as in remote_wait. */
4763 /* Come here after finding the start of a frame when we expected an
4764 ack. Do our best to discard the rest of this packet. */
4773 c
= readchar (remote_timeout
);
4776 case SERIAL_TIMEOUT
:
4777 /* Nothing we can do. */
4780 /* Discard the two bytes of checksum and stop. */
4781 c
= readchar (remote_timeout
);
4783 c
= readchar (remote_timeout
);
4786 case '*': /* Run length encoding. */
4787 /* Discard the repeat count. */
4788 c
= readchar (remote_timeout
);
4793 /* A regular character. */
4799 /* Come here after finding the start of the frame. Collect the rest
4800 into *BUF, verifying the checksum, length, and handling run-length
4801 compression. NUL terminate the buffer. If there is not enough room,
4802 expand *BUF using xrealloc.
4804 Returns -1 on error, number of characters in buffer (ignoring the
4805 trailing NULL) on success. (could be extended to return one of the
4806 SERIAL status indications). */
4809 read_frame (char **buf_p
,
4822 c
= readchar (remote_timeout
);
4825 case SERIAL_TIMEOUT
:
4827 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4831 fputs_filtered ("Saw new packet start in middle of old one\n",
4833 return -1; /* Start a new packet, count retries. */
4836 unsigned char pktcsum
;
4842 check_0
= readchar (remote_timeout
);
4844 check_1
= readchar (remote_timeout
);
4846 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4849 fputs_filtered ("Timeout in checksum, retrying\n",
4853 else if (check_0
< 0 || check_1
< 0)
4856 fputs_filtered ("Communication error in checksum\n",
4861 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4862 if (csum
== pktcsum
)
4867 fprintf_filtered (gdb_stdlog
,
4868 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4870 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4871 fputs_filtered ("\n", gdb_stdlog
);
4873 /* Number of characters in buffer ignoring trailing
4877 case '*': /* Run length encoding. */
4882 c
= readchar (remote_timeout
);
4884 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4886 /* The character before ``*'' is repeated. */
4888 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4890 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4892 /* Make some more room in the buffer. */
4893 *sizeof_buf
+= repeat
;
4894 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4898 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4904 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4908 if (bc
>= *sizeof_buf
- 1)
4910 /* Make some more room in the buffer. */
4912 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4923 /* Read a packet from the remote machine, with error checking, and
4924 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4925 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4926 rather than timing out; this is used (in synchronous mode) to wait
4927 for a target that is is executing user code to stop. */
4928 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4929 don't have to change all the calls to getpkt to deal with the
4930 return value, because at the moment I don't know what the right
4931 thing to do it for those. */
4939 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4943 /* Read a packet from the remote machine, with error checking, and
4944 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4945 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4946 rather than timing out; this is used (in synchronous mode) to wait
4947 for a target that is is executing user code to stop. If FOREVER ==
4948 0, this function is allowed to time out gracefully and return an
4949 indication of this to the caller. Otherwise return the number
4952 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4959 strcpy (*buf
, "timeout");
4963 timeout
= watchdog
> 0 ? watchdog
: -1;
4967 timeout
= remote_timeout
;
4971 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4973 /* This can loop forever if the remote side sends us characters
4974 continuously, but if it pauses, we'll get a zero from
4975 readchar because of timeout. Then we'll count that as a
4978 /* Note that we will only wait forever prior to the start of a
4979 packet. After that, we expect characters to arrive at a
4980 brisk pace. They should show up within remote_timeout
4985 c
= readchar (timeout
);
4987 if (c
== SERIAL_TIMEOUT
)
4989 if (forever
) /* Watchdog went off? Kill the target. */
4992 target_mourn_inferior ();
4993 error (_("Watchdog has expired. Target detached."));
4996 fputs_filtered ("Timed out.\n", gdb_stdlog
);
5002 /* We've found the start of a packet, now collect the data. */
5004 val
= read_frame (buf
, sizeof_buf
);
5010 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
5011 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
5012 fprintf_unfiltered (gdb_stdlog
, "\n");
5014 serial_write (remote_desc
, "+", 1);
5018 /* Try the whole thing again. */
5020 serial_write (remote_desc
, "-", 1);
5023 /* We have tried hard enough, and just can't receive the packet.
5026 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
5027 serial_write (remote_desc
, "+", 1);
5034 /* For some mysterious reason, wait_for_inferior calls kill instead of
5035 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5039 target_mourn_inferior ();
5043 /* Use catch_errors so the user can quit from gdb even when we aren't on
5044 speaking terms with the remote system. */
5045 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5047 /* Don't wait for it to die. I'm not really sure it matters whether
5048 we do or not. For the existing stubs, kill is a noop. */
5049 target_mourn_inferior ();
5052 /* Async version of remote_kill. */
5054 remote_async_kill (void)
5056 /* Unregister the file descriptor from the event loop. */
5057 if (target_is_async_p ())
5058 serial_async (remote_desc
, NULL
, 0);
5060 /* For some mysterious reason, wait_for_inferior calls kill instead of
5061 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5065 target_mourn_inferior ();
5069 /* Use catch_errors so the user can quit from gdb even when we
5070 aren't on speaking terms with the remote system. */
5071 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5073 /* Don't wait for it to die. I'm not really sure it matters whether
5074 we do or not. For the existing stubs, kill is a noop. */
5075 target_mourn_inferior ();
5081 remote_mourn_1 (&remote_ops
);
5085 remote_async_mourn (void)
5087 remote_mourn_1 (&remote_async_ops
);
5091 extended_remote_mourn (void)
5093 /* We do _not_ want to mourn the target like this; this will
5094 remove the extended remote target from the target stack,
5095 and the next time the user says "run" it'll fail.
5097 FIXME: What is the right thing to do here? */
5099 remote_mourn_1 (&extended_remote_ops
);
5103 /* Worker function for remote_mourn. */
5105 remote_mourn_1 (struct target_ops
*target
)
5107 unpush_target (target
);
5108 generic_mourn_inferior ();
5111 /* In the extended protocol we want to be able to do things like
5112 "run" and have them basically work as expected. So we need
5113 a special create_inferior function.
5115 FIXME: One day add support for changing the exec file
5116 we're debugging, arguments and an environment. */
5119 extended_remote_create_inferior (char *exec_file
, char *args
,
5120 char **env
, int from_tty
)
5122 /* Rip out the breakpoints; we'll reinsert them after restarting
5123 the remote server. */
5124 remove_breakpoints ();
5126 /* Now restart the remote server. */
5127 extended_remote_restart ();
5129 /* NOTE: We don't need to recheck for a target description here; but
5130 if we gain the ability to switch the remote executable we may
5131 need to, if for instance we are running a process which requested
5132 different emulated hardware from the operating system. A
5133 concrete example of this is ARM GNU/Linux, where some binaries
5134 will have a legacy FPA coprocessor emulated and others may have
5135 access to a hardware VFP unit. */
5137 /* Now put the breakpoints back in. This way we're safe if the
5138 restart function works via a unix fork on the remote side. */
5139 insert_breakpoints ();
5141 /* Clean up from the last time we were running. */
5142 clear_proceed_status ();
5145 /* Async version of extended_remote_create_inferior. */
5147 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5148 char **env
, int from_tty
)
5150 /* Rip out the breakpoints; we'll reinsert them after restarting
5151 the remote server. */
5152 remove_breakpoints ();
5154 /* If running asynchronously, register the target file descriptor
5155 with the event loop. */
5156 if (target_can_async_p ())
5157 target_async (inferior_event_handler
, 0);
5159 /* Now restart the remote server. */
5160 extended_remote_restart ();
5162 /* NOTE: We don't need to recheck for a target description here; but
5163 if we gain the ability to switch the remote executable we may
5164 need to, if for instance we are running a process which requested
5165 different emulated hardware from the operating system. A
5166 concrete example of this is ARM GNU/Linux, where some binaries
5167 will have a legacy FPA coprocessor emulated and others may have
5168 access to a hardware VFP unit. */
5170 /* Now put the breakpoints back in. This way we're safe if the
5171 restart function works via a unix fork on the remote side. */
5172 insert_breakpoints ();
5174 /* Clean up from the last time we were running. */
5175 clear_proceed_status ();
5179 /* Insert a breakpoint. On targets that have software breakpoint
5180 support, we ask the remote target to do the work; on targets
5181 which don't, we insert a traditional memory breakpoint. */
5184 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5186 CORE_ADDR addr
= bp_tgt
->placed_address
;
5187 struct remote_state
*rs
= get_remote_state ();
5189 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5190 If it succeeds, then set the support to PACKET_ENABLE. If it
5191 fails, and the user has explicitly requested the Z support then
5192 report an error, otherwise, mark it disabled and go on. */
5194 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5201 gdbarch_breakpoint_from_pc
5202 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5203 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5204 p
+= hexnumstr (p
, addr
);
5205 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5208 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5210 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5216 case PACKET_UNKNOWN
:
5221 return memory_insert_breakpoint (bp_tgt
);
5225 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5227 CORE_ADDR addr
= bp_tgt
->placed_address
;
5228 struct remote_state
*rs
= get_remote_state ();
5231 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5239 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5240 p
+= hexnumstr (p
, addr
);
5241 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5244 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5246 return (rs
->buf
[0] == 'E');
5249 return memory_remove_breakpoint (bp_tgt
);
5253 watchpoint_to_Z_packet (int type
)
5258 return Z_PACKET_WRITE_WP
;
5261 return Z_PACKET_READ_WP
;
5264 return Z_PACKET_ACCESS_WP
;
5267 internal_error (__FILE__
, __LINE__
,
5268 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5273 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5275 struct remote_state
*rs
= get_remote_state ();
5277 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5279 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5282 sprintf (rs
->buf
, "Z%x,", packet
);
5283 p
= strchr (rs
->buf
, '\0');
5284 addr
= remote_address_masked (addr
);
5285 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5286 sprintf (p
, ",%x", len
);
5289 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5291 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5294 case PACKET_UNKNOWN
:
5299 internal_error (__FILE__
, __LINE__
,
5300 _("remote_insert_watchpoint: reached end of function"));
5305 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5307 struct remote_state
*rs
= get_remote_state ();
5309 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5311 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5314 sprintf (rs
->buf
, "z%x,", packet
);
5315 p
= strchr (rs
->buf
, '\0');
5316 addr
= remote_address_masked (addr
);
5317 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5318 sprintf (p
, ",%x", len
);
5320 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5322 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5325 case PACKET_UNKNOWN
:
5330 internal_error (__FILE__
, __LINE__
,
5331 _("remote_remove_watchpoint: reached end of function"));
5335 int remote_hw_watchpoint_limit
= -1;
5336 int remote_hw_breakpoint_limit
= -1;
5339 remote_check_watch_resources (int type
, int cnt
, int ot
)
5341 if (type
== bp_hardware_breakpoint
)
5343 if (remote_hw_breakpoint_limit
== 0)
5345 else if (remote_hw_breakpoint_limit
< 0)
5347 else if (cnt
<= remote_hw_breakpoint_limit
)
5352 if (remote_hw_watchpoint_limit
== 0)
5354 else if (remote_hw_watchpoint_limit
< 0)
5358 else if (cnt
<= remote_hw_watchpoint_limit
)
5365 remote_stopped_by_watchpoint (void)
5367 return remote_stopped_by_watchpoint_p
;
5370 extern int stepped_after_stopped_by_watchpoint
;
5373 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5376 if (remote_stopped_by_watchpoint ()
5377 || stepped_after_stopped_by_watchpoint
)
5379 *addr_p
= remote_watch_data_address
;
5388 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5391 struct remote_state
*rs
= get_remote_state ();
5394 /* The length field should be set to the size of a breakpoint
5395 instruction, even though we aren't inserting one ourselves. */
5397 gdbarch_breakpoint_from_pc
5398 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5400 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5407 addr
= remote_address_masked (bp_tgt
->placed_address
);
5408 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5409 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5412 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5414 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5417 case PACKET_UNKNOWN
:
5422 internal_error (__FILE__
, __LINE__
,
5423 _("remote_insert_hw_breakpoint: reached end of function"));
5428 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5431 struct remote_state
*rs
= get_remote_state ();
5434 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5441 addr
= remote_address_masked (bp_tgt
->placed_address
);
5442 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5443 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5446 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5448 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5451 case PACKET_UNKNOWN
:
5456 internal_error (__FILE__
, __LINE__
,
5457 _("remote_remove_hw_breakpoint: reached end of function"));
5460 /* Some targets are only capable of doing downloads, and afterwards
5461 they switch to the remote serial protocol. This function provides
5462 a clean way to get from the download target to the remote target.
5463 It's basically just a wrapper so that we don't have to expose any
5464 of the internal workings of remote.c.
5466 Prior to calling this routine, you should shutdown the current
5467 target code, else you will get the "A program is being debugged
5468 already..." message. Usually a call to pop_target() suffices. */
5471 push_remote_target (char *name
, int from_tty
)
5473 printf_filtered (_("Switching to remote protocol\n"));
5474 remote_open (name
, from_tty
);
5477 /* Table used by the crc32 function to calcuate the checksum. */
5479 static unsigned long crc32_table
[256] =
5482 static unsigned long
5483 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5485 if (!crc32_table
[1])
5487 /* Initialize the CRC table and the decoding table. */
5491 for (i
= 0; i
< 256; i
++)
5493 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5494 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5501 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5507 /* compare-sections command
5509 With no arguments, compares each loadable section in the exec bfd
5510 with the same memory range on the target, and reports mismatches.
5511 Useful for verifying the image on the target against the exec file.
5512 Depends on the target understanding the new "qCRC:" request. */
5514 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5515 target method (target verify memory) and generic version of the
5516 actual command. This will allow other high-level code (especially
5517 generic_load()) to make use of this target functionality. */
5520 compare_sections_command (char *args
, int from_tty
)
5522 struct remote_state
*rs
= get_remote_state ();
5524 unsigned long host_crc
, target_crc
;
5525 extern bfd
*exec_bfd
;
5526 struct cleanup
*old_chain
;
5529 const char *sectname
;
5536 error (_("command cannot be used without an exec file"));
5537 if (!current_target
.to_shortname
||
5538 strcmp (current_target
.to_shortname
, "remote") != 0)
5539 error (_("command can only be used with remote target"));
5541 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5543 if (!(s
->flags
& SEC_LOAD
))
5544 continue; /* skip non-loadable section */
5546 size
= bfd_get_section_size (s
);
5548 continue; /* skip zero-length section */
5550 sectname
= bfd_get_section_name (exec_bfd
, s
);
5551 if (args
&& strcmp (args
, sectname
) != 0)
5552 continue; /* not the section selected by user */
5554 matched
= 1; /* do this section */
5556 /* FIXME: assumes lma can fit into long. */
5557 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5558 (long) lma
, (long) size
);
5561 /* Be clever; compute the host_crc before waiting for target
5563 sectdata
= xmalloc (size
);
5564 old_chain
= make_cleanup (xfree
, sectdata
);
5565 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5566 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5568 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5569 if (rs
->buf
[0] == 'E')
5570 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5571 sectname
, paddr (lma
), paddr (lma
+ size
));
5572 if (rs
->buf
[0] != 'C')
5573 error (_("remote target does not support this operation"));
5575 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5576 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5578 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5579 sectname
, paddr (lma
), paddr (lma
+ size
));
5580 if (host_crc
== target_crc
)
5581 printf_filtered ("matched.\n");
5584 printf_filtered ("MIS-MATCHED!\n");
5588 do_cleanups (old_chain
);
5591 warning (_("One or more sections of the remote executable does not match\n\
5592 the loaded file\n"));
5593 if (args
&& !matched
)
5594 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5597 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5598 into remote target. The number of bytes written to the remote
5599 target is returned, or -1 for error. */
5602 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
5603 const char *annex
, const gdb_byte
*writebuf
,
5604 ULONGEST offset
, LONGEST len
,
5605 struct packet_config
*packet
)
5610 struct remote_state
*rs
= get_remote_state ();
5611 int max_size
= get_memory_write_packet_size ();
5613 if (packet
->support
== PACKET_DISABLE
)
5616 /* Insert header. */
5617 i
= snprintf (rs
->buf
, max_size
,
5618 "qXfer:%s:write:%s:%s:",
5619 object_name
, annex
? annex
: "",
5620 phex_nz (offset
, sizeof offset
));
5621 max_size
-= (i
+ 1);
5623 /* Escape as much data as fits into rs->buf. */
5624 buf_len
= remote_escape_output
5625 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
5627 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
5628 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
5629 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5632 unpack_varlen_hex (rs
->buf
, &n
);
5636 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5637 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5638 number of bytes read is returned, or 0 for EOF, or -1 for error.
5639 The number of bytes read may be less than LEN without indicating an
5640 EOF. PACKET is checked and updated to indicate whether the remote
5641 target supports this object. */
5644 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5646 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5647 struct packet_config
*packet
)
5649 static char *finished_object
;
5650 static char *finished_annex
;
5651 static ULONGEST finished_offset
;
5653 struct remote_state
*rs
= get_remote_state ();
5654 unsigned int total
= 0;
5655 LONGEST i
, n
, packet_len
;
5657 if (packet
->support
== PACKET_DISABLE
)
5660 /* Check whether we've cached an end-of-object packet that matches
5662 if (finished_object
)
5664 if (strcmp (object_name
, finished_object
) == 0
5665 && strcmp (annex
? annex
: "", finished_annex
) == 0
5666 && offset
== finished_offset
)
5669 /* Otherwise, we're now reading something different. Discard
5671 xfree (finished_object
);
5672 xfree (finished_annex
);
5673 finished_object
= NULL
;
5674 finished_annex
= NULL
;
5677 /* Request only enough to fit in a single packet. The actual data
5678 may not, since we don't know how much of it will need to be escaped;
5679 the target is free to respond with slightly less data. We subtract
5680 five to account for the response type and the protocol frame. */
5681 n
= min (get_remote_packet_size () - 5, len
);
5682 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5683 object_name
, annex
? annex
: "",
5684 phex_nz (offset
, sizeof offset
),
5685 phex_nz (n
, sizeof n
));
5686 i
= putpkt (rs
->buf
);
5691 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5692 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5695 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5696 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5698 /* 'm' means there is (or at least might be) more data after this
5699 batch. That does not make sense unless there's at least one byte
5700 of data in this reply. */
5701 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5702 error (_("Remote qXfer reply contained no data."));
5704 /* Got some data. */
5705 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5707 /* 'l' is an EOF marker, possibly including a final block of data,
5708 or possibly empty. If we have the final block of a non-empty
5709 object, record this fact to bypass a subsequent partial read. */
5710 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
5712 finished_object
= xstrdup (object_name
);
5713 finished_annex
= xstrdup (annex
? annex
: "");
5714 finished_offset
= offset
+ i
;
5721 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5722 const char *annex
, gdb_byte
*readbuf
,
5723 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5725 struct remote_state
*rs
= get_remote_state ();
5730 /* Handle memory using the standard memory routines. */
5731 if (object
== TARGET_OBJECT_MEMORY
)
5736 if (writebuf
!= NULL
)
5737 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5739 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5743 else if (xfered
== 0 && errno
== 0)
5749 /* Handle SPU memory using qxfer packets. */
5750 if (object
== TARGET_OBJECT_SPU
)
5753 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
5754 &remote_protocol_packets
5755 [PACKET_qXfer_spu_read
]);
5757 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
5758 &remote_protocol_packets
5759 [PACKET_qXfer_spu_write
]);
5762 /* Only handle flash writes. */
5763 if (writebuf
!= NULL
)
5769 case TARGET_OBJECT_FLASH
:
5770 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5774 else if (xfered
== 0 && errno
== 0)
5784 /* Map pre-existing objects onto letters. DO NOT do this for new
5785 objects!!! Instead specify new query packets. */
5788 case TARGET_OBJECT_AVR
:
5792 case TARGET_OBJECT_AUXV
:
5793 gdb_assert (annex
== NULL
);
5794 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5795 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5797 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5798 return remote_read_qxfer
5799 (ops
, "features", annex
, readbuf
, offset
, len
,
5800 &remote_protocol_packets
[PACKET_qXfer_features
]);
5802 case TARGET_OBJECT_MEMORY_MAP
:
5803 gdb_assert (annex
== NULL
);
5804 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5805 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5811 /* Note: a zero OFFSET and LEN can be used to query the minimum
5813 if (offset
== 0 && len
== 0)
5814 return (get_remote_packet_size ());
5815 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5816 large enough let the caller deal with it. */
5817 if (len
< get_remote_packet_size ())
5819 len
= get_remote_packet_size ();
5821 /* Except for querying the minimum buffer size, target must be open. */
5823 error (_("remote query is only available after target open"));
5825 gdb_assert (annex
!= NULL
);
5826 gdb_assert (readbuf
!= NULL
);
5832 /* We used one buffer char for the remote protocol q command and
5833 another for the query type. As the remote protocol encapsulation
5834 uses 4 chars plus one extra in case we are debugging
5835 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5838 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5840 /* Bad caller may have sent forbidden characters. */
5841 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5846 gdb_assert (annex
[i
] == '\0');
5848 i
= putpkt (rs
->buf
);
5852 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5853 strcpy ((char *) readbuf
, rs
->buf
);
5855 return strlen ((char *) readbuf
);
5859 remote_rcmd (char *command
,
5860 struct ui_file
*outbuf
)
5862 struct remote_state
*rs
= get_remote_state ();
5866 error (_("remote rcmd is only available after target open"));
5868 /* Send a NULL command across as an empty command. */
5869 if (command
== NULL
)
5872 /* The query prefix. */
5873 strcpy (rs
->buf
, "qRcmd,");
5874 p
= strchr (rs
->buf
, '\0');
5876 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5877 error (_("\"monitor\" command ``%s'' is too long."), command
);
5879 /* Encode the actual command. */
5880 bin2hex ((gdb_byte
*) command
, p
, 0);
5882 if (putpkt (rs
->buf
) < 0)
5883 error (_("Communication problem with target."));
5885 /* get/display the response */
5890 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5892 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5895 error (_("Target does not support this command."));
5896 if (buf
[0] == 'O' && buf
[1] != 'K')
5898 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5901 if (strcmp (buf
, "OK") == 0)
5903 if (strlen (buf
) == 3 && buf
[0] == 'E'
5904 && isdigit (buf
[1]) && isdigit (buf
[2]))
5906 error (_("Protocol error with Rcmd"));
5908 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5910 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5911 fputc_unfiltered (c
, outbuf
);
5917 static VEC(mem_region_s
) *
5918 remote_memory_map (struct target_ops
*ops
)
5920 VEC(mem_region_s
) *result
= NULL
;
5921 char *text
= target_read_stralloc (¤t_target
,
5922 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5926 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5927 result
= parse_memory_map (text
);
5928 do_cleanups (back_to
);
5935 packet_command (char *args
, int from_tty
)
5937 struct remote_state
*rs
= get_remote_state ();
5940 error (_("command can only be used with remote target"));
5943 error (_("remote-packet command requires packet text as argument"));
5945 puts_filtered ("sending: ");
5946 print_packet (args
);
5947 puts_filtered ("\n");
5950 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5951 puts_filtered ("received: ");
5952 print_packet (rs
->buf
);
5953 puts_filtered ("\n");
5957 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5959 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5961 static void threadset_test_cmd (char *cmd
, int tty
);
5963 static void threadalive_test (char *cmd
, int tty
);
5965 static void threadlist_test_cmd (char *cmd
, int tty
);
5967 int get_and_display_threadinfo (threadref
*ref
);
5969 static void threadinfo_test_cmd (char *cmd
, int tty
);
5971 static int thread_display_step (threadref
*ref
, void *context
);
5973 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5975 static void init_remote_threadtests (void);
5977 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5980 threadset_test_cmd (char *cmd
, int tty
)
5982 int sample_thread
= SAMPLE_THREAD
;
5984 printf_filtered (_("Remote threadset test\n"));
5985 set_thread (sample_thread
, 1);
5990 threadalive_test (char *cmd
, int tty
)
5992 int sample_thread
= SAMPLE_THREAD
;
5994 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5995 printf_filtered ("PASS: Thread alive test\n");
5997 printf_filtered ("FAIL: Thread alive test\n");
6000 void output_threadid (char *title
, threadref
*ref
);
6003 output_threadid (char *title
, threadref
*ref
)
6007 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
6009 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
6013 threadlist_test_cmd (char *cmd
, int tty
)
6016 threadref nextthread
;
6017 int done
, result_count
;
6018 threadref threadlist
[3];
6020 printf_filtered ("Remote Threadlist test\n");
6021 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
6022 &result_count
, &threadlist
[0]))
6023 printf_filtered ("FAIL: threadlist test\n");
6026 threadref
*scan
= threadlist
;
6027 threadref
*limit
= scan
+ result_count
;
6029 while (scan
< limit
)
6030 output_threadid (" thread ", scan
++);
6035 display_thread_info (struct gdb_ext_thread_info
*info
)
6037 output_threadid ("Threadid: ", &info
->threadid
);
6038 printf_filtered ("Name: %s\n ", info
->shortname
);
6039 printf_filtered ("State: %s\n", info
->display
);
6040 printf_filtered ("other: %s\n\n", info
->more_display
);
6044 get_and_display_threadinfo (threadref
*ref
)
6048 struct gdb_ext_thread_info threadinfo
;
6050 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
6051 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
6052 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
6053 display_thread_info (&threadinfo
);
6058 threadinfo_test_cmd (char *cmd
, int tty
)
6060 int athread
= SAMPLE_THREAD
;
6064 int_to_threadref (&thread
, athread
);
6065 printf_filtered ("Remote Threadinfo test\n");
6066 if (!get_and_display_threadinfo (&thread
))
6067 printf_filtered ("FAIL cannot get thread info\n");
6071 thread_display_step (threadref
*ref
, void *context
)
6073 /* output_threadid(" threadstep ",ref); *//* simple test */
6074 return get_and_display_threadinfo (ref
);
6078 threadlist_update_test_cmd (char *cmd
, int tty
)
6080 printf_filtered ("Remote Threadlist update test\n");
6081 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
6085 init_remote_threadtests (void)
6087 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
6088 Fetch and print the remote list of thread identifiers, one pkt only"));
6089 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
6090 _("Fetch and display info about one thread"));
6091 add_com ("tset", class_obscure
, threadset_test_cmd
,
6092 _("Test setting to a different thread"));
6093 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
6094 _("Iterate through updating all remote thread info"));
6095 add_com ("talive", class_obscure
, threadalive_test
,
6096 _(" Remote thread alive test "));
6101 /* Convert a thread ID to a string. Returns the string in a static
6105 remote_pid_to_str (ptid_t ptid
)
6107 static char buf
[32];
6109 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
6113 /* Get the address of the thread local variable in OBJFILE which is
6114 stored at OFFSET within the thread local storage for thread PTID. */
6117 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
6119 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
6121 struct remote_state
*rs
= get_remote_state ();
6123 enum packet_result result
;
6125 strcpy (p
, "qGetTLSAddr:");
6127 p
+= hexnumstr (p
, PIDGET (ptid
));
6129 p
+= hexnumstr (p
, offset
);
6131 p
+= hexnumstr (p
, lm
);
6135 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6136 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6137 if (result
== PACKET_OK
)
6141 unpack_varlen_hex (rs
->buf
, &result
);
6144 else if (result
== PACKET_UNKNOWN
)
6145 throw_error (TLS_GENERIC_ERROR
,
6146 _("Remote target doesn't support qGetTLSAddr packet"));
6148 throw_error (TLS_GENERIC_ERROR
,
6149 _("Remote target failed to process qGetTLSAddr request"));
6152 throw_error (TLS_GENERIC_ERROR
,
6153 _("TLS not supported or disabled on this target"));
6158 /* Support for inferring a target description based on the current
6159 architecture and the size of a 'g' packet. While the 'g' packet
6160 can have any size (since optional registers can be left off the
6161 end), some sizes are easily recognizable given knowledge of the
6162 approximate architecture. */
6164 struct remote_g_packet_guess
6167 const struct target_desc
*tdesc
;
6169 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6170 DEF_VEC_O(remote_g_packet_guess_s
);
6172 struct remote_g_packet_data
6174 VEC(remote_g_packet_guess_s
) *guesses
;
6177 static struct gdbarch_data
*remote_g_packet_data_handle
;
6180 remote_g_packet_data_init (struct obstack
*obstack
)
6182 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6186 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6187 const struct target_desc
*tdesc
)
6189 struct remote_g_packet_data
*data
6190 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6191 struct remote_g_packet_guess new_guess
, *guess
;
6194 gdb_assert (tdesc
!= NULL
);
6197 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6199 if (guess
->bytes
== bytes
)
6200 internal_error (__FILE__
, __LINE__
,
6201 "Duplicate g packet description added for size %d",
6204 new_guess
.bytes
= bytes
;
6205 new_guess
.tdesc
= tdesc
;
6206 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6209 static const struct target_desc
*
6210 remote_read_description (struct target_ops
*target
)
6212 struct remote_g_packet_data
*data
6213 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6215 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6217 struct remote_g_packet_guess
*guess
;
6219 int bytes
= send_g_packet ();
6222 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6224 if (guess
->bytes
== bytes
)
6225 return guess
->tdesc
;
6227 /* We discard the g packet. A minor optimization would be to
6228 hold on to it, and fill the register cache once we have selected
6229 an architecture, but it's too tricky to do safely. */
6236 init_remote_ops (void)
6238 remote_ops
.to_shortname
= "remote";
6239 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6241 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6242 Specify the serial device it is connected to\n\
6243 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6244 remote_ops
.to_open
= remote_open
;
6245 remote_ops
.to_close
= remote_close
;
6246 remote_ops
.to_detach
= remote_detach
;
6247 remote_ops
.to_disconnect
= remote_disconnect
;
6248 remote_ops
.to_resume
= remote_resume
;
6249 remote_ops
.to_wait
= remote_wait
;
6250 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6251 remote_ops
.to_store_registers
= remote_store_registers
;
6252 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6253 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6254 remote_ops
.to_files_info
= remote_files_info
;
6255 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6256 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6257 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6258 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6259 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6260 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6261 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6262 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6263 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6264 remote_ops
.to_kill
= remote_kill
;
6265 remote_ops
.to_load
= generic_load
;
6266 remote_ops
.to_mourn_inferior
= remote_mourn
;
6267 remote_ops
.to_thread_alive
= remote_thread_alive
;
6268 remote_ops
.to_find_new_threads
= remote_threads_info
;
6269 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6270 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6271 remote_ops
.to_stop
= remote_stop
;
6272 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6273 remote_ops
.to_rcmd
= remote_rcmd
;
6274 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6275 remote_ops
.to_stratum
= process_stratum
;
6276 remote_ops
.to_has_all_memory
= 1;
6277 remote_ops
.to_has_memory
= 1;
6278 remote_ops
.to_has_stack
= 1;
6279 remote_ops
.to_has_registers
= 1;
6280 remote_ops
.to_has_execution
= 1;
6281 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6282 remote_ops
.to_magic
= OPS_MAGIC
;
6283 remote_ops
.to_memory_map
= remote_memory_map
;
6284 remote_ops
.to_flash_erase
= remote_flash_erase
;
6285 remote_ops
.to_flash_done
= remote_flash_done
;
6286 remote_ops
.to_read_description
= remote_read_description
;
6289 /* Set up the extended remote vector by making a copy of the standard
6290 remote vector and adding to it. */
6293 init_extended_remote_ops (void)
6295 extended_remote_ops
= remote_ops
;
6297 extended_remote_ops
.to_shortname
= "extended-remote";
6298 extended_remote_ops
.to_longname
=
6299 "Extended remote serial target in gdb-specific protocol";
6300 extended_remote_ops
.to_doc
=
6301 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6302 Specify the serial device it is connected to (e.g. /dev/ttya).",
6303 extended_remote_ops
.to_open
= extended_remote_open
;
6304 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6305 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6309 remote_can_async_p (void)
6311 /* We're async whenever the serial device is. */
6312 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6316 remote_is_async_p (void)
6318 /* We're async whenever the serial device is. */
6319 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6322 /* Pass the SERIAL event on and up to the client. One day this code
6323 will be able to delay notifying the client of an event until the
6324 point where an entire packet has been received. */
6326 static void (*async_client_callback
) (enum inferior_event_type event_type
,
6328 static void *async_client_context
;
6329 static serial_event_ftype remote_async_serial_handler
;
6332 remote_async_serial_handler (struct serial
*scb
, void *context
)
6334 /* Don't propogate error information up to the client. Instead let
6335 the client find out about the error by querying the target. */
6336 async_client_callback (INF_REG_EVENT
, async_client_context
);
6340 remote_async (void (*callback
) (enum inferior_event_type event_type
,
6341 void *context
), void *context
)
6343 if (current_target
.to_async_mask_value
== 0)
6344 internal_error (__FILE__
, __LINE__
,
6345 _("Calling remote_async when async is masked"));
6347 if (callback
!= NULL
)
6349 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
6350 async_client_callback
= callback
;
6351 async_client_context
= context
;
6354 serial_async (remote_desc
, NULL
, NULL
);
6357 /* Target async and target extended-async.
6359 This are temporary targets, until it is all tested. Eventually
6360 async support will be incorporated int the usual 'remote'
6364 init_remote_async_ops (void)
6366 remote_async_ops
.to_shortname
= "async";
6367 remote_async_ops
.to_longname
=
6368 "Remote serial target in async version of the gdb-specific protocol";
6369 remote_async_ops
.to_doc
=
6370 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6371 Specify the serial device it is connected to (e.g. /dev/ttya).";
6372 remote_async_ops
.to_open
= remote_async_open
;
6373 remote_async_ops
.to_close
= remote_close
;
6374 remote_async_ops
.to_detach
= remote_detach
;
6375 remote_async_ops
.to_disconnect
= remote_disconnect
;
6376 remote_async_ops
.to_resume
= remote_async_resume
;
6377 remote_async_ops
.to_wait
= remote_async_wait
;
6378 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
6379 remote_async_ops
.to_store_registers
= remote_store_registers
;
6380 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6381 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6382 remote_async_ops
.to_files_info
= remote_files_info
;
6383 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6384 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6385 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6386 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6387 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6388 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6389 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6390 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6391 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6392 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
6393 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
6394 remote_async_ops
.to_kill
= remote_async_kill
;
6395 remote_async_ops
.to_load
= generic_load
;
6396 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
6397 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
6398 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
6399 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
6400 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6401 remote_async_ops
.to_stop
= remote_stop
;
6402 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
6403 remote_async_ops
.to_rcmd
= remote_rcmd
;
6404 remote_async_ops
.to_stratum
= process_stratum
;
6405 remote_async_ops
.to_has_all_memory
= 1;
6406 remote_async_ops
.to_has_memory
= 1;
6407 remote_async_ops
.to_has_stack
= 1;
6408 remote_async_ops
.to_has_registers
= 1;
6409 remote_async_ops
.to_has_execution
= 1;
6410 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6411 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
6412 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
6413 remote_async_ops
.to_async
= remote_async
;
6414 remote_async_ops
.to_async_mask_value
= 1;
6415 remote_async_ops
.to_magic
= OPS_MAGIC
;
6416 remote_async_ops
.to_memory_map
= remote_memory_map
;
6417 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
6418 remote_async_ops
.to_flash_done
= remote_flash_done
;
6419 remote_ops
.to_read_description
= remote_read_description
;
6422 /* Set up the async extended remote vector by making a copy of the standard
6423 remote vector and adding to it. */
6426 init_extended_async_remote_ops (void)
6428 extended_async_remote_ops
= remote_async_ops
;
6430 extended_async_remote_ops
.to_shortname
= "extended-async";
6431 extended_async_remote_ops
.to_longname
=
6432 "Extended remote serial target in async gdb-specific protocol";
6433 extended_async_remote_ops
.to_doc
=
6434 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6435 Specify the serial device it is connected to (e.g. /dev/ttya).",
6436 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
6437 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
6438 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6442 set_remote_cmd (char *args
, int from_tty
)
6444 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
6448 show_remote_cmd (char *args
, int from_tty
)
6450 /* We can't just use cmd_show_list here, because we want to skip
6451 the redundant "show remote Z-packet" and the legacy aliases. */
6452 struct cleanup
*showlist_chain
;
6453 struct cmd_list_element
*list
= remote_show_cmdlist
;
6455 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
6456 for (; list
!= NULL
; list
= list
->next
)
6457 if (strcmp (list
->name
, "Z-packet") == 0)
6459 else if (list
->type
== not_set_cmd
)
6460 /* Alias commands are exactly like the original, except they
6461 don't have the normal type. */
6465 struct cleanup
*option_chain
6466 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
6467 ui_out_field_string (uiout
, "name", list
->name
);
6468 ui_out_text (uiout
, ": ");
6469 if (list
->type
== show_cmd
)
6470 do_setshow_command ((char *) NULL
, from_tty
, list
);
6472 cmd_func (list
, NULL
, from_tty
);
6473 /* Close the tuple. */
6474 do_cleanups (option_chain
);
6477 /* Close the tuple. */
6478 do_cleanups (showlist_chain
);
6482 /* Function to be called whenever a new objfile (shlib) is detected. */
6484 remote_new_objfile (struct objfile
*objfile
)
6486 if (remote_desc
!= 0) /* Have a remote connection. */
6487 remote_check_symbols (objfile
);
6491 _initialize_remote (void)
6493 struct remote_state
*rs
;
6495 /* architecture specific data */
6496 remote_gdbarch_data_handle
=
6497 gdbarch_data_register_post_init (init_remote_state
);
6498 remote_g_packet_data_handle
=
6499 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
6501 /* Initialize the per-target state. At the moment there is only one
6502 of these, not one per target. Only one target is active at a
6503 time. The default buffer size is unimportant; it will be expanded
6504 whenever a larger buffer is needed. */
6505 rs
= get_remote_state_raw ();
6507 rs
->buf
= xmalloc (rs
->buf_size
);
6510 add_target (&remote_ops
);
6512 init_extended_remote_ops ();
6513 add_target (&extended_remote_ops
);
6515 init_remote_async_ops ();
6516 add_target (&remote_async_ops
);
6518 init_extended_async_remote_ops ();
6519 add_target (&extended_async_remote_ops
);
6521 /* Hook into new objfile notification. */
6522 observer_attach_new_objfile (remote_new_objfile
);
6525 init_remote_threadtests ();
6528 /* set/show remote ... */
6530 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
6531 Remote protocol specific variables\n\
6532 Configure various remote-protocol specific variables such as\n\
6533 the packets being used"),
6534 &remote_set_cmdlist
, "set remote ",
6535 0 /* allow-unknown */, &setlist
);
6536 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
6537 Remote protocol specific variables\n\
6538 Configure various remote-protocol specific variables such as\n\
6539 the packets being used"),
6540 &remote_show_cmdlist
, "show remote ",
6541 0 /* allow-unknown */, &showlist
);
6543 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
6544 Compare section data on target to the exec file.\n\
6545 Argument is a single section name (default: all loaded sections)."),
6548 add_cmd ("packet", class_maintenance
, packet_command
, _("\
6549 Send an arbitrary packet to a remote target.\n\
6550 maintenance packet TEXT\n\
6551 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6552 this command sends the string TEXT to the inferior, and displays the\n\
6553 response packet. GDB supplies the initial `$' character, and the\n\
6554 terminating `#' character and checksum."),
6557 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
6558 Set whether to send break if interrupted."), _("\
6559 Show whether to send break if interrupted."), _("\
6560 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6561 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6562 &setlist
, &showlist
);
6564 /* Install commands for configuring memory read/write packets. */
6566 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
6567 Set the maximum number of bytes per memory write packet (deprecated)."),
6569 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
6570 Show the maximum number of bytes per memory write packet (deprecated)."),
6572 add_cmd ("memory-write-packet-size", no_class
,
6573 set_memory_write_packet_size
, _("\
6574 Set the maximum number of bytes per memory-write packet.\n\
6575 Specify the number of bytes in a packet or 0 (zero) for the\n\
6576 default packet size. The actual limit is further reduced\n\
6577 dependent on the target. Specify ``fixed'' to disable the\n\
6578 further restriction and ``limit'' to enable that restriction."),
6579 &remote_set_cmdlist
);
6580 add_cmd ("memory-read-packet-size", no_class
,
6581 set_memory_read_packet_size
, _("\
6582 Set the maximum number of bytes per memory-read packet.\n\
6583 Specify the number of bytes in a packet or 0 (zero) for the\n\
6584 default packet size. The actual limit is further reduced\n\
6585 dependent on the target. Specify ``fixed'' to disable the\n\
6586 further restriction and ``limit'' to enable that restriction."),
6587 &remote_set_cmdlist
);
6588 add_cmd ("memory-write-packet-size", no_class
,
6589 show_memory_write_packet_size
,
6590 _("Show the maximum number of bytes per memory-write packet."),
6591 &remote_show_cmdlist
);
6592 add_cmd ("memory-read-packet-size", no_class
,
6593 show_memory_read_packet_size
,
6594 _("Show the maximum number of bytes per memory-read packet."),
6595 &remote_show_cmdlist
);
6597 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6598 &remote_hw_watchpoint_limit
, _("\
6599 Set the maximum number of target hardware watchpoints."), _("\
6600 Show the maximum number of target hardware watchpoints."), _("\
6601 Specify a negative limit for unlimited."),
6602 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6603 &remote_set_cmdlist
, &remote_show_cmdlist
);
6604 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6605 &remote_hw_breakpoint_limit
, _("\
6606 Set the maximum number of target hardware breakpoints."), _("\
6607 Show the maximum number of target hardware breakpoints."), _("\
6608 Specify a negative limit for unlimited."),
6609 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6610 &remote_set_cmdlist
, &remote_show_cmdlist
);
6612 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6613 &remote_address_size
, _("\
6614 Set the maximum size of the address (in bits) in a memory packet."), _("\
6615 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6617 NULL
, /* FIXME: i18n: */
6618 &setlist
, &showlist
);
6620 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6621 "X", "binary-download", 1);
6623 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6624 "vCont", "verbose-resume", 0);
6626 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
6627 "QPassSignals", "pass-signals", 0);
6629 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6630 "qSymbol", "symbol-lookup", 0);
6632 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6633 "P", "set-register", 1);
6635 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6636 "p", "fetch-register", 1);
6638 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6639 "Z0", "software-breakpoint", 0);
6641 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6642 "Z1", "hardware-breakpoint", 0);
6644 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6645 "Z2", "write-watchpoint", 0);
6647 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6648 "Z3", "read-watchpoint", 0);
6650 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6651 "Z4", "access-watchpoint", 0);
6653 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6654 "qXfer:auxv:read", "read-aux-vector", 0);
6656 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
6657 "qXfer:features:read", "target-features", 0);
6659 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
6660 "qXfer:memory-map:read", "memory-map", 0);
6662 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
6663 "qXfer:spu:read", "read-spu-object", 0);
6665 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
6666 "qXfer:spu:write", "write-spu-object", 0);
6668 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6669 "qGetTLSAddr", "get-thread-local-storage-address",
6672 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6673 "qSupported", "supported-packets", 0);
6675 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6676 Z sub-packet has its own set and show commands, but users may
6677 have sets to this variable in their .gdbinit files (or in their
6679 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6680 &remote_Z_packet_detect
, _("\
6681 Set use of remote protocol `Z' packets"), _("\
6682 Show use of remote protocol `Z' packets "), _("\
6683 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6685 set_remote_protocol_Z_packet_cmd
,
6686 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6687 &remote_set_cmdlist
, &remote_show_cmdlist
);
6689 /* Eventually initialize fileio. See fileio.c */
6690 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);