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 3 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, see <http://www.gnu.org/licenses/>. */
22 /* See the GDB User Guide for details of the GDB remote protocol. */
25 #include "gdb_string.h"
31 #include "exceptions.h"
33 /*#include "terminal.h" */
36 #include "gdb-stabs.h"
37 #include "gdbthread.h"
41 #include "gdb_assert.h"
44 #include "cli/cli-decode.h"
45 #include "cli/cli-setshow.h"
46 #include "target-descriptions.h"
51 #include "event-loop.h"
52 #include "event-top.h"
58 #include "gdbcore.h" /* for exec_bfd */
60 #include "remote-fileio.h"
62 #include "memory-map.h"
64 /* The size to align memory write packets, when practical. The protocol
65 does not guarantee any alignment, and gdb will generate short
66 writes and unaligned writes, but even as a best-effort attempt this
67 can improve bulk transfers. For instance, if a write is misaligned
68 relative to the target's data bus, the stub may need to make an extra
69 round trip fetching data from the target. This doesn't make a
70 huge difference, but it's easy to do, so we try to be helpful.
72 The alignment chosen is arbitrary; usually data bus width is
73 important here, not the possibly larger cache line size. */
74 enum { REMOTE_ALIGN_WRITES = 16 };
76 /* Prototypes for local functions. */
77 static void cleanup_sigint_signal_handler (void *dummy);
78 static void initialize_sigint_signal_handler (void);
79 static int getpkt_sane (char **buf, long *sizeof_buf, int forever);
81 static void handle_remote_sigint (int);
82 static void handle_remote_sigint_twice (int);
83 static void async_remote_interrupt (gdb_client_data);
84 void async_remote_interrupt_twice (gdb_client_data);
86 static void remote_files_info (struct target_ops *ignore);
88 static void remote_prepare_to_store (struct regcache *regcache);
90 static void remote_fetch_registers (struct regcache *regcache, int regno);
92 static void remote_resume (ptid_t ptid, int step,
93 enum target_signal siggnal);
94 static void remote_async_resume (ptid_t ptid, int step,
95 enum target_signal siggnal);
96 static void remote_open (char *name, int from_tty);
97 static void remote_async_open (char *name, int from_tty);
99 static void extended_remote_open (char *name, int from_tty);
100 static void extended_remote_async_open (char *name, int from_tty);
102 static void remote_open_1 (char *, int, struct target_ops *, int extended_p,
105 static void remote_close (int quitting);
107 static void remote_store_registers (struct regcache *regcache, int regno);
109 static void remote_mourn (void);
110 static void remote_async_mourn (void);
112 static void extended_remote_restart (void);
114 static void extended_remote_mourn (void);
116 static void remote_mourn_1 (struct target_ops *);
118 static void remote_send (char **buf, long *sizeof_buf_p);
120 static int readchar (int timeout);
122 static ptid_t remote_wait (ptid_t ptid,
123 struct target_waitstatus *status);
124 static ptid_t remote_async_wait (ptid_t ptid,
125 struct target_waitstatus *status);
127 static void remote_kill (void);
128 static void remote_async_kill (void);
130 static int tohex (int nib);
132 static void remote_detach (char *args, int from_tty);
134 static void remote_interrupt (int signo);
136 static void remote_interrupt_twice (int signo);
138 static void interrupt_query (void);
140 static void set_thread (int, int);
142 static int remote_thread_alive (ptid_t);
144 static void get_offsets (void);
146 static void skip_frame (void);
148 static long read_frame (char **buf_p, long *sizeof_buf);
150 static int hexnumlen (ULONGEST num);
152 static void init_remote_ops (void);
154 static void init_extended_remote_ops (void);
156 static void remote_stop (void);
158 static int ishex (int ch, int *val);
160 static int stubhex (int ch);
162 static int hexnumstr (char *, ULONGEST);
164 static int hexnumnstr (char *, ULONGEST, int);
166 static CORE_ADDR remote_address_masked (CORE_ADDR);
168 static void print_packet (char *);
170 static unsigned long crc32 (unsigned char *, int, unsigned int);
172 static void compare_sections_command (char *, int);
174 static void packet_command (char *, int);
176 static int stub_unpack_int (char *buff, int fieldlength);
178 static ptid_t remote_current_thread (ptid_t oldptid);
180 static void remote_find_new_threads (void);
182 static void record_currthread (int currthread);
184 static int fromhex (int a);
186 static int hex2bin (const char *hex, gdb_byte *bin, int count);
188 static int bin2hex (const gdb_byte *bin, char *hex, int count);
190 static int putpkt_binary (char *buf, int cnt);
192 static void check_binary_download (CORE_ADDR addr);
194 struct packet_config;
196 static void show_packet_config_cmd (struct packet_config *config);
198 static void update_packet_config (struct packet_config *config);
200 static void set_remote_protocol_packet_cmd (char *args, int from_tty,
201 struct cmd_list_element *c);
203 static void show_remote_protocol_packet_cmd (struct ui_file *file,
205 struct cmd_list_element *c,
208 void _initialize_remote (void);
210 /* For "set remote" and "show remote". */
212 static struct cmd_list_element *remote_set_cmdlist;
213 static struct cmd_list_element *remote_show_cmdlist;
215 /* Description of the remote protocol state for the currently
216 connected target. This is per-target state, and independent of the
217 selected architecture. */
221 /* A buffer to use for incoming packets, and its current size. The
222 buffer is grown dynamically for larger incoming packets.
223 Outgoing packets may also be constructed in this buffer.
224 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
225 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
230 /* If we negotiated packet size explicitly (and thus can bypass
231 heuristics for the largest packet size that will not overflow
232 a buffer in the stub), this will be set to that packet size.
233 Otherwise zero, meaning to use the guessed size. */
234 long explicit_packet_size;
237 /* This data could be associated with a target, but we do not always
238 have access to the current target when we need it, so for now it is
239 static. This will be fine for as long as only one target is in use
241 static struct remote_state remote_state;
243 static struct remote_state *
244 get_remote_state_raw (void)
246 return &remote_state;
249 /* Description of the remote protocol for a given architecture. */
253 long offset; /* Offset into G packet. */
254 long regnum; /* GDB's internal register number. */
255 LONGEST pnum; /* Remote protocol register number. */
256 int in_g_packet; /* Always part of G packet. */
257 /* long size in bytes; == register_size (current_gdbarch, regnum);
259 /* char *name; == gdbarch_register_name (current_gdbarch, regnum);
263 struct remote_arch_state
265 /* Description of the remote protocol registers. */
266 long sizeof_g_packet;
268 /* Description of the remote protocol registers indexed by REGNUM
269 (making an array gdbarch_num_regs in size). */
270 struct packet_reg *regs;
272 /* This is the size (in chars) of the first response to the ``g''
273 packet. It is used as a heuristic when determining the maximum
274 size of memory-read and memory-write packets. A target will
275 typically only reserve a buffer large enough to hold the ``g''
276 packet. The size does not include packet overhead (headers and
278 long actual_register_packet_size;
280 /* This is the maximum size (in chars) of a non read/write packet.
281 It is also used as a cap on the size of read/write packets. */
282 long remote_packet_size;
286 /* Handle for retreving the remote protocol data from gdbarch. */
287 static struct gdbarch_data *remote_gdbarch_data_handle;
289 static struct remote_arch_state *
290 get_remote_arch_state (void)
292 return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
295 /* Fetch the global remote target state. */
297 static struct remote_state *
298 get_remote_state (void)
300 /* Make sure that the remote architecture state has been
301 initialized, because doing so might reallocate rs->buf. Any
302 function which calls getpkt also needs to be mindful of changes
303 to rs->buf, but this call limits the number of places which run
305 get_remote_arch_state ();
307 return get_remote_state_raw ();
311 compare_pnums (const void *lhs_, const void *rhs_)
313 const struct packet_reg * const *lhs = lhs_;
314 const struct packet_reg * const *rhs = rhs_;
316 if ((*lhs)->pnum < (*rhs)->pnum)
318 else if ((*lhs)->pnum == (*rhs)->pnum)
325 init_remote_state (struct gdbarch *gdbarch)
327 int regnum, num_remote_regs, offset;
328 struct remote_state *rs = get_remote_state_raw ();
329 struct remote_arch_state *rsa;
330 struct packet_reg **remote_regs;
332 rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
334 /* Use the architecture to build a regnum<->pnum table, which will be
335 1:1 unless a feature set specifies otherwise. */
336 rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,
337 gdbarch_num_regs (current_gdbarch),
339 for (regnum = 0; regnum < gdbarch_num_regs (current_gdbarch); regnum++)
341 struct packet_reg *r = &rsa->regs[regnum];
343 if (register_size (current_gdbarch, regnum) == 0)
344 /* Do not try to fetch zero-sized (placeholder) registers. */
347 r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
352 /* Define the g/G packet format as the contents of each register
353 with a remote protocol number, in order of ascending protocol
356 remote_regs = alloca (gdbarch_num_regs (current_gdbarch)
357 * sizeof (struct packet_reg *));
358 for (num_remote_regs = 0, regnum = 0;
359 regnum < gdbarch_num_regs (current_gdbarch);
361 if (rsa->regs[regnum].pnum != -1)
362 remote_regs[num_remote_regs++] = &rsa->regs[regnum];
364 qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
367 for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
369 remote_regs[regnum]->in_g_packet = 1;
370 remote_regs[regnum]->offset = offset;
371 offset += register_size (current_gdbarch, remote_regs[regnum]->regnum);
374 /* Record the maximum possible size of the g packet - it may turn out
376 rsa->sizeof_g_packet = offset;
378 /* Default maximum number of characters in a packet body. Many
379 remote stubs have a hardwired buffer size of 400 bytes
380 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
381 as the maximum packet-size to ensure that the packet and an extra
382 NUL character can always fit in the buffer. This stops GDB
383 trashing stubs that try to squeeze an extra NUL into what is
384 already a full buffer (As of 1999-12-04 that was most stubs). */
385 rsa->remote_packet_size = 400 - 1;
387 /* This one is filled in when a ``g'' packet is received. */
388 rsa->actual_register_packet_size = 0;
390 /* Should rsa->sizeof_g_packet needs more space than the
391 default, adjust the size accordingly. Remember that each byte is
392 encoded as two characters. 32 is the overhead for the packet
393 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
394 (``$NN:G...#NN'') is a better guess, the below has been padded a
396 if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
397 rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
399 /* Make sure that the packet buffer is plenty big enough for
400 this architecture. */
401 if (rs->buf_size < rsa->remote_packet_size)
403 rs->buf_size = 2 * rsa->remote_packet_size;
404 rs->buf = xrealloc (rs->buf, rs->buf_size);
410 /* Return the current allowed size of a remote packet. This is
411 inferred from the current architecture, and should be used to
412 limit the length of outgoing packets. */
414 get_remote_packet_size (void)
416 struct remote_state *rs = get_remote_state ();
417 struct remote_arch_state *rsa = get_remote_arch_state ();
419 if (rs->explicit_packet_size)
420 return rs->explicit_packet_size;
422 return rsa->remote_packet_size;
425 static struct packet_reg *
426 packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
428 if (regnum < 0 && regnum >= gdbarch_num_regs (current_gdbarch))
432 struct packet_reg *r = &rsa->regs[regnum];
433 gdb_assert (r->regnum == regnum);
438 static struct packet_reg *
439 packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
442 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
444 struct packet_reg *r = &rsa->regs[i];
451 /* FIXME: graces/2002-08-08: These variables should eventually be
452 bound to an instance of the target object (as in gdbarch-tdep()),
453 when such a thing exists. */
455 /* This is set to the data address of the access causing the target
456 to stop for a watchpoint. */
457 static CORE_ADDR remote_watch_data_address;
459 /* This is non-zero if target stopped for a watchpoint. */
460 static int remote_stopped_by_watchpoint_p;
462 static struct target_ops remote_ops;
464 static struct target_ops extended_remote_ops;
466 /* Temporary target ops. Just like the remote_ops and
467 extended_remote_ops, but with asynchronous support. */
468 static struct target_ops remote_async_ops;
470 static struct target_ops extended_async_remote_ops;
472 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
473 ``forever'' still use the normal timeout mechanism. This is
474 currently used by the ASYNC code to guarentee that target reads
475 during the initial connect always time-out. Once getpkt has been
476 modified to return a timeout indication and, in turn
477 remote_wait()/wait_for_inferior() have gained a timeout parameter
479 static int wait_forever_enabled_p = 1;
482 /* This variable chooses whether to send a ^C or a break when the user
483 requests program interruption. Although ^C is usually what remote
484 systems expect, and that is the default here, sometimes a break is
485 preferable instead. */
487 static int remote_break;
489 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
490 remote_open knows that we don't have a file open when the program
492 static struct serial *remote_desc = NULL;
494 /* This variable sets the number of bits in an address that are to be
495 sent in a memory ("M" or "m") packet. Normally, after stripping
496 leading zeros, the entire address would be sent. This variable
497 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
498 initial implementation of remote.c restricted the address sent in
499 memory packets to ``host::sizeof long'' bytes - (typically 32
500 bits). Consequently, for 64 bit targets, the upper 32 bits of an
501 address was never sent. Since fixing this bug may cause a break in
502 some remote targets this variable is principly provided to
503 facilitate backward compatibility. */
505 static int remote_address_size;
507 /* Tempoary to track who currently owns the terminal. See
508 target_async_terminal_* for more details. */
510 static int remote_async_terminal_ours_p;
513 /* User configurable variables for the number of characters in a
514 memory read/write packet. MIN (rsa->remote_packet_size,
515 rsa->sizeof_g_packet) is the default. Some targets need smaller
516 values (fifo overruns, et.al.) and some users need larger values
517 (speed up transfers). The variables ``preferred_*'' (the user
518 request), ``current_*'' (what was actually set) and ``forced_*''
519 (Positive - a soft limit, negative - a hard limit). */
521 struct memory_packet_config
528 /* Compute the current size of a read/write packet. Since this makes
529 use of ``actual_register_packet_size'' the computation is dynamic. */
532 get_memory_packet_size (struct memory_packet_config *config)
534 struct remote_state *rs = get_remote_state ();
535 struct remote_arch_state *rsa = get_remote_arch_state ();
537 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
538 law?) that some hosts don't cope very well with large alloca()
539 calls. Eventually the alloca() code will be replaced by calls to
540 xmalloc() and make_cleanups() allowing this restriction to either
541 be lifted or removed. */
542 #ifndef MAX_REMOTE_PACKET_SIZE
543 #define MAX_REMOTE_PACKET_SIZE 16384
545 /* NOTE: 20 ensures we can write at least one byte. */
546 #ifndef MIN_REMOTE_PACKET_SIZE
547 #define MIN_REMOTE_PACKET_SIZE 20
552 if (config->size <= 0)
553 what_they_get = MAX_REMOTE_PACKET_SIZE;
555 what_they_get = config->size;
559 what_they_get = get_remote_packet_size ();
560 /* Limit the packet to the size specified by the user. */
562 && what_they_get > config->size)
563 what_they_get = config->size;
565 /* Limit it to the size of the targets ``g'' response unless we have
566 permission from the stub to use a larger packet size. */
567 if (rs->explicit_packet_size == 0
568 && rsa->actual_register_packet_size > 0
569 && what_they_get > rsa->actual_register_packet_size)
570 what_they_get = rsa->actual_register_packet_size;
572 if (what_they_get > MAX_REMOTE_PACKET_SIZE)
573 what_they_get = MAX_REMOTE_PACKET_SIZE;
574 if (what_they_get < MIN_REMOTE_PACKET_SIZE)
575 what_they_get = MIN_REMOTE_PACKET_SIZE;
577 /* Make sure there is room in the global buffer for this packet
578 (including its trailing NUL byte). */
579 if (rs->buf_size < what_they_get + 1)
581 rs->buf_size = 2 * what_they_get;
582 rs->buf = xrealloc (rs->buf, 2 * what_they_get);
585 return what_they_get;
588 /* Update the size of a read/write packet. If they user wants
589 something really big then do a sanity check. */
592 set_memory_packet_size (char *args, struct memory_packet_config *config)
594 int fixed_p = config->fixed_p;
595 long size = config->size;
597 error (_("Argument required (integer, `fixed' or `limited')."));
598 else if (strcmp (args, "hard") == 0
599 || strcmp (args, "fixed") == 0)
601 else if (strcmp (args, "soft") == 0
602 || strcmp (args, "limit") == 0)
607 size = strtoul (args, &end, 0);
609 error (_("Invalid %s (bad syntax)."), config->name);
611 /* Instead of explicitly capping the size of a packet to
612 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
613 instead allowed to set the size to something arbitrarily
615 if (size > MAX_REMOTE_PACKET_SIZE)
616 error (_("Invalid %s (too large)."), config->name);
620 if (fixed_p && !config->fixed_p)
622 if (! query (_("The target may not be able to correctly handle a %s\n"
623 "of %ld bytes. Change the packet size? "),
625 error (_("Packet size not changed."));
627 /* Update the config. */
628 config->fixed_p = fixed_p;
633 show_memory_packet_size (struct memory_packet_config *config)
635 printf_filtered (_("The %s is %ld. "), config->name, config->size);
637 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
638 get_memory_packet_size (config));
640 printf_filtered (_("Packets are limited to %ld bytes.\n"),
641 get_memory_packet_size (config));
644 static struct memory_packet_config memory_write_packet_config =
646 "memory-write-packet-size",
650 set_memory_write_packet_size (char *args, int from_tty)
652 set_memory_packet_size (args, &memory_write_packet_config);
656 show_memory_write_packet_size (char *args, int from_tty)
658 show_memory_packet_size (&memory_write_packet_config);
662 get_memory_write_packet_size (void)
664 return get_memory_packet_size (&memory_write_packet_config);
667 static struct memory_packet_config memory_read_packet_config =
669 "memory-read-packet-size",
673 set_memory_read_packet_size (char *args, int from_tty)
675 set_memory_packet_size (args, &memory_read_packet_config);
679 show_memory_read_packet_size (char *args, int from_tty)
681 show_memory_packet_size (&memory_read_packet_config);
685 get_memory_read_packet_size (void)
687 long size = get_memory_packet_size (&memory_read_packet_config);
688 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
689 extra buffer size argument before the memory read size can be
690 increased beyond this. */
691 if (size > get_remote_packet_size ())
692 size = get_remote_packet_size ();
697 /* Generic configuration support for packets the stub optionally
698 supports. Allows the user to specify the use of the packet as well
699 as allowing GDB to auto-detect support in the remote stub. */
703 PACKET_SUPPORT_UNKNOWN = 0,
712 enum auto_boolean detect;
713 enum packet_support support;
716 /* Analyze a packet's return value and update the packet config
727 update_packet_config (struct packet_config *config)
729 switch (config->detect)
731 case AUTO_BOOLEAN_TRUE:
732 config->support = PACKET_ENABLE;
734 case AUTO_BOOLEAN_FALSE:
735 config->support = PACKET_DISABLE;
737 case AUTO_BOOLEAN_AUTO:
738 config->support = PACKET_SUPPORT_UNKNOWN;
744 show_packet_config_cmd (struct packet_config *config)
746 char *support = "internal-error";
747 switch (config->support)
753 support = "disabled";
755 case PACKET_SUPPORT_UNKNOWN:
759 switch (config->detect)
761 case AUTO_BOOLEAN_AUTO:
762 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
763 config->name, support);
765 case AUTO_BOOLEAN_TRUE:
766 case AUTO_BOOLEAN_FALSE:
767 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
768 config->name, support);
774 add_packet_config_cmd (struct packet_config *config, const char *name,
775 const char *title, int legacy)
782 config->title = title;
783 config->detect = AUTO_BOOLEAN_AUTO;
784 config->support = PACKET_SUPPORT_UNKNOWN;
785 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
787 show_doc = xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
789 /* set/show TITLE-packet {auto,on,off} */
790 cmd_name = xstrprintf ("%s-packet", title);
791 add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
792 &config->detect, set_doc, show_doc, NULL, /* help_doc */
793 set_remote_protocol_packet_cmd,
794 show_remote_protocol_packet_cmd,
795 &remote_set_cmdlist, &remote_show_cmdlist);
796 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
800 legacy_name = xstrprintf ("%s-packet", name);
801 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
802 &remote_set_cmdlist);
803 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
804 &remote_show_cmdlist);
808 static enum packet_result
809 packet_check_result (const char *buf)
813 /* The stub recognized the packet request. Check that the
814 operation succeeded. */
816 && isxdigit (buf[1]) && isxdigit (buf[2])
818 /* "Enn" - definitly an error. */
821 /* Always treat "E." as an error. This will be used for
822 more verbose error messages, such as E.memtypes. */
823 if (buf[0] == 'E' && buf[1] == '.')
826 /* The packet may or may not be OK. Just assume it is. */
830 /* The stub does not support the packet. */
831 return PACKET_UNKNOWN;
834 static enum packet_result
835 packet_ok (const char *buf, struct packet_config *config)
837 enum packet_result result;
839 result = packet_check_result (buf);
844 /* The stub recognized the packet request. */
845 switch (config->support)
847 case PACKET_SUPPORT_UNKNOWN:
849 fprintf_unfiltered (gdb_stdlog,
850 "Packet %s (%s) is supported\n",
851 config->name, config->title);
852 config->support = PACKET_ENABLE;
855 internal_error (__FILE__, __LINE__,
856 _("packet_ok: attempt to use a disabled packet"));
863 /* The stub does not support the packet. */
864 switch (config->support)
867 if (config->detect == AUTO_BOOLEAN_AUTO)
868 /* If the stub previously indicated that the packet was
869 supported then there is a protocol error.. */
870 error (_("Protocol error: %s (%s) conflicting enabled responses."),
871 config->name, config->title);
873 /* The user set it wrong. */
874 error (_("Enabled packet %s (%s) not recognized by stub"),
875 config->name, config->title);
877 case PACKET_SUPPORT_UNKNOWN:
879 fprintf_unfiltered (gdb_stdlog,
880 "Packet %s (%s) is NOT supported\n",
881 config->name, config->title);
882 config->support = PACKET_DISABLE;
905 PACKET_qXfer_features,
906 PACKET_qXfer_libraries,
907 PACKET_qXfer_memory_map,
908 PACKET_qXfer_spu_read,
909 PACKET_qXfer_spu_write,
916 static struct packet_config remote_protocol_packets[PACKET_MAX];
919 set_remote_protocol_packet_cmd (char *args, int from_tty,
920 struct cmd_list_element *c)
922 struct packet_config *packet;
924 for (packet = remote_protocol_packets;
925 packet < &remote_protocol_packets[PACKET_MAX];
928 if (&packet->detect == c->var)
930 update_packet_config (packet);
934 internal_error (__FILE__, __LINE__, "Could not find config for %s",
939 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
940 struct cmd_list_element *c,
943 struct packet_config *packet;
945 for (packet = remote_protocol_packets;
946 packet < &remote_protocol_packets[PACKET_MAX];
949 if (&packet->detect == c->var)
951 show_packet_config_cmd (packet);
955 internal_error (__FILE__, __LINE__, "Could not find config for %s",
959 /* Should we try one of the 'Z' requests? */
963 Z_PACKET_SOFTWARE_BP,
964 Z_PACKET_HARDWARE_BP,
971 /* For compatibility with older distributions. Provide a ``set remote
972 Z-packet ...'' command that updates all the Z packet types. */
974 static enum auto_boolean remote_Z_packet_detect;
977 set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
978 struct cmd_list_element *c)
981 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
983 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
984 update_packet_config (&remote_protocol_packets[PACKET_Z0 + i]);
989 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
990 struct cmd_list_element *c,
994 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
996 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
1000 /* Should we try the 'ThreadInfo' query packet?
1002 This variable (NOT available to the user: auto-detect only!)
1003 determines whether GDB will use the new, simpler "ThreadInfo"
1004 query or the older, more complex syntax for thread queries.
1005 This is an auto-detect variable (set to true at each connect,
1006 and set to false when the target fails to recognize it). */
1008 static int use_threadinfo_query;
1009 static int use_threadextra_query;
1011 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1012 static struct async_signal_handler *sigint_remote_twice_token;
1013 static struct async_signal_handler *sigint_remote_token;
1015 /* These are pointers to hook functions that may be set in order to
1016 modify resume/wait behavior for a particular architecture. */
1018 void (*deprecated_target_resume_hook) (void);
1019 void (*deprecated_target_wait_loop_hook) (void);
1023 /* These are the threads which we last sent to the remote system.
1024 -1 for all or -2 for not sent yet. */
1025 static int general_thread;
1026 static int continue_thread;
1028 /* Call this function as a result of
1029 1) A halt indication (T packet) containing a thread id
1030 2) A direct query of currthread
1031 3) Successful execution of set thread
1035 record_currthread (int currthread)
1037 general_thread = currthread;
1039 /* If this is a new thread, add it to GDB's thread list.
1040 If we leave it up to WFI to do this, bad things will happen. */
1041 if (!in_thread_list (pid_to_ptid (currthread)))
1043 add_thread (pid_to_ptid (currthread));
1044 ui_out_text (uiout, "[New ");
1045 ui_out_text (uiout, target_pid_to_str (pid_to_ptid (currthread)));
1046 ui_out_text (uiout, "]\n");
1050 static char *last_pass_packet;
1052 /* If 'QPassSignals' is supported, tell the remote stub what signals
1053 it can simply pass through to the inferior without reporting. */
1056 remote_pass_signals (void)
1058 if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE)
1060 char *pass_packet, *p;
1061 int numsigs = (int) TARGET_SIGNAL_LAST;
1064 gdb_assert (numsigs < 256);
1065 for (i = 0; i < numsigs; i++)
1067 if (signal_stop_state (i) == 0
1068 && signal_print_state (i) == 0
1069 && signal_pass_state (i) == 1)
1072 pass_packet = xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
1073 strcpy (pass_packet, "QPassSignals:");
1074 p = pass_packet + strlen (pass_packet);
1075 for (i = 0; i < numsigs; i++)
1077 if (signal_stop_state (i) == 0
1078 && signal_print_state (i) == 0
1079 && signal_pass_state (i) == 1)
1082 *p++ = tohex (i >> 4);
1083 *p++ = tohex (i & 15);
1092 if (!last_pass_packet || strcmp (last_pass_packet, pass_packet))
1094 struct remote_state *rs = get_remote_state ();
1095 char *buf = rs->buf;
1097 putpkt (pass_packet);
1098 getpkt (&rs->buf, &rs->buf_size, 0);
1099 packet_ok (buf, &remote_protocol_packets[PACKET_QPassSignals]);
1100 if (last_pass_packet)
1101 xfree (last_pass_packet);
1102 last_pass_packet = pass_packet;
1105 xfree (pass_packet);
1109 #define MAGIC_NULL_PID 42000
1112 set_thread (int th, int gen)
1114 struct remote_state *rs = get_remote_state ();
1115 char *buf = rs->buf;
1116 int state = gen ? general_thread : continue_thread;
1122 buf[1] = gen ? 'g' : 'c';
1123 if (th == MAGIC_NULL_PID)
1129 xsnprintf (&buf[2], get_remote_packet_size () - 2, "-%x", -th);
1131 xsnprintf (&buf[2], get_remote_packet_size () - 2, "%x", th);
1133 getpkt (&rs->buf, &rs->buf_size, 0);
1135 general_thread = th;
1137 continue_thread = th;
1140 /* Return nonzero if the thread TH is still alive on the remote system. */
1143 remote_thread_alive (ptid_t ptid)
1145 struct remote_state *rs = get_remote_state ();
1146 int tid = PIDGET (ptid);
1149 xsnprintf (rs->buf, get_remote_packet_size (), "T-%08x", -tid);
1151 xsnprintf (rs->buf, get_remote_packet_size (), "T%08x", tid);
1153 getpkt (&rs->buf, &rs->buf_size, 0);
1154 return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
1157 /* About these extended threadlist and threadinfo packets. They are
1158 variable length packets but, the fields within them are often fixed
1159 length. They are redundent enough to send over UDP as is the
1160 remote protocol in general. There is a matching unit test module
1163 #define OPAQUETHREADBYTES 8
1165 /* a 64 bit opaque identifier */
1166 typedef unsigned char threadref[OPAQUETHREADBYTES];
1168 /* WARNING: This threadref data structure comes from the remote O.S.,
1169 libstub protocol encoding, and remote.c. it is not particularly
1172 /* Right now, the internal structure is int. We want it to be bigger.
1176 typedef int gdb_threadref; /* Internal GDB thread reference. */
1178 /* gdb_ext_thread_info is an internal GDB data structure which is
1179 equivalent to the reply of the remote threadinfo packet. */
1181 struct gdb_ext_thread_info
1183 threadref threadid; /* External form of thread reference. */
1184 int active; /* Has state interesting to GDB?
1186 char display[256]; /* Brief state display, name,
1187 blocked/suspended. */
1188 char shortname[32]; /* To be used to name threads. */
1189 char more_display[256]; /* Long info, statistics, queue depth,
1193 /* The volume of remote transfers can be limited by submitting
1194 a mask containing bits specifying the desired information.
1195 Use a union of these values as the 'selection' parameter to
1196 get_thread_info. FIXME: Make these TAG names more thread specific.
1199 #define TAG_THREADID 1
1200 #define TAG_EXISTS 2
1201 #define TAG_DISPLAY 4
1202 #define TAG_THREADNAME 8
1203 #define TAG_MOREDISPLAY 16
1205 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1207 char *unpack_varlen_hex (char *buff, ULONGEST *result);
1209 static char *unpack_nibble (char *buf, int *val);
1211 static char *pack_nibble (char *buf, int nibble);
1213 static char *pack_hex_byte (char *pkt, int /* unsigned char */ byte);
1215 static char *unpack_byte (char *buf, int *value);
1217 static char *pack_int (char *buf, int value);
1219 static char *unpack_int (char *buf, int *value);
1221 static char *unpack_string (char *src, char *dest, int length);
1223 static char *pack_threadid (char *pkt, threadref *id);
1225 static char *unpack_threadid (char *inbuf, threadref *id);
1227 void int_to_threadref (threadref *id, int value);
1229 static int threadref_to_int (threadref *ref);
1231 static void copy_threadref (threadref *dest, threadref *src);
1233 static int threadmatch (threadref *dest, threadref *src);
1235 static char *pack_threadinfo_request (char *pkt, int mode,
1238 static int remote_unpack_thread_info_response (char *pkt,
1239 threadref *expectedref,
1240 struct gdb_ext_thread_info
1244 static int remote_get_threadinfo (threadref *threadid,
1245 int fieldset, /*TAG mask */
1246 struct gdb_ext_thread_info *info);
1248 static char *pack_threadlist_request (char *pkt, int startflag,
1250 threadref *nextthread);
1252 static int parse_threadlist_response (char *pkt,
1254 threadref *original_echo,
1255 threadref *resultlist,
1258 static int remote_get_threadlist (int startflag,
1259 threadref *nextthread,
1263 threadref *threadlist);
1265 typedef int (*rmt_thread_action) (threadref *ref, void *context);
1267 static int remote_threadlist_iterator (rmt_thread_action stepfunction,
1268 void *context, int looplimit);
1270 static int remote_newthread_step (threadref *ref, void *context);
1272 /* Encode 64 bits in 16 chars of hex. */
1274 static const char hexchars[] = "0123456789abcdef";
1277 ishex (int ch, int *val)
1279 if ((ch >= 'a') && (ch <= 'f'))
1281 *val = ch - 'a' + 10;
1284 if ((ch >= 'A') && (ch <= 'F'))
1286 *val = ch - 'A' + 10;
1289 if ((ch >= '0') && (ch <= '9'))
1300 if (ch >= 'a' && ch <= 'f')
1301 return ch - 'a' + 10;
1302 if (ch >= '0' && ch <= '9')
1304 if (ch >= 'A' && ch <= 'F')
1305 return ch - 'A' + 10;
1310 stub_unpack_int (char *buff, int fieldlength)
1317 nibble = stubhex (*buff++);
1321 retval = retval << 4;
1327 unpack_varlen_hex (char *buff, /* packet to parse */
1331 ULONGEST retval = 0;
1333 while (ishex (*buff, &nibble))
1336 retval = retval << 4;
1337 retval |= nibble & 0x0f;
1344 unpack_nibble (char *buf, int *val)
1346 ishex (*buf++, val);
1351 pack_nibble (char *buf, int nibble)
1353 *buf++ = hexchars[(nibble & 0x0f)];
1358 pack_hex_byte (char *pkt, int byte)
1360 *pkt++ = hexchars[(byte >> 4) & 0xf];
1361 *pkt++ = hexchars[(byte & 0xf)];
1366 unpack_byte (char *buf, int *value)
1368 *value = stub_unpack_int (buf, 2);
1373 pack_int (char *buf, int value)
1375 buf = pack_hex_byte (buf, (value >> 24) & 0xff);
1376 buf = pack_hex_byte (buf, (value >> 16) & 0xff);
1377 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
1378 buf = pack_hex_byte (buf, (value & 0xff));
1383 unpack_int (char *buf, int *value)
1385 *value = stub_unpack_int (buf, 8);
1389 #if 0 /* Currently unused, uncomment when needed. */
1390 static char *pack_string (char *pkt, char *string);
1393 pack_string (char *pkt, char *string)
1398 len = strlen (string);
1400 len = 200; /* Bigger than most GDB packets, junk??? */
1401 pkt = pack_hex_byte (pkt, len);
1405 if ((ch == '\0') || (ch == '#'))
1406 ch = '*'; /* Protect encapsulation. */
1411 #endif /* 0 (unused) */
1414 unpack_string (char *src, char *dest, int length)
1423 pack_threadid (char *pkt, threadref *id)
1426 unsigned char *altid;
1428 altid = (unsigned char *) id;
1429 limit = pkt + BUF_THREAD_ID_SIZE;
1431 pkt = pack_hex_byte (pkt, *altid++);
1437 unpack_threadid (char *inbuf, threadref *id)
1440 char *limit = inbuf + BUF_THREAD_ID_SIZE;
1443 altref = (char *) id;
1445 while (inbuf < limit)
1447 x = stubhex (*inbuf++);
1448 y = stubhex (*inbuf++);
1449 *altref++ = (x << 4) | y;
1454 /* Externally, threadrefs are 64 bits but internally, they are still
1455 ints. This is due to a mismatch of specifications. We would like
1456 to use 64bit thread references internally. This is an adapter
1460 int_to_threadref (threadref *id, int value)
1462 unsigned char *scan;
1464 scan = (unsigned char *) id;
1470 *scan++ = (value >> 24) & 0xff;
1471 *scan++ = (value >> 16) & 0xff;
1472 *scan++ = (value >> 8) & 0xff;
1473 *scan++ = (value & 0xff);
1477 threadref_to_int (threadref *ref)
1480 unsigned char *scan;
1486 value = (value << 8) | ((*scan++) & 0xff);
1491 copy_threadref (threadref *dest, threadref *src)
1494 unsigned char *csrc, *cdest;
1496 csrc = (unsigned char *) src;
1497 cdest = (unsigned char *) dest;
1504 threadmatch (threadref *dest, threadref *src)
1506 /* Things are broken right now, so just assume we got a match. */
1508 unsigned char *srcp, *destp;
1510 srcp = (char *) src;
1511 destp = (char *) dest;
1515 result &= (*srcp++ == *destp++) ? 1 : 0;
1522 threadid:1, # always request threadid
1529 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1532 pack_threadinfo_request (char *pkt, int mode, threadref *id)
1534 *pkt++ = 'q'; /* Info Query */
1535 *pkt++ = 'P'; /* process or thread info */
1536 pkt = pack_int (pkt, mode); /* mode */
1537 pkt = pack_threadid (pkt, id); /* threadid */
1538 *pkt = '\0'; /* terminate */
1542 /* These values tag the fields in a thread info response packet. */
1543 /* Tagging the fields allows us to request specific fields and to
1544 add more fields as time goes by. */
1546 #define TAG_THREADID 1 /* Echo the thread identifier. */
1547 #define TAG_EXISTS 2 /* Is this process defined enough to
1548 fetch registers and its stack? */
1549 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1550 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1551 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1555 remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
1556 struct gdb_ext_thread_info *info)
1558 struct remote_state *rs = get_remote_state ();
1562 char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */
1565 /* info->threadid = 0; FIXME: implement zero_threadref. */
1567 info->display[0] = '\0';
1568 info->shortname[0] = '\0';
1569 info->more_display[0] = '\0';
1571 /* Assume the characters indicating the packet type have been
1573 pkt = unpack_int (pkt, &mask); /* arg mask */
1574 pkt = unpack_threadid (pkt, &ref);
1577 warning (_("Incomplete response to threadinfo request."));
1578 if (!threadmatch (&ref, expectedref))
1579 { /* This is an answer to a different request. */
1580 warning (_("ERROR RMT Thread info mismatch."));
1583 copy_threadref (&info->threadid, &ref);
1585 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1587 /* Packets are terminated with nulls. */
1588 while ((pkt < limit) && mask && *pkt)
1590 pkt = unpack_int (pkt, &tag); /* tag */
1591 pkt = unpack_byte (pkt, &length); /* length */
1592 if (!(tag & mask)) /* Tags out of synch with mask. */
1594 warning (_("ERROR RMT: threadinfo tag mismatch."));
1598 if (tag == TAG_THREADID)
1602 warning (_("ERROR RMT: length of threadid is not 16."));
1606 pkt = unpack_threadid (pkt, &ref);
1607 mask = mask & ~TAG_THREADID;
1610 if (tag == TAG_EXISTS)
1612 info->active = stub_unpack_int (pkt, length);
1614 mask = mask & ~(TAG_EXISTS);
1617 warning (_("ERROR RMT: 'exists' length too long."));
1623 if (tag == TAG_THREADNAME)
1625 pkt = unpack_string (pkt, &info->shortname[0], length);
1626 mask = mask & ~TAG_THREADNAME;
1629 if (tag == TAG_DISPLAY)
1631 pkt = unpack_string (pkt, &info->display[0], length);
1632 mask = mask & ~TAG_DISPLAY;
1635 if (tag == TAG_MOREDISPLAY)
1637 pkt = unpack_string (pkt, &info->more_display[0], length);
1638 mask = mask & ~TAG_MOREDISPLAY;
1641 warning (_("ERROR RMT: unknown thread info tag."));
1642 break; /* Not a tag we know about. */
1648 remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */
1649 struct gdb_ext_thread_info *info)
1651 struct remote_state *rs = get_remote_state ();
1654 pack_threadinfo_request (rs->buf, fieldset, threadid);
1656 getpkt (&rs->buf, &rs->buf_size, 0);
1657 result = remote_unpack_thread_info_response (rs->buf + 2,
1662 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1665 pack_threadlist_request (char *pkt, int startflag, int threadcount,
1666 threadref *nextthread)
1668 *pkt++ = 'q'; /* info query packet */
1669 *pkt++ = 'L'; /* Process LIST or threadLIST request */
1670 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
1671 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
1672 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
1677 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1680 parse_threadlist_response (char *pkt, int result_limit,
1681 threadref *original_echo, threadref *resultlist,
1684 struct remote_state *rs = get_remote_state ();
1686 int count, resultcount, done;
1689 /* Assume the 'q' and 'M chars have been stripped. */
1690 limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
1691 /* done parse past here */
1692 pkt = unpack_byte (pkt, &count); /* count field */
1693 pkt = unpack_nibble (pkt, &done);
1694 /* The first threadid is the argument threadid. */
1695 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
1696 while ((count-- > 0) && (pkt < limit))
1698 pkt = unpack_threadid (pkt, resultlist++);
1699 if (resultcount++ >= result_limit)
1708 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
1709 int *done, int *result_count, threadref *threadlist)
1711 struct remote_state *rs = get_remote_state ();
1712 static threadref echo_nextthread;
1715 /* Trancate result limit to be smaller than the packet size. */
1716 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= get_remote_packet_size ())
1717 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
1719 pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
1721 getpkt (&rs->buf, &rs->buf_size, 0);
1724 parse_threadlist_response (rs->buf + 2, result_limit, &echo_nextthread,
1727 if (!threadmatch (&echo_nextthread, nextthread))
1729 /* FIXME: This is a good reason to drop the packet. */
1730 /* Possably, there is a duplicate response. */
1732 retransmit immediatly - race conditions
1733 retransmit after timeout - yes
1735 wait for packet, then exit
1737 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1738 return 0; /* I choose simply exiting. */
1740 if (*result_count <= 0)
1744 warning (_("RMT ERROR : failed to get remote thread list."));
1747 return result; /* break; */
1749 if (*result_count > result_limit)
1752 warning (_("RMT ERROR: threadlist response longer than requested."));
1758 /* This is the interface between remote and threads, remotes upper
1761 /* remote_find_new_threads retrieves the thread list and for each
1762 thread in the list, looks up the thread in GDB's internal list,
1763 ading the thread if it does not already exist. This involves
1764 getting partial thread lists from the remote target so, polling the
1765 quit_flag is required. */
1768 /* About this many threadisds fit in a packet. */
1770 #define MAXTHREADLISTRESULTS 32
1773 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
1776 int done, i, result_count;
1780 static threadref nextthread;
1781 static threadref resultthreadlist[MAXTHREADLISTRESULTS];
1786 if (loopcount++ > looplimit)
1789 warning (_("Remote fetch threadlist -infinite loop-."));
1792 if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
1793 &done, &result_count, resultthreadlist))
1798 /* Clear for later iterations. */
1800 /* Setup to resume next batch of thread references, set nextthread. */
1801 if (result_count >= 1)
1802 copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
1804 while (result_count--)
1805 if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
1812 remote_newthread_step (threadref *ref, void *context)
1816 ptid = pid_to_ptid (threadref_to_int (ref));
1818 if (!in_thread_list (ptid))
1820 return 1; /* continue iterator */
1823 #define CRAZY_MAX_THREADS 1000
1826 remote_current_thread (ptid_t oldpid)
1828 struct remote_state *rs = get_remote_state ();
1831 getpkt (&rs->buf, &rs->buf_size, 0);
1832 if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
1833 /* Use strtoul here, so we'll correctly parse values whose highest
1834 bit is set. The protocol carries them as a simple series of
1835 hex digits; in the absence of a sign, strtol will see such
1836 values as positive numbers out of range for signed 'long', and
1837 return LONG_MAX to indicate an overflow. */
1838 return pid_to_ptid (strtoul (&rs->buf[2], NULL, 16));
1843 /* Find new threads for info threads command.
1844 * Original version, using John Metzler's thread protocol.
1848 remote_find_new_threads (void)
1850 remote_threadlist_iterator (remote_newthread_step, 0,
1852 if (PIDGET (inferior_ptid) == MAGIC_NULL_PID) /* ack ack ack */
1853 inferior_ptid = remote_current_thread (inferior_ptid);
1857 * Find all threads for info threads command.
1858 * Uses new thread protocol contributed by Cisco.
1859 * Falls back and attempts to use the older method (above)
1860 * if the target doesn't respond to the new method.
1864 remote_threads_info (void)
1866 struct remote_state *rs = get_remote_state ();
1870 if (remote_desc == 0) /* paranoia */
1871 error (_("Command can only be used when connected to the remote target."));
1873 if (use_threadinfo_query)
1875 putpkt ("qfThreadInfo");
1876 getpkt (&rs->buf, &rs->buf_size, 0);
1878 if (bufp[0] != '\0') /* q packet recognized */
1880 while (*bufp++ == 'm') /* reply contains one or more TID */
1884 /* Use strtoul here, so we'll correctly parse values
1885 whose highest bit is set. The protocol carries
1886 them as a simple series of hex digits; in the
1887 absence of a sign, strtol will see such values as
1888 positive numbers out of range for signed 'long',
1889 and return LONG_MAX to indicate an overflow. */
1890 tid = strtoul (bufp, &bufp, 16);
1891 if (tid != 0 && !in_thread_list (pid_to_ptid (tid)))
1892 add_thread (pid_to_ptid (tid));
1894 while (*bufp++ == ','); /* comma-separated list */
1895 putpkt ("qsThreadInfo");
1896 getpkt (&rs->buf, &rs->buf_size, 0);
1903 /* Else fall back to old method based on jmetzler protocol. */
1904 use_threadinfo_query = 0;
1905 remote_find_new_threads ();
1910 * Collect a descriptive string about the given thread.
1911 * The target may say anything it wants to about the thread
1912 * (typically info about its blocked / runnable state, name, etc.).
1913 * This string will appear in the info threads display.
1915 * Optional: targets are not required to implement this function.
1919 remote_threads_extra_info (struct thread_info *tp)
1921 struct remote_state *rs = get_remote_state ();
1925 struct gdb_ext_thread_info threadinfo;
1926 static char display_buf[100]; /* arbitrary... */
1927 int n = 0; /* position in display_buf */
1929 if (remote_desc == 0) /* paranoia */
1930 internal_error (__FILE__, __LINE__,
1931 _("remote_threads_extra_info"));
1933 if (use_threadextra_query)
1935 xsnprintf (rs->buf, get_remote_packet_size (), "qThreadExtraInfo,%x",
1938 getpkt (&rs->buf, &rs->buf_size, 0);
1939 if (rs->buf[0] != 0)
1941 n = min (strlen (rs->buf) / 2, sizeof (display_buf));
1942 result = hex2bin (rs->buf, (gdb_byte *) display_buf, n);
1943 display_buf [result] = '\0';
1948 /* If the above query fails, fall back to the old method. */
1949 use_threadextra_query = 0;
1950 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
1951 | TAG_MOREDISPLAY | TAG_DISPLAY;
1952 int_to_threadref (&id, PIDGET (tp->ptid));
1953 if (remote_get_threadinfo (&id, set, &threadinfo))
1954 if (threadinfo.active)
1956 if (*threadinfo.shortname)
1957 n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
1958 " Name: %s,", threadinfo.shortname);
1959 if (*threadinfo.display)
1960 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
1961 " State: %s,", threadinfo.display);
1962 if (*threadinfo.more_display)
1963 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
1964 " Priority: %s", threadinfo.more_display);
1968 /* For purely cosmetic reasons, clear up trailing commas. */
1969 if (',' == display_buf[n-1])
1970 display_buf[n-1] = ' ';
1978 /* Restart the remote side; this is an extended protocol operation. */
1981 extended_remote_restart (void)
1983 struct remote_state *rs = get_remote_state ();
1985 /* Send the restart command; for reasons I don't understand the
1986 remote side really expects a number after the "R". */
1987 xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
1990 remote_fileio_reset ();
1992 /* Now query for status so this looks just like we restarted
1993 gdbserver from scratch. */
1995 getpkt (&rs->buf, &rs->buf_size, 0);
1998 /* Clean up connection to a remote debugger. */
2001 remote_close (int quitting)
2004 serial_close (remote_desc);
2008 /* Query the remote side for the text, data and bss offsets. */
2013 struct remote_state *rs = get_remote_state ();
2016 int lose, num_segments = 0, do_sections, do_segments;
2017 CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
2018 struct section_offsets *offs;
2019 struct symfile_segment_data *data;
2021 if (symfile_objfile == NULL)
2024 putpkt ("qOffsets");
2025 getpkt (&rs->buf, &rs->buf_size, 0);
2028 if (buf[0] == '\000')
2029 return; /* Return silently. Stub doesn't support
2033 warning (_("Remote failure reply: %s"), buf);
2037 /* Pick up each field in turn. This used to be done with scanf, but
2038 scanf will make trouble if CORE_ADDR size doesn't match
2039 conversion directives correctly. The following code will work
2040 with any size of CORE_ADDR. */
2041 text_addr = data_addr = bss_addr = 0;
2045 if (strncmp (ptr, "Text=", 5) == 0)
2048 /* Don't use strtol, could lose on big values. */
2049 while (*ptr && *ptr != ';')
2050 text_addr = (text_addr << 4) + fromhex (*ptr++);
2052 if (strncmp (ptr, ";Data=", 6) == 0)
2055 while (*ptr && *ptr != ';')
2056 data_addr = (data_addr << 4) + fromhex (*ptr++);
2061 if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
2064 while (*ptr && *ptr != ';')
2065 bss_addr = (bss_addr << 4) + fromhex (*ptr++);
2067 if (bss_addr != data_addr)
2068 warning (_("Target reported unsupported offsets: %s"), buf);
2073 else if (strncmp (ptr, "TextSeg=", 8) == 0)
2076 /* Don't use strtol, could lose on big values. */
2077 while (*ptr && *ptr != ';')
2078 text_addr = (text_addr << 4) + fromhex (*ptr++);
2081 if (strncmp (ptr, ";DataSeg=", 9) == 0)
2084 while (*ptr && *ptr != ';')
2085 data_addr = (data_addr << 4) + fromhex (*ptr++);
2093 error (_("Malformed response to offset query, %s"), buf);
2094 else if (*ptr != '\0')
2095 warning (_("Target reported unsupported offsets: %s"), buf);
2097 offs = ((struct section_offsets *)
2098 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
2099 memcpy (offs, symfile_objfile->section_offsets,
2100 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
2102 data = get_symfile_segment_data (symfile_objfile->obfd);
2103 do_segments = (data != NULL);
2104 do_sections = num_segments == 0;
2106 if (num_segments > 0)
2108 segments[0] = text_addr;
2109 segments[1] = data_addr;
2111 /* If we have two segments, we can still try to relocate everything
2112 by assuming that the .text and .data offsets apply to the whole
2113 text and data segments. Convert the offsets given in the packet
2114 to base addresses for symfile_map_offsets_to_segments. */
2115 else if (data && data->num_segments == 2)
2117 segments[0] = data->segment_bases[0] + text_addr;
2118 segments[1] = data->segment_bases[1] + data_addr;
2121 /* There's no way to relocate by segment. */
2127 int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
2128 offs, num_segments, segments);
2130 if (ret == 0 && !do_sections)
2131 error (_("Can not handle qOffsets TextSeg response with this symbol file"));
2137 free_symfile_segment_data (data);
2141 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
2143 /* This is a temporary kludge to force data and bss to use the same offsets
2144 because that's what nlmconv does now. The real solution requires changes
2145 to the stub and remote.c that I don't have time to do right now. */
2147 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
2148 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
2151 objfile_relocate (symfile_objfile, offs);
2154 /* Stub for catch_exception. */
2157 remote_start_remote (struct ui_out *uiout, void *from_tty_p)
2159 int from_tty = * (int *) from_tty_p;
2161 immediate_quit++; /* Allow user to interrupt it. */
2163 /* Ack any packet which the remote side has already sent. */
2164 serial_write (remote_desc, "+", 1);
2166 /* Let the stub know that we want it to return the thread. */
2169 inferior_ptid = remote_current_thread (inferior_ptid);
2171 get_offsets (); /* Get text, data & bss offsets. */
2173 putpkt ("?"); /* Initiate a query from remote machine. */
2176 start_remote (from_tty); /* Initialize gdb process mechanisms. */
2179 /* Open a connection to a remote debugger.
2180 NAME is the filename used for communication. */
2183 remote_open (char *name, int from_tty)
2185 remote_open_1 (name, from_tty, &remote_ops, 0, 0);
2188 /* Just like remote_open, but with asynchronous support. */
2190 remote_async_open (char *name, int from_tty)
2192 remote_open_1 (name, from_tty, &remote_async_ops, 0, 1);
2195 /* Open a connection to a remote debugger using the extended
2196 remote gdb protocol. NAME is the filename used for communication. */
2199 extended_remote_open (char *name, int from_tty)
2201 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */,
2205 /* Just like extended_remote_open, but with asynchronous support. */
2207 extended_remote_async_open (char *name, int from_tty)
2209 remote_open_1 (name, from_tty, &extended_async_remote_ops,
2210 1 /*extended_p */, 1 /* async_p */);
2213 /* Generic code for opening a connection to a remote target. */
2216 init_all_packet_configs (void)
2219 for (i = 0; i < PACKET_MAX; i++)
2220 update_packet_config (&remote_protocol_packets[i]);
2223 /* Symbol look-up. */
2226 remote_check_symbols (struct objfile *objfile)
2228 struct remote_state *rs = get_remote_state ();
2229 char *msg, *reply, *tmp;
2230 struct minimal_symbol *sym;
2233 if (remote_protocol_packets[PACKET_qSymbol].support == PACKET_DISABLE)
2236 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2237 because we need both at the same time. */
2238 msg = alloca (get_remote_packet_size ());
2240 /* Invite target to request symbol lookups. */
2242 putpkt ("qSymbol::");
2243 getpkt (&rs->buf, &rs->buf_size, 0);
2244 packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
2247 while (strncmp (reply, "qSymbol:", 8) == 0)
2250 end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
2252 sym = lookup_minimal_symbol (msg, NULL, NULL);
2254 xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
2257 CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym);
2259 /* If this is a function address, return the start of code
2260 instead of any data function descriptor. */
2261 sym_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
2265 xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
2266 paddr_nz (sym_addr), &reply[8]);
2270 getpkt (&rs->buf, &rs->buf_size, 0);
2275 static struct serial *
2276 remote_serial_open (char *name)
2278 static int udp_warning = 0;
2280 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2281 of in ser-tcp.c, because it is the remote protocol assuming that the
2282 serial connection is reliable and not the serial connection promising
2284 if (!udp_warning && strncmp (name, "udp:", 4) == 0)
2287 The remote protocol may be unreliable over UDP.\n\
2288 Some events may be lost, rendering further debugging impossible."));
2292 return serial_open (name);
2295 /* This type describes each known response to the qSupported
2297 struct protocol_feature
2299 /* The name of this protocol feature. */
2302 /* The default for this protocol feature. */
2303 enum packet_support default_support;
2305 /* The function to call when this feature is reported, or after
2306 qSupported processing if the feature is not supported.
2307 The first argument points to this structure. The second
2308 argument indicates whether the packet requested support be
2309 enabled, disabled, or probed (or the default, if this function
2310 is being called at the end of processing and this feature was
2311 not reported). The third argument may be NULL; if not NULL, it
2312 is a NUL-terminated string taken from the packet following
2313 this feature's name and an equals sign. */
2314 void (*func) (const struct protocol_feature *, enum packet_support,
2317 /* The corresponding packet for this feature. Only used if
2318 FUNC is remote_supported_packet. */
2323 remote_supported_packet (const struct protocol_feature *feature,
2324 enum packet_support support,
2325 const char *argument)
2329 warning (_("Remote qSupported response supplied an unexpected value for"
2330 " \"%s\"."), feature->name);
2334 if (remote_protocol_packets[feature->packet].support
2335 == PACKET_SUPPORT_UNKNOWN)
2336 remote_protocol_packets[feature->packet].support = support;
2340 remote_packet_size (const struct protocol_feature *feature,
2341 enum packet_support support, const char *value)
2343 struct remote_state *rs = get_remote_state ();
2348 if (support != PACKET_ENABLE)
2351 if (value == NULL || *value == '\0')
2353 warning (_("Remote target reported \"%s\" without a size."),
2359 packet_size = strtol (value, &value_end, 16);
2360 if (errno != 0 || *value_end != '\0' || packet_size < 0)
2362 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2363 feature->name, value);
2367 if (packet_size > MAX_REMOTE_PACKET_SIZE)
2369 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2370 packet_size, MAX_REMOTE_PACKET_SIZE);
2371 packet_size = MAX_REMOTE_PACKET_SIZE;
2374 /* Record the new maximum packet size. */
2375 rs->explicit_packet_size = packet_size;
2378 static struct protocol_feature remote_protocol_features[] = {
2379 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
2380 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
2381 PACKET_qXfer_auxv },
2382 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
2383 PACKET_qXfer_features },
2384 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
2385 PACKET_qXfer_libraries },
2386 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
2387 PACKET_qXfer_memory_map },
2388 { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
2389 PACKET_qXfer_spu_read },
2390 { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
2391 PACKET_qXfer_spu_write },
2392 { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
2393 PACKET_QPassSignals },
2397 remote_query_supported (void)
2399 struct remote_state *rs = get_remote_state ();
2402 unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
2404 /* The packet support flags are handled differently for this packet
2405 than for most others. We treat an error, a disabled packet, and
2406 an empty response identically: any features which must be reported
2407 to be used will be automatically disabled. An empty buffer
2408 accomplishes this, since that is also the representation for a list
2409 containing no features. */
2412 if (remote_protocol_packets[PACKET_qSupported].support != PACKET_DISABLE)
2414 putpkt ("qSupported");
2415 getpkt (&rs->buf, &rs->buf_size, 0);
2417 /* If an error occured, warn, but do not return - just reset the
2418 buffer to empty and go on to disable features. */
2419 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
2422 warning (_("Remote failure reply: %s"), rs->buf);
2427 memset (seen, 0, sizeof (seen));
2432 enum packet_support is_supported;
2433 char *p, *end, *name_end, *value;
2435 /* First separate out this item from the rest of the packet. If
2436 there's another item after this, we overwrite the separator
2437 (terminated strings are much easier to work with). */
2439 end = strchr (p, ';');
2442 end = p + strlen (p);
2452 warning (_("empty item in \"qSupported\" response"));
2457 name_end = strchr (p, '=');
2460 /* This is a name=value entry. */
2461 is_supported = PACKET_ENABLE;
2462 value = name_end + 1;
2471 is_supported = PACKET_ENABLE;
2475 is_supported = PACKET_DISABLE;
2479 is_supported = PACKET_SUPPORT_UNKNOWN;
2483 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p);
2489 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
2490 if (strcmp (remote_protocol_features[i].name, p) == 0)
2492 const struct protocol_feature *feature;
2495 feature = &remote_protocol_features[i];
2496 feature->func (feature, is_supported, value);
2501 /* If we increased the packet size, make sure to increase the global
2502 buffer size also. We delay this until after parsing the entire
2503 qSupported packet, because this is the same buffer we were
2505 if (rs->buf_size < rs->explicit_packet_size)
2507 rs->buf_size = rs->explicit_packet_size;
2508 rs->buf = xrealloc (rs->buf, rs->buf_size);
2511 /* Handle the defaults for unmentioned features. */
2512 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
2515 const struct protocol_feature *feature;
2517 feature = &remote_protocol_features[i];
2518 feature->func (feature, feature->default_support, NULL);
2524 remote_open_1 (char *name, int from_tty, struct target_ops *target,
2525 int extended_p, int async_p)
2527 struct remote_state *rs = get_remote_state ();
2529 error (_("To open a remote debug connection, you need to specify what\n"
2530 "serial device is attached to the remote system\n"
2531 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2533 /* See FIXME above. */
2535 wait_forever_enabled_p = 1;
2537 target_preopen (from_tty);
2539 unpush_target (target);
2541 /* Make sure we send the passed signals list the next time we resume. */
2542 xfree (last_pass_packet);
2543 last_pass_packet = NULL;
2545 remote_fileio_reset ();
2546 reopen_exec_file ();
2549 remote_desc = remote_serial_open (name);
2551 perror_with_name (name);
2553 if (baud_rate != -1)
2555 if (serial_setbaudrate (remote_desc, baud_rate))
2557 /* The requested speed could not be set. Error out to
2558 top level after closing remote_desc. Take care to
2559 set remote_desc to NULL to avoid closing remote_desc
2561 serial_close (remote_desc);
2563 perror_with_name (name);
2567 serial_raw (remote_desc);
2569 /* If there is something sitting in the buffer we might take it as a
2570 response to a command, which would be bad. */
2571 serial_flush_input (remote_desc);
2575 puts_filtered ("Remote debugging using ");
2576 puts_filtered (name);
2577 puts_filtered ("\n");
2579 push_target (target); /* Switch to using remote target now. */
2581 /* Reset the target state; these things will be queried either by
2582 remote_query_supported or as they are needed. */
2583 init_all_packet_configs ();
2584 rs->explicit_packet_size = 0;
2586 general_thread = -2;
2587 continue_thread = -2;
2589 /* Probe for ability to use "ThreadInfo" query, as required. */
2590 use_threadinfo_query = 1;
2591 use_threadextra_query = 1;
2593 /* The first packet we send to the target is the optional "supported
2594 packets" request. If the target can answer this, it will tell us
2595 which later probes to skip. */
2596 remote_query_supported ();
2598 /* Next, if the target can specify a description, read it. We do
2599 this before anything involving memory or registers. */
2600 target_find_description ();
2602 /* Without this, some commands which require an active target (such
2603 as kill) won't work. This variable serves (at least) double duty
2604 as both the pid of the target process (if it has such), and as a
2605 flag indicating that a target is active. These functions should
2606 be split out into seperate variables, especially since GDB will
2607 someday have a notion of debugging several processes. */
2609 inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
2613 /* With this target we start out by owning the terminal. */
2614 remote_async_terminal_ours_p = 1;
2616 /* FIXME: cagney/1999-09-23: During the initial connection it is
2617 assumed that the target is already ready and able to respond to
2618 requests. Unfortunately remote_start_remote() eventually calls
2619 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2620 around this. Eventually a mechanism that allows
2621 wait_for_inferior() to expect/get timeouts will be
2623 wait_forever_enabled_p = 0;
2626 /* First delete any symbols previously loaded from shared libraries. */
2627 no_shared_libraries (NULL, 0);
2629 /* Start the remote connection. If error() or QUIT, discard this
2630 target (we'd otherwise be in an inconsistent state) and then
2631 propogate the error on up the exception chain. This ensures that
2632 the caller doesn't stumble along blindly assuming that the
2633 function succeeded. The CLI doesn't have this problem but other
2634 UI's, such as MI do.
2636 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2637 this function should return an error indication letting the
2638 caller restore the previous state. Unfortunately the command
2639 ``target remote'' is directly wired to this function making that
2640 impossible. On a positive note, the CLI side of this problem has
2641 been fixed - the function set_cmd_context() makes it possible for
2642 all the ``target ....'' commands to share a common callback
2643 function. See cli-dump.c. */
2645 struct gdb_exception ex
2646 = catch_exception (uiout, remote_start_remote, &from_tty,
2652 wait_forever_enabled_p = 1;
2653 throw_exception (ex);
2658 wait_forever_enabled_p = 1;
2662 /* Tell the remote that we are using the extended protocol. */
2664 getpkt (&rs->buf, &rs->buf_size, 0);
2667 if (exec_bfd) /* No use without an exec file. */
2668 remote_check_symbols (symfile_objfile);
2671 /* This takes a program previously attached to and detaches it. After
2672 this is done, GDB can be used to debug some other program. We
2673 better not have left any breakpoints in the target program or it'll
2674 die when it hits one. */
2677 remote_detach (char *args, int from_tty)
2679 struct remote_state *rs = get_remote_state ();
2682 error (_("Argument given to \"detach\" when remotely debugging."));
2684 /* Tell the remote target to detach. */
2685 strcpy (rs->buf, "D");
2687 getpkt (&rs->buf, &rs->buf_size, 0);
2689 if (rs->buf[0] == 'E')
2690 error (_("Can't detach process."));
2692 /* Unregister the file descriptor from the event loop. */
2693 if (target_is_async_p ())
2694 serial_async (remote_desc, NULL, 0);
2696 target_mourn_inferior ();
2698 puts_filtered ("Ending remote debugging.\n");
2701 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2704 remote_disconnect (struct target_ops *target, char *args, int from_tty)
2707 error (_("Argument given to \"detach\" when remotely debugging."));
2709 /* Unregister the file descriptor from the event loop. */
2710 if (target_is_async_p ())
2711 serial_async (remote_desc, NULL, 0);
2713 target_mourn_inferior ();
2715 puts_filtered ("Ending remote debugging.\n");
2718 /* Convert hex digit A to a number. */
2723 if (a >= '0' && a <= '9')
2725 else if (a >= 'a' && a <= 'f')
2726 return a - 'a' + 10;
2727 else if (a >= 'A' && a <= 'F')
2728 return a - 'A' + 10;
2730 error (_("Reply contains invalid hex digit %d"), a);
2734 hex2bin (const char *hex, gdb_byte *bin, int count)
2738 for (i = 0; i < count; i++)
2740 if (hex[0] == 0 || hex[1] == 0)
2742 /* Hex string is short, or of uneven length.
2743 Return the count that has been converted so far. */
2746 *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
2752 /* Convert number NIB to a hex digit. */
2760 return 'a' + nib - 10;
2764 bin2hex (const gdb_byte *bin, char *hex, int count)
2767 /* May use a length, or a nul-terminated string as input. */
2769 count = strlen ((char *) bin);
2771 for (i = 0; i < count; i++)
2773 *hex++ = tohex ((*bin >> 4) & 0xf);
2774 *hex++ = tohex (*bin++ & 0xf);
2780 /* Check for the availability of vCont. This function should also check
2784 remote_vcont_probe (struct remote_state *rs)
2788 strcpy (rs->buf, "vCont?");
2790 getpkt (&rs->buf, &rs->buf_size, 0);
2793 /* Make sure that the features we assume are supported. */
2794 if (strncmp (buf, "vCont", 5) == 0)
2797 int support_s, support_S, support_c, support_C;
2803 while (p && *p == ';')
2806 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
2808 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
2810 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
2812 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
2815 p = strchr (p, ';');
2818 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2819 BUF will make packet_ok disable the packet. */
2820 if (!support_s || !support_S || !support_c || !support_C)
2824 packet_ok (buf, &remote_protocol_packets[PACKET_vCont]);
2827 /* Resume the remote inferior by using a "vCont" packet. The thread
2828 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2829 resumed thread should be single-stepped and/or signalled. If PTID's
2830 PID is -1, then all threads are resumed; the thread to be stepped and/or
2831 signalled is given in the global INFERIOR_PTID. This function returns
2832 non-zero iff it resumes the inferior.
2834 This function issues a strict subset of all possible vCont commands at the
2838 remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal)
2840 struct remote_state *rs = get_remote_state ();
2841 int pid = PIDGET (ptid);
2842 char *buf = NULL, *outbuf;
2843 struct cleanup *old_cleanup;
2845 if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
2846 remote_vcont_probe (rs);
2848 if (remote_protocol_packets[PACKET_vCont].support == PACKET_DISABLE)
2851 /* If we could generate a wider range of packets, we'd have to worry
2852 about overflowing BUF. Should there be a generic
2853 "multi-part-packet" packet? */
2855 if (PIDGET (inferior_ptid) == MAGIC_NULL_PID)
2857 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2858 don't have any PID numbers the inferior will understand. Make sure
2859 to only send forms that do not specify a PID. */
2860 if (step && siggnal != TARGET_SIGNAL_0)
2861 outbuf = xstrprintf ("vCont;S%02x", siggnal);
2863 outbuf = xstrprintf ("vCont;s");
2864 else if (siggnal != TARGET_SIGNAL_0)
2865 outbuf = xstrprintf ("vCont;C%02x", siggnal);
2867 outbuf = xstrprintf ("vCont;c");
2871 /* Resume all threads, with preference for INFERIOR_PTID. */
2872 if (step && siggnal != TARGET_SIGNAL_0)
2873 outbuf = xstrprintf ("vCont;S%02x:%x;c", siggnal,
2874 PIDGET (inferior_ptid));
2876 outbuf = xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid));
2877 else if (siggnal != TARGET_SIGNAL_0)
2878 outbuf = xstrprintf ("vCont;C%02x:%x;c", siggnal,
2879 PIDGET (inferior_ptid));
2881 outbuf = xstrprintf ("vCont;c");
2885 /* Scheduler locking; resume only PTID. */
2886 if (step && siggnal != TARGET_SIGNAL_0)
2887 outbuf = xstrprintf ("vCont;S%02x:%x", siggnal, pid);
2889 outbuf = xstrprintf ("vCont;s:%x", pid);
2890 else if (siggnal != TARGET_SIGNAL_0)
2891 outbuf = xstrprintf ("vCont;C%02x:%x", siggnal, pid);
2893 outbuf = xstrprintf ("vCont;c:%x", pid);
2896 gdb_assert (outbuf && strlen (outbuf) < get_remote_packet_size ());
2897 old_cleanup = make_cleanup (xfree, outbuf);
2901 do_cleanups (old_cleanup);
2906 /* Tell the remote machine to resume. */
2908 static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
2910 static int last_sent_step;
2913 remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
2915 struct remote_state *rs = get_remote_state ();
2917 int pid = PIDGET (ptid);
2919 last_sent_signal = siggnal;
2920 last_sent_step = step;
2922 /* A hook for when we need to do something at the last moment before
2924 if (deprecated_target_resume_hook)
2925 (*deprecated_target_resume_hook) ();
2927 /* Update the inferior on signals to silently pass, if they've changed. */
2928 remote_pass_signals ();
2930 /* The vCont packet doesn't need to specify threads via Hc. */
2931 if (remote_vcont_resume (ptid, step, siggnal))
2934 /* All other supported resume packets do use Hc, so call set_thread. */
2936 set_thread (0, 0); /* Run any thread. */
2938 set_thread (pid, 0); /* Run this thread. */
2941 if (siggnal != TARGET_SIGNAL_0)
2943 buf[0] = step ? 'S' : 'C';
2944 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
2945 buf[2] = tohex (((int) siggnal) & 0xf);
2949 strcpy (buf, step ? "s" : "c");
2954 /* Same as remote_resume, but with async support. */
2956 remote_async_resume (ptid_t ptid, int step, enum target_signal siggnal)
2958 remote_resume (ptid, step, siggnal);
2960 /* We are about to start executing the inferior, let's register it
2961 with the event loop. NOTE: this is the one place where all the
2962 execution commands end up. We could alternatively do this in each
2963 of the execution commands in infcmd.c. */
2964 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2965 into infcmd.c in order to allow inferior function calls to work
2966 NOT asynchronously. */
2967 if (target_can_async_p ())
2968 target_async (inferior_event_handler, 0);
2969 /* Tell the world that the target is now executing. */
2970 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2971 this? Instead, should the client of target just assume (for
2972 async targets) that the target is going to start executing? Is
2973 this information already found in the continuation block? */
2974 if (target_is_async_p ())
2975 target_executing = 1;
2979 /* Set up the signal handler for SIGINT, while the target is
2980 executing, ovewriting the 'regular' SIGINT signal handler. */
2982 initialize_sigint_signal_handler (void)
2984 sigint_remote_token =
2985 create_async_signal_handler (async_remote_interrupt, NULL);
2986 signal (SIGINT, handle_remote_sigint);
2989 /* Signal handler for SIGINT, while the target is executing. */
2991 handle_remote_sigint (int sig)
2993 signal (sig, handle_remote_sigint_twice);
2994 sigint_remote_twice_token =
2995 create_async_signal_handler (async_remote_interrupt_twice, NULL);
2996 mark_async_signal_handler_wrapper (sigint_remote_token);
2999 /* Signal handler for SIGINT, installed after SIGINT has already been
3000 sent once. It will take effect the second time that the user sends
3003 handle_remote_sigint_twice (int sig)
3005 signal (sig, handle_sigint);
3006 sigint_remote_twice_token =
3007 create_async_signal_handler (inferior_event_handler_wrapper, NULL);
3008 mark_async_signal_handler_wrapper (sigint_remote_twice_token);
3011 /* Perform the real interruption of the target execution, in response
3014 async_remote_interrupt (gdb_client_data arg)
3017 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
3022 /* Perform interrupt, if the first attempt did not succeed. Just give
3023 up on the target alltogether. */
3025 async_remote_interrupt_twice (gdb_client_data arg)
3028 fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
3029 /* Do something only if the target was not killed by the previous
3031 if (target_executing)
3034 signal (SIGINT, handle_remote_sigint);
3038 /* Reinstall the usual SIGINT handlers, after the target has
3041 cleanup_sigint_signal_handler (void *dummy)
3043 signal (SIGINT, handle_sigint);
3044 if (sigint_remote_twice_token)
3045 delete_async_signal_handler (&sigint_remote_twice_token);
3046 if (sigint_remote_token)
3047 delete_async_signal_handler (&sigint_remote_token);
3050 /* Send ^C to target to halt it. Target will respond, and send us a
3052 static void (*ofunc) (int);
3054 /* The command line interface's stop routine. This function is installed
3055 as a signal handler for SIGINT. The first time a user requests a
3056 stop, we call remote_stop to send a break or ^C. If there is no
3057 response from the target (it didn't stop when the user requested it),
3058 we ask the user if he'd like to detach from the target. */
3060 remote_interrupt (int signo)
3062 /* If this doesn't work, try more severe steps. */
3063 signal (signo, remote_interrupt_twice);
3066 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
3071 /* The user typed ^C twice. */
3074 remote_interrupt_twice (int signo)
3076 signal (signo, ofunc);
3078 signal (signo, remote_interrupt);
3081 /* This is the generic stop called via the target vector. When a target
3082 interrupt is requested, either by the command line or the GUI, we
3083 will eventually end up here. */
3087 /* Send a break or a ^C, depending on user preference. */
3089 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
3092 serial_send_break (remote_desc);
3094 serial_write (remote_desc, "\003", 1);
3097 /* Ask the user what to do when an interrupt is received. */
3100 interrupt_query (void)
3102 target_terminal_ours ();
3104 if (query ("Interrupted while waiting for the program.\n\
3105 Give up (and stop debugging it)? "))
3107 target_mourn_inferior ();
3108 deprecated_throw_reason (RETURN_QUIT);
3111 target_terminal_inferior ();
3114 /* Enable/disable target terminal ownership. Most targets can use
3115 terminal groups to control terminal ownership. Remote targets are
3116 different in that explicit transfer of ownership to/from GDB/target
3120 remote_async_terminal_inferior (void)
3122 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3123 sync_execution here. This function should only be called when
3124 GDB is resuming the inferior in the forground. A background
3125 resume (``run&'') should leave GDB in control of the terminal and
3126 consequently should not call this code. */
3127 if (!sync_execution)
3129 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3130 calls target_terminal_*() idenpotent. The event-loop GDB talking
3131 to an asynchronous target with a synchronous command calls this
3132 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3133 stops trying to transfer the terminal to the target when it
3134 shouldn't this guard can go away. */
3135 if (!remote_async_terminal_ours_p)
3137 delete_file_handler (input_fd);
3138 remote_async_terminal_ours_p = 0;
3139 initialize_sigint_signal_handler ();
3140 /* NOTE: At this point we could also register our selves as the
3141 recipient of all input. Any characters typed could then be
3142 passed on down to the target. */
3146 remote_async_terminal_ours (void)
3148 /* See FIXME in remote_async_terminal_inferior. */
3149 if (!sync_execution)
3151 /* See FIXME in remote_async_terminal_inferior. */
3152 if (remote_async_terminal_ours_p)
3154 cleanup_sigint_signal_handler (NULL);
3155 add_file_handler (input_fd, stdin_event_handler, 0);
3156 remote_async_terminal_ours_p = 1;
3159 /* If nonzero, ignore the next kill. */
3164 remote_console_output (char *msg)
3168 for (p = msg; p[0] && p[1]; p += 2)
3171 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
3174 fputs_unfiltered (tb, gdb_stdtarg);
3176 gdb_flush (gdb_stdtarg);
3179 /* Wait until the remote machine stops, then return,
3180 storing status in STATUS just as `wait' would.
3181 Returns "pid", which in the case of a multi-threaded
3182 remote OS, is the thread-id. */
3185 remote_wait (ptid_t ptid, struct target_waitstatus *status)
3187 struct remote_state *rs = get_remote_state ();
3188 struct remote_arch_state *rsa = get_remote_arch_state ();
3189 ULONGEST thread_num = -1;
3191 int solibs_changed = 0;
3193 status->kind = TARGET_WAITKIND_EXITED;
3194 status->value.integer = 0;
3200 ofunc = signal (SIGINT, remote_interrupt);
3201 getpkt (&rs->buf, &rs->buf_size, 1);
3202 signal (SIGINT, ofunc);
3206 /* This is a hook for when we need to do something (perhaps the
3207 collection of trace data) every time the target stops. */
3208 if (deprecated_target_wait_loop_hook)
3209 (*deprecated_target_wait_loop_hook) ();
3211 remote_stopped_by_watchpoint_p = 0;
3215 case 'E': /* Error of some sort. */
3216 warning (_("Remote failure reply: %s"), buf);
3218 case 'F': /* File-I/O request. */
3219 remote_fileio_request (buf);
3221 case 'T': /* Status with PC, SP, FP, ... */
3223 gdb_byte regs[MAX_REGISTER_SIZE];
3225 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3226 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3228 n... = register number
3229 r... = register contents
3231 p = &buf[3]; /* after Txx */
3240 /* If the packet contains a register number save it in
3241 pnum and set p1 to point to the character following
3242 it. Otherwise p1 points to p. */
3244 /* If this packet is an awatch packet, don't parse the
3245 'a' as a register number. */
3247 if (strncmp (p, "awatch", strlen("awatch")) != 0)
3249 /* Read the ``P'' register number. */
3250 pnum = strtol (p, &p_temp, 16);
3256 if (p1 == p) /* No register number present here. */
3258 p1 = strchr (p, ':');
3260 error (_("Malformed packet(a) (missing colon): %s\n\
3263 if (strncmp (p, "thread", p1 - p) == 0)
3265 p_temp = unpack_varlen_hex (++p1, &thread_num);
3266 record_currthread (thread_num);
3269 else if ((strncmp (p, "watch", p1 - p) == 0)
3270 || (strncmp (p, "rwatch", p1 - p) == 0)
3271 || (strncmp (p, "awatch", p1 - p) == 0))
3273 remote_stopped_by_watchpoint_p = 1;
3274 p = unpack_varlen_hex (++p1, &addr);
3275 remote_watch_data_address = (CORE_ADDR)addr;
3277 else if (strncmp (p, "library", p1 - p) == 0)
3281 while (*p_temp && *p_temp != ';')
3289 /* Silently skip unknown optional info. */
3290 p_temp = strchr (p1 + 1, ';');
3297 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
3301 error (_("Malformed packet(b) (missing colon): %s\n\
3306 error (_("Remote sent bad register number %s: %s\n\
3308 phex_nz (pnum, 0), p, buf);
3310 fieldsize = hex2bin (p, regs,
3311 register_size (current_gdbarch,
3314 if (fieldsize < register_size (current_gdbarch,
3316 warning (_("Remote reply is too short: %s"), buf);
3317 regcache_raw_supply (get_current_regcache (),
3322 error (_("Remote register badly formatted: %s\nhere: %s"),
3327 case 'S': /* Old style status, just signal only. */
3329 status->kind = TARGET_WAITKIND_LOADED;
3332 status->kind = TARGET_WAITKIND_STOPPED;
3333 status->value.sig = (enum target_signal)
3334 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3339 thread_num = strtol ((const char *) &buf[4], NULL, 16);
3340 record_currthread (thread_num);
3343 case 'W': /* Target exited. */
3345 /* The remote process exited. */
3346 status->kind = TARGET_WAITKIND_EXITED;
3347 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3351 status->kind = TARGET_WAITKIND_SIGNALLED;
3352 status->value.sig = (enum target_signal)
3353 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3357 case 'O': /* Console output. */
3358 remote_console_output (buf + 1);
3361 if (last_sent_signal != TARGET_SIGNAL_0)
3363 /* Zero length reply means that we tried 'S' or 'C' and
3364 the remote system doesn't support it. */
3365 target_terminal_ours_for_output ();
3367 ("Can't send signals to this remote system. %s not sent.\n",
3368 target_signal_to_name (last_sent_signal));
3369 last_sent_signal = TARGET_SIGNAL_0;
3370 target_terminal_inferior ();
3372 strcpy ((char *) buf, last_sent_step ? "s" : "c");
3373 putpkt ((char *) buf);
3376 /* else fallthrough */
3378 warning (_("Invalid remote reply: %s"), buf);
3383 if (thread_num != -1)
3385 return pid_to_ptid (thread_num);
3387 return inferior_ptid;
3390 /* Async version of remote_wait. */
3392 remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
3394 struct remote_state *rs = get_remote_state ();
3395 struct remote_arch_state *rsa = get_remote_arch_state ();
3396 ULONGEST thread_num = -1;
3398 int solibs_changed = 0;
3400 status->kind = TARGET_WAITKIND_EXITED;
3401 status->value.integer = 0;
3403 remote_stopped_by_watchpoint_p = 0;
3409 if (!target_is_async_p ())
3410 ofunc = signal (SIGINT, remote_interrupt);
3411 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3412 _never_ wait for ever -> test on target_is_async_p().
3413 However, before we do that we need to ensure that the caller
3414 knows how to take the target into/out of async mode. */
3415 getpkt (&rs->buf, &rs->buf_size, wait_forever_enabled_p);
3416 if (!target_is_async_p ())
3417 signal (SIGINT, ofunc);
3421 /* This is a hook for when we need to do something (perhaps the
3422 collection of trace data) every time the target stops. */
3423 if (deprecated_target_wait_loop_hook)
3424 (*deprecated_target_wait_loop_hook) ();
3428 case 'E': /* Error of some sort. */
3429 warning (_("Remote failure reply: %s"), buf);
3431 case 'F': /* File-I/O request. */
3432 remote_fileio_request (buf);
3434 case 'T': /* Status with PC, SP, FP, ... */
3436 gdb_byte regs[MAX_REGISTER_SIZE];
3438 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3439 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3441 n... = register number
3442 r... = register contents
3444 p = &buf[3]; /* after Txx */
3453 /* If the packet contains a register number, save it
3454 in pnum and set p1 to point to the character
3455 following it. Otherwise p1 points to p. */
3457 /* If this packet is an awatch packet, don't parse the 'a'
3458 as a register number. */
3460 if (strncmp (p, "awatch", strlen("awatch")) != 0)
3462 /* Read the register number. */
3463 pnum = strtol (p, &p_temp, 16);
3469 if (p1 == p) /* No register number present here. */
3471 p1 = strchr (p, ':');
3473 error (_("Malformed packet(a) (missing colon): %s\n\
3476 if (strncmp (p, "thread", p1 - p) == 0)
3478 p_temp = unpack_varlen_hex (++p1, &thread_num);
3479 record_currthread (thread_num);
3482 else if ((strncmp (p, "watch", p1 - p) == 0)
3483 || (strncmp (p, "rwatch", p1 - p) == 0)
3484 || (strncmp (p, "awatch", p1 - p) == 0))
3486 remote_stopped_by_watchpoint_p = 1;
3487 p = unpack_varlen_hex (++p1, &addr);
3488 remote_watch_data_address = (CORE_ADDR)addr;
3490 else if (strncmp (p, "library", p1 - p) == 0)
3494 while (*p_temp && *p_temp != ';')
3502 /* Silently skip unknown optional info. */
3503 p_temp = strchr (p1 + 1, ';');
3511 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
3514 error (_("Malformed packet(b) (missing colon): %s\n\
3519 error (_("Remote sent bad register number %ld: %s\n\
3523 fieldsize = hex2bin (p, regs,
3524 register_size (current_gdbarch,
3527 if (fieldsize < register_size (current_gdbarch,
3529 warning (_("Remote reply is too short: %s"), buf);
3530 regcache_raw_supply (get_current_regcache (),
3535 error (_("Remote register badly formatted: %s\nhere: %s"),
3540 case 'S': /* Old style status, just signal only. */
3542 status->kind = TARGET_WAITKIND_LOADED;
3545 status->kind = TARGET_WAITKIND_STOPPED;
3546 status->value.sig = (enum target_signal)
3547 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3552 thread_num = strtol ((const char *) &buf[4], NULL, 16);
3553 record_currthread (thread_num);
3556 case 'W': /* Target exited. */
3558 /* The remote process exited. */
3559 status->kind = TARGET_WAITKIND_EXITED;
3560 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3564 status->kind = TARGET_WAITKIND_SIGNALLED;
3565 status->value.sig = (enum target_signal)
3566 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3570 case 'O': /* Console output. */
3571 remote_console_output (buf + 1);
3572 /* Return immediately to the event loop. The event loop will
3573 still be waiting on the inferior afterwards. */
3574 status->kind = TARGET_WAITKIND_IGNORE;
3577 if (last_sent_signal != TARGET_SIGNAL_0)
3579 /* Zero length reply means that we tried 'S' or 'C' and
3580 the remote system doesn't support it. */
3581 target_terminal_ours_for_output ();
3583 ("Can't send signals to this remote system. %s not sent.\n",
3584 target_signal_to_name (last_sent_signal));
3585 last_sent_signal = TARGET_SIGNAL_0;
3586 target_terminal_inferior ();
3588 strcpy ((char *) buf, last_sent_step ? "s" : "c");
3589 putpkt ((char *) buf);
3592 /* else fallthrough */
3594 warning (_("Invalid remote reply: %s"), buf);
3599 if (thread_num != -1)
3601 return pid_to_ptid (thread_num);
3603 return inferior_ptid;
3606 /* Fetch a single register using a 'p' packet. */
3609 fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
3611 struct remote_state *rs = get_remote_state ();
3613 char regp[MAX_REGISTER_SIZE];
3616 if (remote_protocol_packets[PACKET_p].support == PACKET_DISABLE)
3619 if (reg->pnum == -1)
3624 p += hexnumstr (p, reg->pnum);
3626 remote_send (&rs->buf, &rs->buf_size);
3630 switch (packet_ok (buf, &remote_protocol_packets[PACKET_p]))
3634 case PACKET_UNKNOWN:
3637 error (_("Could not fetch register \"%s\""),
3638 gdbarch_register_name (current_gdbarch, reg->regnum));
3641 /* If this register is unfetchable, tell the regcache. */
3644 regcache_raw_supply (regcache, reg->regnum, NULL);
3648 /* Otherwise, parse and supply the value. */
3654 error (_("fetch_register_using_p: early buf termination"));
3656 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
3659 regcache_raw_supply (regcache, reg->regnum, regp);
3663 /* Fetch the registers included in the target's 'g' packet. */
3666 send_g_packet (void)
3668 struct remote_state *rs = get_remote_state ();
3673 sprintf (rs->buf, "g");
3674 remote_send (&rs->buf, &rs->buf_size);
3676 /* We can get out of synch in various cases. If the first character
3677 in the buffer is not a hex character, assume that has happened
3678 and try to fetch another packet to read. */
3679 while ((rs->buf[0] < '0' || rs->buf[0] > '9')
3680 && (rs->buf[0] < 'A' || rs->buf[0] > 'F')
3681 && (rs->buf[0] < 'a' || rs->buf[0] > 'f')
3682 && rs->buf[0] != 'x') /* New: unavailable register value. */
3685 fprintf_unfiltered (gdb_stdlog,
3686 "Bad register packet; fetching a new packet\n");
3687 getpkt (&rs->buf, &rs->buf_size, 0);
3690 buf_len = strlen (rs->buf);
3692 /* Sanity check the received packet. */
3693 if (buf_len % 2 != 0)
3694 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf);
3700 process_g_packet (struct regcache *regcache)
3702 struct remote_state *rs = get_remote_state ();
3703 struct remote_arch_state *rsa = get_remote_arch_state ();
3708 buf_len = strlen (rs->buf);
3710 /* Further sanity checks, with knowledge of the architecture. */
3711 if (buf_len > 2 * rsa->sizeof_g_packet)
3712 error (_("Remote 'g' packet reply is too long: %s"), rs->buf);
3714 /* Save the size of the packet sent to us by the target. It is used
3715 as a heuristic when determining the max size of packets that the
3716 target can safely receive. */
3717 if (rsa->actual_register_packet_size == 0)
3718 rsa->actual_register_packet_size = buf_len;
3720 /* If this is smaller than we guessed the 'g' packet would be,
3721 update our records. A 'g' reply that doesn't include a register's
3722 value implies either that the register is not available, or that
3723 the 'p' packet must be used. */
3724 if (buf_len < 2 * rsa->sizeof_g_packet)
3726 rsa->sizeof_g_packet = buf_len / 2;
3728 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3730 if (rsa->regs[i].pnum == -1)
3733 if (rsa->regs[i].offset >= rsa->sizeof_g_packet)
3734 rsa->regs[i].in_g_packet = 0;
3736 rsa->regs[i].in_g_packet = 1;
3740 regs = alloca (rsa->sizeof_g_packet);
3742 /* Unimplemented registers read as all bits zero. */
3743 memset (regs, 0, rsa->sizeof_g_packet);
3745 /* Reply describes registers byte by byte, each byte encoded as two
3746 hex characters. Suck them all up, then supply them to the
3747 register cacheing/storage mechanism. */
3750 for (i = 0; i < rsa->sizeof_g_packet; i++)
3752 if (p[0] == 0 || p[1] == 0)
3753 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3754 internal_error (__FILE__, __LINE__,
3755 "unexpected end of 'g' packet reply");
3757 if (p[0] == 'x' && p[1] == 'x')
3758 regs[i] = 0; /* 'x' */
3760 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
3766 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3768 struct packet_reg *r = &rsa->regs[i];
3771 if (r->offset * 2 >= strlen (rs->buf))
3772 /* This shouldn't happen - we adjusted in_g_packet above. */
3773 internal_error (__FILE__, __LINE__,
3774 "unexpected end of 'g' packet reply");
3775 else if (rs->buf[r->offset * 2] == 'x')
3777 gdb_assert (r->offset * 2 < strlen (rs->buf));
3778 /* The register isn't available, mark it as such (at
3779 the same time setting the value to zero). */
3780 regcache_raw_supply (regcache, r->regnum, NULL);
3783 regcache_raw_supply (regcache, r->regnum,
3791 fetch_registers_using_g (struct regcache *regcache)
3794 process_g_packet (regcache);
3798 remote_fetch_registers (struct regcache *regcache, int regnum)
3800 struct remote_state *rs = get_remote_state ();
3801 struct remote_arch_state *rsa = get_remote_arch_state ();
3804 set_thread (PIDGET (inferior_ptid), 1);
3808 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
3809 gdb_assert (reg != NULL);
3811 /* If this register might be in the 'g' packet, try that first -
3812 we are likely to read more than one register. If this is the
3813 first 'g' packet, we might be overly optimistic about its
3814 contents, so fall back to 'p'. */
3815 if (reg->in_g_packet)
3817 fetch_registers_using_g (regcache);
3818 if (reg->in_g_packet)
3822 if (fetch_register_using_p (regcache, reg))
3825 /* This register is not available. */
3826 regcache_raw_supply (regcache, reg->regnum, NULL);
3831 fetch_registers_using_g (regcache);
3833 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3834 if (!rsa->regs[i].in_g_packet)
3835 if (!fetch_register_using_p (regcache, &rsa->regs[i]))
3837 /* This register is not available. */
3838 regcache_raw_supply (regcache, i, NULL);
3842 /* Prepare to store registers. Since we may send them all (using a
3843 'G' request), we have to read out the ones we don't want to change
3847 remote_prepare_to_store (struct regcache *regcache)
3849 struct remote_arch_state *rsa = get_remote_arch_state ();
3851 gdb_byte buf[MAX_REGISTER_SIZE];
3853 /* Make sure the entire registers array is valid. */
3854 switch (remote_protocol_packets[PACKET_P].support)
3856 case PACKET_DISABLE:
3857 case PACKET_SUPPORT_UNKNOWN:
3858 /* Make sure all the necessary registers are cached. */
3859 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3860 if (rsa->regs[i].in_g_packet)
3861 regcache_raw_read (regcache, rsa->regs[i].regnum, buf);
3868 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3869 packet was not recognized. */
3872 store_register_using_P (const struct regcache *regcache, struct packet_reg *reg)
3874 struct remote_state *rs = get_remote_state ();
3875 struct remote_arch_state *rsa = get_remote_arch_state ();
3876 /* Try storing a single register. */
3877 char *buf = rs->buf;
3878 gdb_byte regp[MAX_REGISTER_SIZE];
3881 if (remote_protocol_packets[PACKET_P].support == PACKET_DISABLE)
3884 if (reg->pnum == -1)
3887 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
3888 p = buf + strlen (buf);
3889 regcache_raw_collect (regcache, reg->regnum, regp);
3890 bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
3891 remote_send (&rs->buf, &rs->buf_size);
3893 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
3898 error (_("Could not write register \"%s\""),
3899 gdbarch_register_name (current_gdbarch, reg->regnum));
3900 case PACKET_UNKNOWN:
3903 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
3907 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3908 contents of the register cache buffer. FIXME: ignores errors. */
3911 store_registers_using_G (const struct regcache *regcache)
3913 struct remote_state *rs = get_remote_state ();
3914 struct remote_arch_state *rsa = get_remote_arch_state ();
3918 /* Extract all the registers in the regcache copying them into a
3922 regs = alloca (rsa->sizeof_g_packet);
3923 memset (regs, 0, rsa->sizeof_g_packet);
3924 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3926 struct packet_reg *r = &rsa->regs[i];
3928 regcache_raw_collect (regcache, r->regnum, regs + r->offset);
3932 /* Command describes registers byte by byte,
3933 each byte encoded as two hex characters. */
3936 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3938 bin2hex (regs, p, rsa->sizeof_g_packet);
3939 remote_send (&rs->buf, &rs->buf_size);
3942 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3943 of the register cache buffer. FIXME: ignores errors. */
3946 remote_store_registers (struct regcache *regcache, int regnum)
3948 struct remote_state *rs = get_remote_state ();
3949 struct remote_arch_state *rsa = get_remote_arch_state ();
3952 set_thread (PIDGET (inferior_ptid), 1);
3956 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
3957 gdb_assert (reg != NULL);
3959 /* Always prefer to store registers using the 'P' packet if
3960 possible; we often change only a small number of registers.
3961 Sometimes we change a larger number; we'd need help from a
3962 higher layer to know to use 'G'. */
3963 if (store_register_using_P (regcache, reg))
3966 /* For now, don't complain if we have no way to write the
3967 register. GDB loses track of unavailable registers too
3968 easily. Some day, this may be an error. We don't have
3969 any way to read the register, either... */
3970 if (!reg->in_g_packet)
3973 store_registers_using_G (regcache);
3977 store_registers_using_G (regcache);
3979 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3980 if (!rsa->regs[i].in_g_packet)
3981 if (!store_register_using_P (regcache, &rsa->regs[i]))
3982 /* See above for why we do not issue an error here. */
3987 /* Return the number of hex digits in num. */
3990 hexnumlen (ULONGEST num)
3994 for (i = 0; num != 0; i++)
4000 /* Set BUF to the minimum number of hex digits representing NUM. */
4003 hexnumstr (char *buf, ULONGEST num)
4005 int len = hexnumlen (num);
4006 return hexnumnstr (buf, num, len);
4010 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
4013 hexnumnstr (char *buf, ULONGEST num, int width)
4019 for (i = width - 1; i >= 0; i--)
4021 buf[i] = "0123456789abcdef"[(num & 0xf)];
4028 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
4031 remote_address_masked (CORE_ADDR addr)
4033 int address_size = remote_address_size;
4034 /* If "remoteaddresssize" was not set, default to target address size. */
4036 address_size = gdbarch_addr_bit (current_gdbarch);
4038 if (address_size > 0
4039 && address_size < (sizeof (ULONGEST) * 8))
4041 /* Only create a mask when that mask can safely be constructed
4042 in a ULONGEST variable. */
4044 mask = (mask << address_size) - 1;
4050 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
4051 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
4052 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
4053 (which may be more than *OUT_LEN due to escape characters). The
4054 total number of bytes in the output buffer will be at most
4058 remote_escape_output (const gdb_byte *buffer, int len,
4059 gdb_byte *out_buf, int *out_len,
4062 int input_index, output_index;
4065 for (input_index = 0; input_index < len; input_index++)
4067 gdb_byte b = buffer[input_index];
4069 if (b == '$' || b == '#' || b == '}')
4071 /* These must be escaped. */
4072 if (output_index + 2 > out_maxlen)
4074 out_buf[output_index++] = '}';
4075 out_buf[output_index++] = b ^ 0x20;
4079 if (output_index + 1 > out_maxlen)
4081 out_buf[output_index++] = b;
4085 *out_len = input_index;
4086 return output_index;
4089 /* Convert BUFFER, escaped data LEN bytes long, into binary data
4090 in OUT_BUF. Return the number of bytes written to OUT_BUF.
4091 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
4093 This function reverses remote_escape_output. It allows more
4094 escaped characters than that function does, in particular because
4095 '*' must be escaped to avoid the run-length encoding processing
4096 in reading packets. */
4099 remote_unescape_input (const gdb_byte *buffer, int len,
4100 gdb_byte *out_buf, int out_maxlen)
4102 int input_index, output_index;
4107 for (input_index = 0; input_index < len; input_index++)
4109 gdb_byte b = buffer[input_index];
4111 if (output_index + 1 > out_maxlen)
4113 warning (_("Received too much data from remote target;"
4114 " ignoring overflow."));
4115 return output_index;
4120 out_buf[output_index++] = b ^ 0x20;
4126 out_buf[output_index++] = b;
4130 error (_("Unmatched escape character in target response."));
4132 return output_index;
4135 /* Determine whether the remote target supports binary downloading.
4136 This is accomplished by sending a no-op memory write of zero length
4137 to the target at the specified address. It does not suffice to send
4138 the whole packet, since many stubs strip the eighth bit and
4139 subsequently compute a wrong checksum, which causes real havoc with
4142 NOTE: This can still lose if the serial line is not eight-bit
4143 clean. In cases like this, the user should clear "remote
4147 check_binary_download (CORE_ADDR addr)
4149 struct remote_state *rs = get_remote_state ();
4151 switch (remote_protocol_packets[PACKET_X].support)
4153 case PACKET_DISABLE:
4157 case PACKET_SUPPORT_UNKNOWN:
4163 p += hexnumstr (p, (ULONGEST) addr);
4165 p += hexnumstr (p, (ULONGEST) 0);
4169 putpkt_binary (rs->buf, (int) (p - rs->buf));
4170 getpkt (&rs->buf, &rs->buf_size, 0);
4172 if (rs->buf[0] == '\0')
4175 fprintf_unfiltered (gdb_stdlog,
4176 "binary downloading NOT suppported by target\n");
4177 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
4182 fprintf_unfiltered (gdb_stdlog,
4183 "binary downloading suppported by target\n");
4184 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
4191 /* Write memory data directly to the remote machine.
4192 This does not inform the data cache; the data cache uses this.
4193 HEADER is the starting part of the packet.
4194 MEMADDR is the address in the remote memory space.
4195 MYADDR is the address of the buffer in our space.
4196 LEN is the number of bytes.
4197 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4198 should send data as binary ('X'), or hex-encoded ('M').
4200 The function creates packet of the form
4201 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4203 where encoding of <DATA> is termined by PACKET_FORMAT.
4205 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4208 Returns the number of bytes transferred, or 0 (setting errno) for
4209 error. Only transfer a single packet. */
4212 remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
4213 const gdb_byte *myaddr, int len,
4214 char packet_format, int use_length)
4216 struct remote_state *rs = get_remote_state ();
4226 if (packet_format != 'X' && packet_format != 'M')
4227 internal_error (__FILE__, __LINE__,
4228 "remote_write_bytes_aux: bad packet format");
4233 payload_size = get_memory_write_packet_size ();
4235 /* The packet buffer will be large enough for the payload;
4236 get_memory_packet_size ensures this. */
4239 /* Compute the size of the actual payload by subtracting out the
4240 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4242 payload_size -= strlen ("$,:#NN");
4244 /* The comma won't be used. */
4246 header_length = strlen (header);
4247 payload_size -= header_length;
4248 payload_size -= hexnumlen (memaddr);
4250 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4252 strcat (rs->buf, header);
4253 p = rs->buf + strlen (header);
4255 /* Compute a best guess of the number of bytes actually transfered. */
4256 if (packet_format == 'X')
4258 /* Best guess at number of bytes that will fit. */
4259 todo = min (len, payload_size);
4261 payload_size -= hexnumlen (todo);
4262 todo = min (todo, payload_size);
4266 /* Num bytes that will fit. */
4267 todo = min (len, payload_size / 2);
4269 payload_size -= hexnumlen (todo);
4270 todo = min (todo, payload_size / 2);
4274 internal_error (__FILE__, __LINE__,
4275 _("minumum packet size too small to write data"));
4277 /* If we already need another packet, then try to align the end
4278 of this packet to a useful boundary. */
4279 if (todo > 2 * REMOTE_ALIGN_WRITES && todo < len)
4280 todo = ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
4282 /* Append "<memaddr>". */
4283 memaddr = remote_address_masked (memaddr);
4284 p += hexnumstr (p, (ULONGEST) memaddr);
4291 /* Append <len>. Retain the location/size of <len>. It may need to
4292 be adjusted once the packet body has been created. */
4294 plenlen = hexnumstr (p, (ULONGEST) todo);
4302 /* Append the packet body. */
4303 if (packet_format == 'X')
4305 /* Binary mode. Send target system values byte by byte, in
4306 increasing byte addresses. Only escape certain critical
4308 payload_length = remote_escape_output (myaddr, todo, p, &nr_bytes,
4311 /* If not all TODO bytes fit, then we'll need another packet. Make
4312 a second try to keep the end of the packet aligned. Don't do
4313 this if the packet is tiny. */
4314 if (nr_bytes < todo && nr_bytes > 2 * REMOTE_ALIGN_WRITES)
4318 new_nr_bytes = (((memaddr + nr_bytes) & ~(REMOTE_ALIGN_WRITES - 1))
4320 if (new_nr_bytes != nr_bytes)
4321 payload_length = remote_escape_output (myaddr, new_nr_bytes,
4326 p += payload_length;
4327 if (use_length && nr_bytes < todo)
4329 /* Escape chars have filled up the buffer prematurely,
4330 and we have actually sent fewer bytes than planned.
4331 Fix-up the length field of the packet. Use the same
4332 number of characters as before. */
4333 plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
4334 *plen = ':'; /* overwrite \0 from hexnumnstr() */
4339 /* Normal mode: Send target system values byte by byte, in
4340 increasing byte addresses. Each byte is encoded as a two hex
4342 nr_bytes = bin2hex (myaddr, p, todo);
4346 putpkt_binary (rs->buf, (int) (p - rs->buf));
4347 getpkt (&rs->buf, &rs->buf_size, 0);
4349 if (rs->buf[0] == 'E')
4351 /* There is no correspondance between what the remote protocol
4352 uses for errors and errno codes. We would like a cleaner way
4353 of representing errors (big enough to include errno codes,
4354 bfd_error codes, and others). But for now just return EIO. */
4359 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4360 fewer bytes than we'd planned. */
4364 /* Write memory data directly to the remote machine.
4365 This does not inform the data cache; the data cache uses this.
4366 MEMADDR is the address in the remote memory space.
4367 MYADDR is the address of the buffer in our space.
4368 LEN is the number of bytes.
4370 Returns number of bytes transferred, or 0 (setting errno) for
4371 error. Only transfer a single packet. */
4374 remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
4376 char *packet_format = 0;
4378 /* Check whether the target supports binary download. */
4379 check_binary_download (memaddr);
4381 switch (remote_protocol_packets[PACKET_X].support)
4384 packet_format = "X";
4386 case PACKET_DISABLE:
4387 packet_format = "M";
4389 case PACKET_SUPPORT_UNKNOWN:
4390 internal_error (__FILE__, __LINE__,
4391 _("remote_write_bytes: bad internal state"));
4393 internal_error (__FILE__, __LINE__, _("bad switch"));
4396 return remote_write_bytes_aux (packet_format,
4397 memaddr, myaddr, len, packet_format[0], 1);
4400 /* Read memory data directly from the remote machine.
4401 This does not use the data cache; the data cache uses this.
4402 MEMADDR is the address in the remote memory space.
4403 MYADDR is the address of the buffer in our space.
4404 LEN is the number of bytes.
4406 Returns number of bytes transferred, or 0 for error. */
4408 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4409 remote targets) shouldn't attempt to read the entire buffer.
4410 Instead it should read a single packet worth of data and then
4411 return the byte size of that packet to the caller. The caller (its
4412 caller and its callers caller ;-) already contains code for
4413 handling partial reads. */
4416 remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
4418 struct remote_state *rs = get_remote_state ();
4419 int max_buf_size; /* Max size of packet output buffer. */
4425 max_buf_size = get_memory_read_packet_size ();
4426 /* The packet buffer will be large enough for the payload;
4427 get_memory_packet_size ensures this. */
4436 todo = min (len, max_buf_size / 2); /* num bytes that will fit */
4438 /* construct "m"<memaddr>","<len>" */
4439 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4440 memaddr = remote_address_masked (memaddr);
4443 p += hexnumstr (p, (ULONGEST) memaddr);
4445 p += hexnumstr (p, (ULONGEST) todo);
4449 getpkt (&rs->buf, &rs->buf_size, 0);
4451 if (rs->buf[0] == 'E'
4452 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
4453 && rs->buf[3] == '\0')
4455 /* There is no correspondance between what the remote
4456 protocol uses for errors and errno codes. We would like
4457 a cleaner way of representing errors (big enough to
4458 include errno codes, bfd_error codes, and others). But
4459 for now just return EIO. */
4464 /* Reply describes memory byte by byte,
4465 each byte encoded as two hex characters. */
4468 if ((i = hex2bin (p, myaddr, todo)) < todo)
4470 /* Reply is short. This means that we were able to read
4471 only part of what we wanted to. */
4472 return i + (origlen - len);
4481 /* Read or write LEN bytes from inferior memory at MEMADDR,
4482 transferring to or from debugger address BUFFER. Write to inferior
4483 if SHOULD_WRITE is nonzero. Returns length of data written or
4484 read; 0 for error. TARGET is unused. */
4487 remote_xfer_memory (CORE_ADDR mem_addr, gdb_byte *buffer, int mem_len,
4488 int should_write, struct mem_attrib *attrib,
4489 struct target_ops *target)
4494 res = remote_write_bytes (mem_addr, buffer, mem_len);
4496 res = remote_read_bytes (mem_addr, buffer, mem_len);
4501 /* Sends a packet with content determined by the printf format string
4502 FORMAT and the remaining arguments, then gets the reply. Returns
4503 whether the packet was a success, a failure, or unknown. */
4506 remote_send_printf (const char *format, ...)
4508 struct remote_state *rs = get_remote_state ();
4509 int max_size = get_remote_packet_size ();
4512 va_start (ap, format);
4515 if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
4516 internal_error (__FILE__, __LINE__, "Too long remote packet.");
4518 if (putpkt (rs->buf) < 0)
4519 error (_("Communication problem with target."));
4522 getpkt (&rs->buf, &rs->buf_size, 0);
4524 return packet_check_result (rs->buf);
4528 restore_remote_timeout (void *p)
4530 int value = *(int *)p;
4531 remote_timeout = value;
4534 /* Flash writing can take quite some time. We'll set
4535 effectively infinite timeout for flash operations.
4536 In future, we'll need to decide on a better approach. */
4537 static const int remote_flash_timeout = 1000;
4540 remote_flash_erase (struct target_ops *ops,
4541 ULONGEST address, LONGEST length)
4543 int saved_remote_timeout = remote_timeout;
4544 enum packet_result ret;
4546 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
4547 &saved_remote_timeout);
4548 remote_timeout = remote_flash_timeout;
4550 ret = remote_send_printf ("vFlashErase:%s,%s",
4555 case PACKET_UNKNOWN:
4556 error (_("Remote target does not support flash erase"));
4558 error (_("Error erasing flash with vFlashErase packet"));
4563 do_cleanups (back_to);
4567 remote_flash_write (struct target_ops *ops,
4568 ULONGEST address, LONGEST length,
4569 const gdb_byte *data)
4571 int saved_remote_timeout = remote_timeout;
4573 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
4574 &saved_remote_timeout);
4576 remote_timeout = remote_flash_timeout;
4577 ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 'X', 0);
4578 do_cleanups (back_to);
4584 remote_flash_done (struct target_ops *ops)
4586 int saved_remote_timeout = remote_timeout;
4588 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
4589 &saved_remote_timeout);
4591 remote_timeout = remote_flash_timeout;
4592 ret = remote_send_printf ("vFlashDone");
4593 do_cleanups (back_to);
4597 case PACKET_UNKNOWN:
4598 error (_("Remote target does not support vFlashDone"));
4600 error (_("Error finishing flash operation"));
4607 remote_files_info (struct target_ops *ignore)
4609 puts_filtered ("Debugging a target over a serial line.\n");
4612 /* Stuff for dealing with the packets which are part of this protocol.
4613 See comment at top of file for details. */
4615 /* Read a single character from the remote end. */
4618 readchar (int timeout)
4622 ch = serial_readchar (remote_desc, timeout);
4627 switch ((enum serial_rc) ch)
4630 target_mourn_inferior ();
4631 error (_("Remote connection closed"));
4634 perror_with_name (_("Remote communication error"));
4636 case SERIAL_TIMEOUT:
4642 /* Send the command in *BUF to the remote machine, and read the reply
4643 into *BUF. Report an error if we get an error reply. Resize
4644 *BUF using xrealloc if necessary to hold the result, and update
4648 remote_send (char **buf,
4652 getpkt (buf, sizeof_buf, 0);
4654 if ((*buf)[0] == 'E')
4655 error (_("Remote failure reply: %s"), *buf);
4658 /* Display a null-terminated packet on stdout, for debugging, using C
4662 print_packet (char *buf)
4664 puts_filtered ("\"");
4665 fputstr_filtered (buf, '"', gdb_stdout);
4666 puts_filtered ("\"");
4672 return putpkt_binary (buf, strlen (buf));
4675 /* Send a packet to the remote machine, with error checking. The data
4676 of the packet is in BUF. The string in BUF can be at most
4677 get_remote_packet_size () - 5 to account for the $, # and checksum,
4678 and for a possible /0 if we are debugging (remote_debug) and want
4679 to print the sent packet as a string. */
4682 putpkt_binary (char *buf, int cnt)
4685 unsigned char csum = 0;
4686 char *buf2 = alloca (cnt + 6);
4692 /* Copy the packet into buffer BUF2, encapsulating it
4693 and giving it a checksum. */
4698 for (i = 0; i < cnt; i++)
4704 *p++ = tohex ((csum >> 4) & 0xf);
4705 *p++ = tohex (csum & 0xf);
4707 /* Send it over and over until we get a positive ack. */
4711 int started_error_output = 0;
4716 fprintf_unfiltered (gdb_stdlog, "Sending packet: ");
4717 fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog);
4718 fprintf_unfiltered (gdb_stdlog, "...");
4719 gdb_flush (gdb_stdlog);
4721 if (serial_write (remote_desc, buf2, p - buf2))
4722 perror_with_name (_("putpkt: write failed"));
4724 /* Read until either a timeout occurs (-2) or '+' is read. */
4727 ch = readchar (remote_timeout);
4735 case SERIAL_TIMEOUT:
4737 if (started_error_output)
4739 putchar_unfiltered ('\n');
4740 started_error_output = 0;
4749 fprintf_unfiltered (gdb_stdlog, "Ack\n");
4753 fprintf_unfiltered (gdb_stdlog, "Nak\n");
4754 case SERIAL_TIMEOUT:
4758 break; /* Retransmit buffer. */
4762 fprintf_unfiltered (gdb_stdlog,
4763 "Packet instead of Ack, ignoring it\n");
4764 /* It's probably an old response sent because an ACK
4765 was lost. Gobble up the packet and ack it so it
4766 doesn't get retransmitted when we resend this
4769 serial_write (remote_desc, "+", 1);
4770 continue; /* Now, go look for +. */
4775 if (!started_error_output)
4777 started_error_output = 1;
4778 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
4780 fputc_unfiltered (ch & 0177, gdb_stdlog);
4784 break; /* Here to retransmit. */
4788 /* This is wrong. If doing a long backtrace, the user should be
4789 able to get out next time we call QUIT, without anything as
4790 violent as interrupt_query. If we want to provide a way out of
4791 here without getting to the next QUIT, it should be based on
4792 hitting ^C twice as in remote_wait. */
4802 /* Come here after finding the start of a frame when we expected an
4803 ack. Do our best to discard the rest of this packet. */
4812 c = readchar (remote_timeout);
4815 case SERIAL_TIMEOUT:
4816 /* Nothing we can do. */
4819 /* Discard the two bytes of checksum and stop. */
4820 c = readchar (remote_timeout);
4822 c = readchar (remote_timeout);
4825 case '*': /* Run length encoding. */
4826 /* Discard the repeat count. */
4827 c = readchar (remote_timeout);
4832 /* A regular character. */
4838 /* Come here after finding the start of the frame. Collect the rest
4839 into *BUF, verifying the checksum, length, and handling run-length
4840 compression. NUL terminate the buffer. If there is not enough room,
4841 expand *BUF using xrealloc.
4843 Returns -1 on error, number of characters in buffer (ignoring the
4844 trailing NULL) on success. (could be extended to return one of the
4845 SERIAL status indications). */
4848 read_frame (char **buf_p,
4861 c = readchar (remote_timeout);
4864 case SERIAL_TIMEOUT:
4866 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
4870 fputs_filtered ("Saw new packet start in middle of old one\n",
4872 return -1; /* Start a new packet, count retries. */
4875 unsigned char pktcsum;
4881 check_0 = readchar (remote_timeout);
4883 check_1 = readchar (remote_timeout);
4885 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
4888 fputs_filtered ("Timeout in checksum, retrying\n",
4892 else if (check_0 < 0 || check_1 < 0)
4895 fputs_filtered ("Communication error in checksum\n",
4900 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
4901 if (csum == pktcsum)
4906 fprintf_filtered (gdb_stdlog,
4907 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4909 fputstrn_filtered (buf, bc, 0, gdb_stdlog);
4910 fputs_filtered ("\n", gdb_stdlog);
4912 /* Number of characters in buffer ignoring trailing
4916 case '*': /* Run length encoding. */
4921 c = readchar (remote_timeout);
4923 repeat = c - ' ' + 3; /* Compute repeat count. */
4925 /* The character before ``*'' is repeated. */
4927 if (repeat > 0 && repeat <= 255 && bc > 0)
4929 if (bc + repeat - 1 >= *sizeof_buf - 1)
4931 /* Make some more room in the buffer. */
4932 *sizeof_buf += repeat;
4933 *buf_p = xrealloc (*buf_p, *sizeof_buf);
4937 memset (&buf[bc], buf[bc - 1], repeat);
4943 printf_filtered (_("Invalid run length encoding: %s\n"), buf);
4947 if (bc >= *sizeof_buf - 1)
4949 /* Make some more room in the buffer. */
4951 *buf_p = xrealloc (*buf_p, *sizeof_buf);
4962 /* Read a packet from the remote machine, with error checking, and
4963 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4964 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4965 rather than timing out; this is used (in synchronous mode) to wait
4966 for a target that is is executing user code to stop. */
4967 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4968 don't have to change all the calls to getpkt to deal with the
4969 return value, because at the moment I don't know what the right
4970 thing to do it for those. */
4978 timed_out = getpkt_sane (buf, sizeof_buf, forever);
4982 /* Read a packet from the remote machine, with error checking, and
4983 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4984 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4985 rather than timing out; this is used (in synchronous mode) to wait
4986 for a target that is is executing user code to stop. If FOREVER ==
4987 0, this function is allowed to time out gracefully and return an
4988 indication of this to the caller. Otherwise return the number
4991 getpkt_sane (char **buf, long *sizeof_buf, int forever)
4998 strcpy (*buf, "timeout");
5002 timeout = watchdog > 0 ? watchdog : -1;
5006 timeout = remote_timeout;
5010 for (tries = 1; tries <= MAX_TRIES; tries++)
5012 /* This can loop forever if the remote side sends us characters
5013 continuously, but if it pauses, we'll get a zero from
5014 readchar because of timeout. Then we'll count that as a
5017 /* Note that we will only wait forever prior to the start of a
5018 packet. After that, we expect characters to arrive at a
5019 brisk pace. They should show up within remote_timeout
5024 c = readchar (timeout);
5026 if (c == SERIAL_TIMEOUT)
5028 if (forever) /* Watchdog went off? Kill the target. */
5031 target_mourn_inferior ();
5032 error (_("Watchdog timeout has expired. Target detached."));
5035 fputs_filtered ("Timed out.\n", gdb_stdlog);
5041 /* We've found the start of a packet, now collect the data. */
5043 val = read_frame (buf, sizeof_buf);
5049 fprintf_unfiltered (gdb_stdlog, "Packet received: ");
5050 fputstrn_unfiltered (*buf, val, 0, gdb_stdlog);
5051 fprintf_unfiltered (gdb_stdlog, "\n");
5053 serial_write (remote_desc, "+", 1);
5057 /* Try the whole thing again. */
5059 serial_write (remote_desc, "-", 1);
5062 /* We have tried hard enough, and just can't receive the packet.
5065 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
5066 serial_write (remote_desc, "+", 1);
5073 /* For some mysterious reason, wait_for_inferior calls kill instead of
5074 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5078 target_mourn_inferior ();
5082 /* Use catch_errors so the user can quit from gdb even when we aren't on
5083 speaking terms with the remote system. */
5084 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
5086 /* Don't wait for it to die. I'm not really sure it matters whether
5087 we do or not. For the existing stubs, kill is a noop. */
5088 target_mourn_inferior ();
5091 /* Async version of remote_kill. */
5093 remote_async_kill (void)
5095 /* Unregister the file descriptor from the event loop. */
5096 if (target_is_async_p ())
5097 serial_async (remote_desc, NULL, 0);
5099 /* For some mysterious reason, wait_for_inferior calls kill instead of
5100 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5104 target_mourn_inferior ();
5108 /* Use catch_errors so the user can quit from gdb even when we
5109 aren't on speaking terms with the remote system. */
5110 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
5112 /* Don't wait for it to die. I'm not really sure it matters whether
5113 we do or not. For the existing stubs, kill is a noop. */
5114 target_mourn_inferior ();
5120 remote_mourn_1 (&remote_ops);
5124 remote_async_mourn (void)
5126 remote_mourn_1 (&remote_async_ops);
5130 extended_remote_mourn (void)
5132 /* We do _not_ want to mourn the target like this; this will
5133 remove the extended remote target from the target stack,
5134 and the next time the user says "run" it'll fail.
5136 FIXME: What is the right thing to do here? */
5138 remote_mourn_1 (&extended_remote_ops);
5142 /* Worker function for remote_mourn. */
5144 remote_mourn_1 (struct target_ops *target)
5146 unpush_target (target);
5147 generic_mourn_inferior ();
5150 /* In the extended protocol we want to be able to do things like
5151 "run" and have them basically work as expected. So we need
5152 a special create_inferior function.
5154 FIXME: One day add support for changing the exec file
5155 we're debugging, arguments and an environment. */
5158 extended_remote_create_inferior (char *exec_file, char *args,
5159 char **env, int from_tty)
5161 /* Rip out the breakpoints; we'll reinsert them after restarting
5162 the remote server. */
5163 remove_breakpoints ();
5165 /* Now restart the remote server. */
5166 extended_remote_restart ();
5168 /* NOTE: We don't need to recheck for a target description here; but
5169 if we gain the ability to switch the remote executable we may
5170 need to, if for instance we are running a process which requested
5171 different emulated hardware from the operating system. A
5172 concrete example of this is ARM GNU/Linux, where some binaries
5173 will have a legacy FPA coprocessor emulated and others may have
5174 access to a hardware VFP unit. */
5176 /* Now put the breakpoints back in. This way we're safe if the
5177 restart function works via a unix fork on the remote side. */
5178 insert_breakpoints ();
5180 /* Clean up from the last time we were running. */
5181 clear_proceed_status ();
5184 /* Async version of extended_remote_create_inferior. */
5186 extended_remote_async_create_inferior (char *exec_file, char *args,
5187 char **env, int from_tty)
5189 /* Rip out the breakpoints; we'll reinsert them after restarting
5190 the remote server. */
5191 remove_breakpoints ();
5193 /* If running asynchronously, register the target file descriptor
5194 with the event loop. */
5195 if (target_can_async_p ())
5196 target_async (inferior_event_handler, 0);
5198 /* Now restart the remote server. */
5199 extended_remote_restart ();
5201 /* NOTE: We don't need to recheck for a target description here; but
5202 if we gain the ability to switch the remote executable we may
5203 need to, if for instance we are running a process which requested
5204 different emulated hardware from the operating system. A
5205 concrete example of this is ARM GNU/Linux, where some binaries
5206 will have a legacy FPA coprocessor emulated and others may have
5207 access to a hardware VFP unit. */
5209 /* Now put the breakpoints back in. This way we're safe if the
5210 restart function works via a unix fork on the remote side. */
5211 insert_breakpoints ();
5213 /* Clean up from the last time we were running. */
5214 clear_proceed_status ();
5218 /* Insert a breakpoint. On targets that have software breakpoint
5219 support, we ask the remote target to do the work; on targets
5220 which don't, we insert a traditional memory breakpoint. */
5223 remote_insert_breakpoint (struct bp_target_info *bp_tgt)
5225 CORE_ADDR addr = bp_tgt->placed_address;
5226 struct remote_state *rs = get_remote_state ();
5228 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5229 If it succeeds, then set the support to PACKET_ENABLE. If it
5230 fails, and the user has explicitly requested the Z support then
5231 report an error, otherwise, mark it disabled and go on. */
5233 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
5240 gdbarch_breakpoint_from_pc
5241 (current_gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
5242 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
5243 p += hexnumstr (p, addr);
5244 sprintf (p, ",%d", bp_tgt->placed_size);
5247 getpkt (&rs->buf, &rs->buf_size, 0);
5249 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
5255 case PACKET_UNKNOWN:
5260 return memory_insert_breakpoint (bp_tgt);
5264 remote_remove_breakpoint (struct bp_target_info *bp_tgt)
5266 CORE_ADDR addr = bp_tgt->placed_address;
5267 struct remote_state *rs = get_remote_state ();
5270 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
5278 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
5279 p += hexnumstr (p, addr);
5280 sprintf (p, ",%d", bp_tgt->placed_size);
5283 getpkt (&rs->buf, &rs->buf_size, 0);
5285 return (rs->buf[0] == 'E');
5288 return memory_remove_breakpoint (bp_tgt);
5292 watchpoint_to_Z_packet (int type)
5297 return Z_PACKET_WRITE_WP;
5300 return Z_PACKET_READ_WP;
5303 return Z_PACKET_ACCESS_WP;
5306 internal_error (__FILE__, __LINE__,
5307 _("hw_bp_to_z: bad watchpoint type %d"), type);
5312 remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
5314 struct remote_state *rs = get_remote_state ();
5316 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
5318 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
5321 sprintf (rs->buf, "Z%x,", packet);
5322 p = strchr (rs->buf, '\0');
5323 addr = remote_address_masked (addr);
5324 p += hexnumstr (p, (ULONGEST) addr);
5325 sprintf (p, ",%x", len);
5328 getpkt (&rs->buf, &rs->buf_size, 0);
5330 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
5333 case PACKET_UNKNOWN:
5338 internal_error (__FILE__, __LINE__,
5339 _("remote_insert_watchpoint: reached end of function"));
5344 remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
5346 struct remote_state *rs = get_remote_state ();
5348 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
5350 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
5353 sprintf (rs->buf, "z%x,", packet);
5354 p = strchr (rs->buf, '\0');
5355 addr = remote_address_masked (addr);
5356 p += hexnumstr (p, (ULONGEST) addr);
5357 sprintf (p, ",%x", len);
5359 getpkt (&rs->buf, &rs->buf_size, 0);
5361 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
5364 case PACKET_UNKNOWN:
5369 internal_error (__FILE__, __LINE__,
5370 _("remote_remove_watchpoint: reached end of function"));
5374 int remote_hw_watchpoint_limit = -1;
5375 int remote_hw_breakpoint_limit = -1;
5378 remote_check_watch_resources (int type, int cnt, int ot)
5380 if (type == bp_hardware_breakpoint)
5382 if (remote_hw_breakpoint_limit == 0)
5384 else if (remote_hw_breakpoint_limit < 0)
5386 else if (cnt <= remote_hw_breakpoint_limit)
5391 if (remote_hw_watchpoint_limit == 0)
5393 else if (remote_hw_watchpoint_limit < 0)
5397 else if (cnt <= remote_hw_watchpoint_limit)
5404 remote_stopped_by_watchpoint (void)
5406 return remote_stopped_by_watchpoint_p;
5410 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
5413 if (remote_stopped_by_watchpoint ())
5415 *addr_p = remote_watch_data_address;
5424 remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
5427 struct remote_state *rs = get_remote_state ();
5430 /* The length field should be set to the size of a breakpoint
5431 instruction, even though we aren't inserting one ourselves. */
5433 gdbarch_breakpoint_from_pc
5434 (current_gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
5436 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
5443 addr = remote_address_masked (bp_tgt->placed_address);
5444 p += hexnumstr (p, (ULONGEST) addr);
5445 sprintf (p, ",%x", bp_tgt->placed_size);
5448 getpkt (&rs->buf, &rs->buf_size, 0);
5450 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
5453 case PACKET_UNKNOWN:
5458 internal_error (__FILE__, __LINE__,
5459 _("remote_insert_hw_breakpoint: reached end of function"));
5464 remote_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
5467 struct remote_state *rs = get_remote_state ();
5470 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
5477 addr = remote_address_masked (bp_tgt->placed_address);
5478 p += hexnumstr (p, (ULONGEST) addr);
5479 sprintf (p, ",%x", bp_tgt->placed_size);
5482 getpkt (&rs->buf, &rs->buf_size, 0);
5484 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
5487 case PACKET_UNKNOWN:
5492 internal_error (__FILE__, __LINE__,
5493 _("remote_remove_hw_breakpoint: reached end of function"));
5496 /* Some targets are only capable of doing downloads, and afterwards
5497 they switch to the remote serial protocol. This function provides
5498 a clean way to get from the download target to the remote target.
5499 It's basically just a wrapper so that we don't have to expose any
5500 of the internal workings of remote.c.
5502 Prior to calling this routine, you should shutdown the current
5503 target code, else you will get the "A program is being debugged
5504 already..." message. Usually a call to pop_target() suffices. */
5507 push_remote_target (char *name, int from_tty)
5509 printf_filtered (_("Switching to remote protocol\n"));
5510 remote_open (name, from_tty);
5513 /* Table used by the crc32 function to calcuate the checksum. */
5515 static unsigned long crc32_table[256] =
5518 static unsigned long
5519 crc32 (unsigned char *buf, int len, unsigned int crc)
5521 if (!crc32_table[1])
5523 /* Initialize the CRC table and the decoding table. */
5527 for (i = 0; i < 256; i++)
5529 for (c = i << 24, j = 8; j > 0; --j)
5530 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
5537 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
5543 /* compare-sections command
5545 With no arguments, compares each loadable section in the exec bfd
5546 with the same memory range on the target, and reports mismatches.
5547 Useful for verifying the image on the target against the exec file.
5548 Depends on the target understanding the new "qCRC:" request. */
5550 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5551 target method (target verify memory) and generic version of the
5552 actual command. This will allow other high-level code (especially
5553 generic_load()) to make use of this target functionality. */
5556 compare_sections_command (char *args, int from_tty)
5558 struct remote_state *rs = get_remote_state ();
5560 unsigned long host_crc, target_crc;
5561 extern bfd *exec_bfd;
5562 struct cleanup *old_chain;
5565 const char *sectname;
5572 error (_("command cannot be used without an exec file"));
5573 if (!current_target.to_shortname ||
5574 strcmp (current_target.to_shortname, "remote") != 0)
5575 error (_("command can only be used with remote target"));
5577 for (s = exec_bfd->sections; s; s = s->next)
5579 if (!(s->flags & SEC_LOAD))
5580 continue; /* skip non-loadable section */
5582 size = bfd_get_section_size (s);
5584 continue; /* skip zero-length section */
5586 sectname = bfd_get_section_name (exec_bfd, s);
5587 if (args && strcmp (args, sectname) != 0)
5588 continue; /* not the section selected by user */
5590 matched = 1; /* do this section */
5592 /* FIXME: assumes lma can fit into long. */
5593 xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
5594 (long) lma, (long) size);
5597 /* Be clever; compute the host_crc before waiting for target
5599 sectdata = xmalloc (size);
5600 old_chain = make_cleanup (xfree, sectdata);
5601 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
5602 host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
5604 getpkt (&rs->buf, &rs->buf_size, 0);
5605 if (rs->buf[0] == 'E')
5606 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5607 sectname, paddr (lma), paddr (lma + size));
5608 if (rs->buf[0] != 'C')
5609 error (_("remote target does not support this operation"));
5611 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
5612 target_crc = target_crc * 16 + fromhex (*tmp);
5614 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5615 sectname, paddr (lma), paddr (lma + size));
5616 if (host_crc == target_crc)
5617 printf_filtered ("matched.\n");
5620 printf_filtered ("MIS-MATCHED!\n");
5624 do_cleanups (old_chain);
5627 warning (_("One or more sections of the remote executable does not match\n\
5628 the loaded file\n"));
5629 if (args && !matched)
5630 printf_filtered (_("No loaded section named '%s'.\n"), args);
5633 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5634 into remote target. The number of bytes written to the remote
5635 target is returned, or -1 for error. */
5638 remote_write_qxfer (struct target_ops *ops, const char *object_name,
5639 const char *annex, const gdb_byte *writebuf,
5640 ULONGEST offset, LONGEST len,
5641 struct packet_config *packet)
5646 struct remote_state *rs = get_remote_state ();
5647 int max_size = get_memory_write_packet_size ();
5649 if (packet->support == PACKET_DISABLE)
5652 /* Insert header. */
5653 i = snprintf (rs->buf, max_size,
5654 "qXfer:%s:write:%s:%s:",
5655 object_name, annex ? annex : "",
5656 phex_nz (offset, sizeof offset));
5657 max_size -= (i + 1);
5659 /* Escape as much data as fits into rs->buf. */
5660 buf_len = remote_escape_output
5661 (writebuf, len, (rs->buf + i), &max_size, max_size);
5663 if (putpkt_binary (rs->buf, i + buf_len) < 0
5664 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
5665 || packet_ok (rs->buf, packet) != PACKET_OK)
5668 unpack_varlen_hex (rs->buf, &n);
5672 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5673 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5674 number of bytes read is returned, or 0 for EOF, or -1 for error.
5675 The number of bytes read may be less than LEN without indicating an
5676 EOF. PACKET is checked and updated to indicate whether the remote
5677 target supports this object. */
5680 remote_read_qxfer (struct target_ops *ops, const char *object_name,
5682 gdb_byte *readbuf, ULONGEST offset, LONGEST len,
5683 struct packet_config *packet)
5685 static char *finished_object;
5686 static char *finished_annex;
5687 static ULONGEST finished_offset;
5689 struct remote_state *rs = get_remote_state ();
5690 unsigned int total = 0;
5691 LONGEST i, n, packet_len;
5693 if (packet->support == PACKET_DISABLE)
5696 /* Check whether we've cached an end-of-object packet that matches
5698 if (finished_object)
5700 if (strcmp (object_name, finished_object) == 0
5701 && strcmp (annex ? annex : "", finished_annex) == 0
5702 && offset == finished_offset)
5705 /* Otherwise, we're now reading something different. Discard
5707 xfree (finished_object);
5708 xfree (finished_annex);
5709 finished_object = NULL;
5710 finished_annex = NULL;
5713 /* Request only enough to fit in a single packet. The actual data
5714 may not, since we don't know how much of it will need to be escaped;
5715 the target is free to respond with slightly less data. We subtract
5716 five to account for the response type and the protocol frame. */
5717 n = min (get_remote_packet_size () - 5, len);
5718 snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5719 object_name, annex ? annex : "",
5720 phex_nz (offset, sizeof offset),
5721 phex_nz (n, sizeof n));
5722 i = putpkt (rs->buf);
5727 packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
5728 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
5731 if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
5732 error (_("Unknown remote qXfer reply: %s"), rs->buf);
5734 /* 'm' means there is (or at least might be) more data after this
5735 batch. That does not make sense unless there's at least one byte
5736 of data in this reply. */
5737 if (rs->buf[0] == 'm' && packet_len == 1)
5738 error (_("Remote qXfer reply contained no data."));
5740 /* Got some data. */
5741 i = remote_unescape_input (rs->buf + 1, packet_len - 1, readbuf, n);
5743 /* 'l' is an EOF marker, possibly including a final block of data,
5744 or possibly empty. If we have the final block of a non-empty
5745 object, record this fact to bypass a subsequent partial read. */
5746 if (rs->buf[0] == 'l' && offset + i > 0)
5748 finished_object = xstrdup (object_name);
5749 finished_annex = xstrdup (annex ? annex : "");
5750 finished_offset = offset + i;
5757 remote_xfer_partial (struct target_ops *ops, enum target_object object,
5758 const char *annex, gdb_byte *readbuf,
5759 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5761 struct remote_state *rs = get_remote_state ();
5766 /* Handle memory using the standard memory routines. */
5767 if (object == TARGET_OBJECT_MEMORY)
5772 if (writebuf != NULL)
5773 xfered = remote_write_bytes (offset, writebuf, len);
5775 xfered = remote_read_bytes (offset, readbuf, len);
5779 else if (xfered == 0 && errno == 0)
5785 /* Handle SPU memory using qxfer packets. */
5786 if (object == TARGET_OBJECT_SPU)
5789 return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len,
5790 &remote_protocol_packets
5791 [PACKET_qXfer_spu_read]);
5793 return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len,
5794 &remote_protocol_packets
5795 [PACKET_qXfer_spu_write]);
5798 /* Only handle flash writes. */
5799 if (writebuf != NULL)
5805 case TARGET_OBJECT_FLASH:
5806 xfered = remote_flash_write (ops, offset, len, writebuf);
5810 else if (xfered == 0 && errno == 0)
5820 /* Map pre-existing objects onto letters. DO NOT do this for new
5821 objects!!! Instead specify new query packets. */
5824 case TARGET_OBJECT_AVR:
5828 case TARGET_OBJECT_AUXV:
5829 gdb_assert (annex == NULL);
5830 return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
5831 &remote_protocol_packets[PACKET_qXfer_auxv]);
5833 case TARGET_OBJECT_AVAILABLE_FEATURES:
5834 return remote_read_qxfer
5835 (ops, "features", annex, readbuf, offset, len,
5836 &remote_protocol_packets[PACKET_qXfer_features]);
5838 case TARGET_OBJECT_LIBRARIES:
5839 return remote_read_qxfer
5840 (ops, "libraries", annex, readbuf, offset, len,
5841 &remote_protocol_packets[PACKET_qXfer_libraries]);
5843 case TARGET_OBJECT_MEMORY_MAP:
5844 gdb_assert (annex == NULL);
5845 return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,
5846 &remote_protocol_packets[PACKET_qXfer_memory_map]);
5852 /* Note: a zero OFFSET and LEN can be used to query the minimum
5854 if (offset == 0 && len == 0)
5855 return (get_remote_packet_size ());
5856 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5857 large enough let the caller deal with it. */
5858 if (len < get_remote_packet_size ())
5860 len = get_remote_packet_size ();
5862 /* Except for querying the minimum buffer size, target must be open. */
5864 error (_("remote query is only available after target open"));
5866 gdb_assert (annex != NULL);
5867 gdb_assert (readbuf != NULL);
5873 /* We used one buffer char for the remote protocol q command and
5874 another for the query type. As the remote protocol encapsulation
5875 uses 4 chars plus one extra in case we are debugging
5876 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5879 while (annex[i] && (i < (get_remote_packet_size () - 8)))
5881 /* Bad caller may have sent forbidden characters. */
5882 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
5887 gdb_assert (annex[i] == '\0');
5889 i = putpkt (rs->buf);
5893 getpkt (&rs->buf, &rs->buf_size, 0);
5894 strcpy ((char *) readbuf, rs->buf);
5896 return strlen ((char *) readbuf);
5900 remote_rcmd (char *command,
5901 struct ui_file *outbuf)
5903 struct remote_state *rs = get_remote_state ();
5907 error (_("remote rcmd is only available after target open"));
5909 /* Send a NULL command across as an empty command. */
5910 if (command == NULL)
5913 /* The query prefix. */
5914 strcpy (rs->buf, "qRcmd,");
5915 p = strchr (rs->buf, '\0');
5917 if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
5918 error (_("\"monitor\" command ``%s'' is too long."), command);
5920 /* Encode the actual command. */
5921 bin2hex ((gdb_byte *) command, p, 0);
5923 if (putpkt (rs->buf) < 0)
5924 error (_("Communication problem with target."));
5926 /* get/display the response */
5931 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5933 getpkt (&rs->buf, &rs->buf_size, 0);
5936 error (_("Target does not support this command."));
5937 if (buf[0] == 'O' && buf[1] != 'K')
5939 remote_console_output (buf + 1); /* 'O' message from stub. */
5942 if (strcmp (buf, "OK") == 0)
5944 if (strlen (buf) == 3 && buf[0] == 'E'
5945 && isdigit (buf[1]) && isdigit (buf[2]))
5947 error (_("Protocol error with Rcmd"));
5949 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
5951 char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
5952 fputc_unfiltered (c, outbuf);
5958 static VEC(mem_region_s) *
5959 remote_memory_map (struct target_ops *ops)
5961 VEC(mem_region_s) *result = NULL;
5962 char *text = target_read_stralloc (¤t_target,
5963 TARGET_OBJECT_MEMORY_MAP, NULL);
5967 struct cleanup *back_to = make_cleanup (xfree, text);
5968 result = parse_memory_map (text);
5969 do_cleanups (back_to);
5976 packet_command (char *args, int from_tty)
5978 struct remote_state *rs = get_remote_state ();
5981 error (_("command can only be used with remote target"));
5984 error (_("remote-packet command requires packet text as argument"));
5986 puts_filtered ("sending: ");
5987 print_packet (args);
5988 puts_filtered ("\n");
5991 getpkt (&rs->buf, &rs->buf_size, 0);
5992 puts_filtered ("received: ");
5993 print_packet (rs->buf);
5994 puts_filtered ("\n");
5998 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
6000 static void display_thread_info (struct gdb_ext_thread_info *info);
6002 static void threadset_test_cmd (char *cmd, int tty);
6004 static void threadalive_test (char *cmd, int tty);
6006 static void threadlist_test_cmd (char *cmd, int tty);
6008 int get_and_display_threadinfo (threadref *ref);
6010 static void threadinfo_test_cmd (char *cmd, int tty);
6012 static int thread_display_step (threadref *ref, void *context);
6014 static void threadlist_update_test_cmd (char *cmd, int tty);
6016 static void init_remote_threadtests (void);
6018 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
6021 threadset_test_cmd (char *cmd, int tty)
6023 int sample_thread = SAMPLE_THREAD;
6025 printf_filtered (_("Remote threadset test\n"));
6026 set_thread (sample_thread, 1);
6031 threadalive_test (char *cmd, int tty)
6033 int sample_thread = SAMPLE_THREAD;
6035 if (remote_thread_alive (pid_to_ptid (sample_thread)))
6036 printf_filtered ("PASS: Thread alive test\n");
6038 printf_filtered ("FAIL: Thread alive test\n");
6041 void output_threadid (char *title, threadref *ref);
6044 output_threadid (char *title, threadref *ref)
6048 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */
6050 printf_filtered ("%s %s\n", title, (&hexid[0]));
6054 threadlist_test_cmd (char *cmd, int tty)
6057 threadref nextthread;
6058 int done, result_count;
6059 threadref threadlist[3];
6061 printf_filtered ("Remote Threadlist test\n");
6062 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
6063 &result_count, &threadlist[0]))
6064 printf_filtered ("FAIL: threadlist test\n");
6067 threadref *scan = threadlist;
6068 threadref *limit = scan + result_count;
6070 while (scan < limit)
6071 output_threadid (" thread ", scan++);
6076 display_thread_info (struct gdb_ext_thread_info *info)
6078 output_threadid ("Threadid: ", &info->threadid);
6079 printf_filtered ("Name: %s\n ", info->shortname);
6080 printf_filtered ("State: %s\n", info->display);
6081 printf_filtered ("other: %s\n\n", info->more_display);
6085 get_and_display_threadinfo (threadref *ref)
6089 struct gdb_ext_thread_info threadinfo;
6091 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
6092 | TAG_MOREDISPLAY | TAG_DISPLAY;
6093 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
6094 display_thread_info (&threadinfo);
6099 threadinfo_test_cmd (char *cmd, int tty)
6101 int athread = SAMPLE_THREAD;
6105 int_to_threadref (&thread, athread);
6106 printf_filtered ("Remote Threadinfo test\n");
6107 if (!get_and_display_threadinfo (&thread))
6108 printf_filtered ("FAIL cannot get thread info\n");
6112 thread_display_step (threadref *ref, void *context)
6114 /* output_threadid(" threadstep ",ref); *//* simple test */
6115 return get_and_display_threadinfo (ref);
6119 threadlist_update_test_cmd (char *cmd, int tty)
6121 printf_filtered ("Remote Threadlist update test\n");
6122 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
6126 init_remote_threadtests (void)
6128 add_com ("tlist", class_obscure, threadlist_test_cmd, _("\
6129 Fetch and print the remote list of thread identifiers, one pkt only"));
6130 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
6131 _("Fetch and display info about one thread"));
6132 add_com ("tset", class_obscure, threadset_test_cmd,
6133 _("Test setting to a different thread"));
6134 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
6135 _("Iterate through updating all remote thread info"));
6136 add_com ("talive", class_obscure, threadalive_test,
6137 _(" Remote thread alive test "));
6142 /* Convert a thread ID to a string. Returns the string in a static
6146 remote_pid_to_str (ptid_t ptid)
6148 static char buf[32];
6150 xsnprintf (buf, sizeof buf, "Thread %d", ptid_get_pid (ptid));
6154 /* Get the address of the thread local variable in OBJFILE which is
6155 stored at OFFSET within the thread local storage for thread PTID. */
6158 remote_get_thread_local_address (ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
6160 if (remote_protocol_packets[PACKET_qGetTLSAddr].support != PACKET_DISABLE)
6162 struct remote_state *rs = get_remote_state ();
6164 enum packet_result result;
6166 strcpy (p, "qGetTLSAddr:");
6168 p += hexnumstr (p, PIDGET (ptid));
6170 p += hexnumstr (p, offset);
6172 p += hexnumstr (p, lm);
6176 getpkt (&rs->buf, &rs->buf_size, 0);
6177 result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTLSAddr]);
6178 if (result == PACKET_OK)
6182 unpack_varlen_hex (rs->buf, &result);
6185 else if (result == PACKET_UNKNOWN)
6186 throw_error (TLS_GENERIC_ERROR,
6187 _("Remote target doesn't support qGetTLSAddr packet"));
6189 throw_error (TLS_GENERIC_ERROR,
6190 _("Remote target failed to process qGetTLSAddr request"));
6193 throw_error (TLS_GENERIC_ERROR,
6194 _("TLS not supported or disabled on this target"));
6199 /* Support for inferring a target description based on the current
6200 architecture and the size of a 'g' packet. While the 'g' packet
6201 can have any size (since optional registers can be left off the
6202 end), some sizes are easily recognizable given knowledge of the
6203 approximate architecture. */
6205 struct remote_g_packet_guess
6208 const struct target_desc *tdesc;
6210 typedef struct remote_g_packet_guess remote_g_packet_guess_s;
6211 DEF_VEC_O(remote_g_packet_guess_s);
6213 struct remote_g_packet_data
6215 VEC(remote_g_packet_guess_s) *guesses;
6218 static struct gdbarch_data *remote_g_packet_data_handle;
6221 remote_g_packet_data_init (struct obstack *obstack)
6223 return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data);
6227 register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes,
6228 const struct target_desc *tdesc)
6230 struct remote_g_packet_data *data
6231 = gdbarch_data (gdbarch, remote_g_packet_data_handle);
6232 struct remote_g_packet_guess new_guess, *guess;
6235 gdb_assert (tdesc != NULL);
6238 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
6240 if (guess->bytes == bytes)
6241 internal_error (__FILE__, __LINE__,
6242 "Duplicate g packet description added for size %d",
6245 new_guess.bytes = bytes;
6246 new_guess.tdesc = tdesc;
6247 VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess);
6250 static const struct target_desc *
6251 remote_read_description (struct target_ops *target)
6253 struct remote_g_packet_data *data
6254 = gdbarch_data (current_gdbarch, remote_g_packet_data_handle);
6256 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
6258 struct remote_g_packet_guess *guess;
6260 int bytes = send_g_packet ();
6263 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
6265 if (guess->bytes == bytes)
6266 return guess->tdesc;
6268 /* We discard the g packet. A minor optimization would be to
6269 hold on to it, and fill the register cache once we have selected
6270 an architecture, but it's too tricky to do safely. */
6277 init_remote_ops (void)
6279 remote_ops.to_shortname = "remote";
6280 remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
6282 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6283 Specify the serial device it is connected to\n\
6284 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6285 remote_ops.to_open = remote_open;
6286 remote_ops.to_close = remote_close;
6287 remote_ops.to_detach = remote_detach;
6288 remote_ops.to_disconnect = remote_disconnect;
6289 remote_ops.to_resume = remote_resume;
6290 remote_ops.to_wait = remote_wait;
6291 remote_ops.to_fetch_registers = remote_fetch_registers;
6292 remote_ops.to_store_registers = remote_store_registers;
6293 remote_ops.to_prepare_to_store = remote_prepare_to_store;
6294 remote_ops.deprecated_xfer_memory = remote_xfer_memory;
6295 remote_ops.to_files_info = remote_files_info;
6296 remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
6297 remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
6298 remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
6299 remote_ops.to_stopped_data_address = remote_stopped_data_address;
6300 remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
6301 remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
6302 remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
6303 remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
6304 remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
6305 remote_ops.to_kill = remote_kill;
6306 remote_ops.to_load = generic_load;
6307 remote_ops.to_mourn_inferior = remote_mourn;
6308 remote_ops.to_thread_alive = remote_thread_alive;
6309 remote_ops.to_find_new_threads = remote_threads_info;
6310 remote_ops.to_pid_to_str = remote_pid_to_str;
6311 remote_ops.to_extra_thread_info = remote_threads_extra_info;
6312 remote_ops.to_stop = remote_stop;
6313 remote_ops.to_xfer_partial = remote_xfer_partial;
6314 remote_ops.to_rcmd = remote_rcmd;
6315 remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
6316 remote_ops.to_stratum = process_stratum;
6317 remote_ops.to_has_all_memory = 1;
6318 remote_ops.to_has_memory = 1;
6319 remote_ops.to_has_stack = 1;
6320 remote_ops.to_has_registers = 1;
6321 remote_ops.to_has_execution = 1;
6322 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
6323 remote_ops.to_magic = OPS_MAGIC;
6324 remote_ops.to_memory_map = remote_memory_map;
6325 remote_ops.to_flash_erase = remote_flash_erase;
6326 remote_ops.to_flash_done = remote_flash_done;
6327 remote_ops.to_read_description = remote_read_description;
6330 /* Set up the extended remote vector by making a copy of the standard
6331 remote vector and adding to it. */
6334 init_extended_remote_ops (void)
6336 extended_remote_ops = remote_ops;
6338 extended_remote_ops.to_shortname = "extended-remote";
6339 extended_remote_ops.to_longname =
6340 "Extended remote serial target in gdb-specific protocol";
6341 extended_remote_ops.to_doc =
6342 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6343 Specify the serial device it is connected to (e.g. /dev/ttya).",
6344 extended_remote_ops.to_open = extended_remote_open;
6345 extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
6346 extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
6350 remote_can_async_p (void)
6352 /* We're async whenever the serial device is. */
6353 return (current_target.to_async_mask_value) && serial_can_async_p (remote_desc);
6357 remote_is_async_p (void)
6359 /* We're async whenever the serial device is. */
6360 return (current_target.to_async_mask_value) && serial_is_async_p (remote_desc);
6363 /* Pass the SERIAL event on and up to the client. One day this code
6364 will be able to delay notifying the client of an event until the
6365 point where an entire packet has been received. */
6367 static void (*async_client_callback) (enum inferior_event_type event_type,
6369 static void *async_client_context;
6370 static serial_event_ftype remote_async_serial_handler;
6373 remote_async_serial_handler (struct serial *scb, void *context)
6375 /* Don't propogate error information up to the client. Instead let
6376 the client find out about the error by querying the target. */
6377 async_client_callback (INF_REG_EVENT, async_client_context);
6381 remote_async (void (*callback) (enum inferior_event_type event_type,
6382 void *context), void *context)
6384 if (current_target.to_async_mask_value == 0)
6385 internal_error (__FILE__, __LINE__,
6386 _("Calling remote_async when async is masked"));
6388 if (callback != NULL)
6390 serial_async (remote_desc, remote_async_serial_handler, NULL);
6391 async_client_callback = callback;
6392 async_client_context = context;
6395 serial_async (remote_desc, NULL, NULL);
6398 /* Target async and target extended-async.
6400 This are temporary targets, until it is all tested. Eventually
6401 async support will be incorporated int the usual 'remote'
6405 init_remote_async_ops (void)
6407 remote_async_ops.to_shortname = "async";
6408 remote_async_ops.to_longname =
6409 "Remote serial target in async version of the gdb-specific protocol";
6410 remote_async_ops.to_doc =
6411 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6412 Specify the serial device it is connected to (e.g. /dev/ttya).";
6413 remote_async_ops.to_open = remote_async_open;
6414 remote_async_ops.to_close = remote_close;
6415 remote_async_ops.to_detach = remote_detach;
6416 remote_async_ops.to_disconnect = remote_disconnect;
6417 remote_async_ops.to_resume = remote_async_resume;
6418 remote_async_ops.to_wait = remote_async_wait;
6419 remote_async_ops.to_fetch_registers = remote_fetch_registers;
6420 remote_async_ops.to_store_registers = remote_store_registers;
6421 remote_async_ops.to_prepare_to_store = remote_prepare_to_store;
6422 remote_async_ops.deprecated_xfer_memory = remote_xfer_memory;
6423 remote_async_ops.to_files_info = remote_files_info;
6424 remote_async_ops.to_insert_breakpoint = remote_insert_breakpoint;
6425 remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
6426 remote_async_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
6427 remote_async_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
6428 remote_async_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
6429 remote_async_ops.to_insert_watchpoint = remote_insert_watchpoint;
6430 remote_async_ops.to_remove_watchpoint = remote_remove_watchpoint;
6431 remote_async_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
6432 remote_async_ops.to_stopped_data_address = remote_stopped_data_address;
6433 remote_async_ops.to_terminal_inferior = remote_async_terminal_inferior;
6434 remote_async_ops.to_terminal_ours = remote_async_terminal_ours;
6435 remote_async_ops.to_kill = remote_async_kill;
6436 remote_async_ops.to_load = generic_load;
6437 remote_async_ops.to_mourn_inferior = remote_async_mourn;
6438 remote_async_ops.to_thread_alive = remote_thread_alive;
6439 remote_async_ops.to_find_new_threads = remote_threads_info;
6440 remote_async_ops.to_pid_to_str = remote_pid_to_str;
6441 remote_async_ops.to_extra_thread_info = remote_threads_extra_info;
6442 remote_async_ops.to_stop = remote_stop;
6443 remote_async_ops.to_xfer_partial = remote_xfer_partial;
6444 remote_async_ops.to_rcmd = remote_rcmd;
6445 remote_async_ops.to_stratum = process_stratum;
6446 remote_async_ops.to_has_all_memory = 1;
6447 remote_async_ops.to_has_memory = 1;
6448 remote_async_ops.to_has_stack = 1;
6449 remote_async_ops.to_has_registers = 1;
6450 remote_async_ops.to_has_execution = 1;
6451 remote_async_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
6452 remote_async_ops.to_can_async_p = remote_can_async_p;
6453 remote_async_ops.to_is_async_p = remote_is_async_p;
6454 remote_async_ops.to_async = remote_async;
6455 remote_async_ops.to_async_mask_value = 1;
6456 remote_async_ops.to_magic = OPS_MAGIC;
6457 remote_async_ops.to_memory_map = remote_memory_map;
6458 remote_async_ops.to_flash_erase = remote_flash_erase;
6459 remote_async_ops.to_flash_done = remote_flash_done;
6460 remote_async_ops.to_read_description = remote_read_description;
6463 /* Set up the async extended remote vector by making a copy of the standard
6464 remote vector and adding to it. */
6467 init_extended_async_remote_ops (void)
6469 extended_async_remote_ops = remote_async_ops;
6471 extended_async_remote_ops.to_shortname = "extended-async";
6472 extended_async_remote_ops.to_longname =
6473 "Extended remote serial target in async gdb-specific protocol";
6474 extended_async_remote_ops.to_doc =
6475 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6476 Specify the serial device it is connected to (e.g. /dev/ttya).",
6477 extended_async_remote_ops.to_open = extended_remote_async_open;
6478 extended_async_remote_ops.to_create_inferior = extended_remote_async_create_inferior;
6479 extended_async_remote_ops.to_mourn_inferior = extended_remote_mourn;
6483 set_remote_cmd (char *args, int from_tty)
6485 help_list (remote_set_cmdlist, "set remote ", -1, gdb_stdout);
6489 show_remote_cmd (char *args, int from_tty)
6491 /* We can't just use cmd_show_list here, because we want to skip
6492 the redundant "show remote Z-packet" and the legacy aliases. */
6493 struct cleanup *showlist_chain;
6494 struct cmd_list_element *list = remote_show_cmdlist;
6496 showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
6497 for (; list != NULL; list = list->next)
6498 if (strcmp (list->name, "Z-packet") == 0)
6500 else if (list->type == not_set_cmd)
6501 /* Alias commands are exactly like the original, except they
6502 don't have the normal type. */
6506 struct cleanup *option_chain
6507 = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
6508 ui_out_field_string (uiout, "name", list->name);
6509 ui_out_text (uiout, ": ");
6510 if (list->type == show_cmd)
6511 do_setshow_command ((char *) NULL, from_tty, list);
6513 cmd_func (list, NULL, from_tty);
6514 /* Close the tuple. */
6515 do_cleanups (option_chain);
6518 /* Close the tuple. */
6519 do_cleanups (showlist_chain);
6523 /* Function to be called whenever a new objfile (shlib) is detected. */
6525 remote_new_objfile (struct objfile *objfile)
6527 if (remote_desc != 0) /* Have a remote connection. */
6528 remote_check_symbols (objfile);
6532 _initialize_remote (void)
6534 struct remote_state *rs;
6536 /* architecture specific data */
6537 remote_gdbarch_data_handle =
6538 gdbarch_data_register_post_init (init_remote_state);
6539 remote_g_packet_data_handle =
6540 gdbarch_data_register_pre_init (remote_g_packet_data_init);
6542 /* Initialize the per-target state. At the moment there is only one
6543 of these, not one per target. Only one target is active at a
6544 time. The default buffer size is unimportant; it will be expanded
6545 whenever a larger buffer is needed. */
6546 rs = get_remote_state_raw ();
6548 rs->buf = xmalloc (rs->buf_size);
6551 add_target (&remote_ops);
6553 init_extended_remote_ops ();
6554 add_target (&extended_remote_ops);
6556 init_remote_async_ops ();
6557 add_target (&remote_async_ops);
6559 init_extended_async_remote_ops ();
6560 add_target (&extended_async_remote_ops);
6562 /* Hook into new objfile notification. */
6563 observer_attach_new_objfile (remote_new_objfile);
6566 init_remote_threadtests ();
6569 /* set/show remote ... */
6571 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
6572 Remote protocol specific variables\n\
6573 Configure various remote-protocol specific variables such as\n\
6574 the packets being used"),
6575 &remote_set_cmdlist, "set remote ",
6576 0 /* allow-unknown */, &setlist);
6577 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
6578 Remote protocol specific variables\n\
6579 Configure various remote-protocol specific variables such as\n\
6580 the packets being used"),
6581 &remote_show_cmdlist, "show remote ",
6582 0 /* allow-unknown */, &showlist);
6584 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
6585 Compare section data on target to the exec file.\n\
6586 Argument is a single section name (default: all loaded sections)."),
6589 add_cmd ("packet", class_maintenance, packet_command, _("\
6590 Send an arbitrary packet to a remote target.\n\
6591 maintenance packet TEXT\n\
6592 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6593 this command sends the string TEXT to the inferior, and displays the\n\
6594 response packet. GDB supplies the initial `$' character, and the\n\
6595 terminating `#' character and checksum."),
6598 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
6599 Set whether to send break if interrupted."), _("\
6600 Show whether to send break if interrupted."), _("\
6601 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6602 NULL, NULL, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6603 &setlist, &showlist);
6605 /* Install commands for configuring memory read/write packets. */
6607 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
6608 Set the maximum number of bytes per memory write packet (deprecated)."),
6610 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
6611 Show the maximum number of bytes per memory write packet (deprecated)."),
6613 add_cmd ("memory-write-packet-size", no_class,
6614 set_memory_write_packet_size, _("\
6615 Set the maximum number of bytes per memory-write packet.\n\
6616 Specify the number of bytes in a packet or 0 (zero) for the\n\
6617 default packet size. The actual limit is further reduced\n\
6618 dependent on the target. Specify ``fixed'' to disable the\n\
6619 further restriction and ``limit'' to enable that restriction."),
6620 &remote_set_cmdlist);
6621 add_cmd ("memory-read-packet-size", no_class,
6622 set_memory_read_packet_size, _("\
6623 Set the maximum number of bytes per memory-read packet.\n\
6624 Specify the number of bytes in a packet or 0 (zero) for the\n\
6625 default packet size. The actual limit is further reduced\n\
6626 dependent on the target. Specify ``fixed'' to disable the\n\
6627 further restriction and ``limit'' to enable that restriction."),
6628 &remote_set_cmdlist);
6629 add_cmd ("memory-write-packet-size", no_class,
6630 show_memory_write_packet_size,
6631 _("Show the maximum number of bytes per memory-write packet."),
6632 &remote_show_cmdlist);
6633 add_cmd ("memory-read-packet-size", no_class,
6634 show_memory_read_packet_size,
6635 _("Show the maximum number of bytes per memory-read packet."),
6636 &remote_show_cmdlist);
6638 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class,
6639 &remote_hw_watchpoint_limit, _("\
6640 Set the maximum number of target hardware watchpoints."), _("\
6641 Show the maximum number of target hardware watchpoints."), _("\
6642 Specify a negative limit for unlimited."),
6643 NULL, NULL, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6644 &remote_set_cmdlist, &remote_show_cmdlist);
6645 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
6646 &remote_hw_breakpoint_limit, _("\
6647 Set the maximum number of target hardware breakpoints."), _("\
6648 Show the maximum number of target hardware breakpoints."), _("\
6649 Specify a negative limit for unlimited."),
6650 NULL, NULL, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6651 &remote_set_cmdlist, &remote_show_cmdlist);
6653 add_setshow_integer_cmd ("remoteaddresssize", class_obscure,
6654 &remote_address_size, _("\
6655 Set the maximum size of the address (in bits) in a memory packet."), _("\
6656 Show the maximum size of the address (in bits) in a memory packet."), NULL,
6658 NULL, /* FIXME: i18n: */
6659 &setlist, &showlist);
6661 add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
6662 "X", "binary-download", 1);
6664 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
6665 "vCont", "verbose-resume", 0);
6667 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
6668 "QPassSignals", "pass-signals", 0);
6670 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
6671 "qSymbol", "symbol-lookup", 0);
6673 add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
6674 "P", "set-register", 1);
6676 add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
6677 "p", "fetch-register", 1);
6679 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
6680 "Z0", "software-breakpoint", 0);
6682 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
6683 "Z1", "hardware-breakpoint", 0);
6685 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
6686 "Z2", "write-watchpoint", 0);
6688 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
6689 "Z3", "read-watchpoint", 0);
6691 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
6692 "Z4", "access-watchpoint", 0);
6694 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
6695 "qXfer:auxv:read", "read-aux-vector", 0);
6697 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features],
6698 "qXfer:features:read", "target-features", 0);
6700 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
6701 "qXfer:libraries:read", "library-info", 0);
6703 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
6704 "qXfer:memory-map:read", "memory-map", 0);
6706 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
6707 "qXfer:spu:read", "read-spu-object", 0);
6709 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
6710 "qXfer:spu:write", "write-spu-object", 0);
6712 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
6713 "qGetTLSAddr", "get-thread-local-storage-address",
6716 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
6717 "qSupported", "supported-packets", 0);
6719 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6720 Z sub-packet has its own set and show commands, but users may
6721 have sets to this variable in their .gdbinit files (or in their
6723 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
6724 &remote_Z_packet_detect, _("\
6725 Set use of remote protocol `Z' packets"), _("\
6726 Show use of remote protocol `Z' packets "), _("\
6727 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6729 set_remote_protocol_Z_packet_cmd,
6730 show_remote_protocol_Z_packet_cmd, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6731 &remote_set_cmdlist, &remote_show_cmdlist);
6733 /* Eventually initialize fileio. See fileio.c */
6734 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);