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"));
2138 free_symfile_segment_data (data);
2142 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
2144 /* This is a temporary kludge to force data and bss to use the same offsets
2145 because that's what nlmconv does now. The real solution requires changes
2146 to the stub and remote.c that I don't have time to do right now. */
2148 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
2149 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
2152 objfile_relocate (symfile_objfile, offs);
2155 /* Stub for catch_exception. */
2158 remote_start_remote (struct ui_out *uiout, void *from_tty_p)
2160 int from_tty = * (int *) from_tty_p;
2162 immediate_quit++; /* Allow user to interrupt it. */
2164 /* Ack any packet which the remote side has already sent. */
2165 serial_write (remote_desc, "+", 1);
2167 /* Let the stub know that we want it to return the thread. */
2170 inferior_ptid = remote_current_thread (inferior_ptid);
2172 get_offsets (); /* Get text, data & bss offsets. */
2174 putpkt ("?"); /* Initiate a query from remote machine. */
2177 start_remote (from_tty); /* Initialize gdb process mechanisms. */
2180 /* Open a connection to a remote debugger.
2181 NAME is the filename used for communication. */
2184 remote_open (char *name, int from_tty)
2186 remote_open_1 (name, from_tty, &remote_ops, 0, 0);
2189 /* Just like remote_open, but with asynchronous support. */
2191 remote_async_open (char *name, int from_tty)
2193 remote_open_1 (name, from_tty, &remote_async_ops, 0, 1);
2196 /* Open a connection to a remote debugger using the extended
2197 remote gdb protocol. NAME is the filename used for communication. */
2200 extended_remote_open (char *name, int from_tty)
2202 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */,
2206 /* Just like extended_remote_open, but with asynchronous support. */
2208 extended_remote_async_open (char *name, int from_tty)
2210 remote_open_1 (name, from_tty, &extended_async_remote_ops,
2211 1 /*extended_p */, 1 /* async_p */);
2214 /* Generic code for opening a connection to a remote target. */
2217 init_all_packet_configs (void)
2220 for (i = 0; i < PACKET_MAX; i++)
2221 update_packet_config (&remote_protocol_packets[i]);
2224 /* Symbol look-up. */
2227 remote_check_symbols (struct objfile *objfile)
2229 struct remote_state *rs = get_remote_state ();
2230 char *msg, *reply, *tmp;
2231 struct minimal_symbol *sym;
2234 if (remote_protocol_packets[PACKET_qSymbol].support == PACKET_DISABLE)
2237 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2238 because we need both at the same time. */
2239 msg = alloca (get_remote_packet_size ());
2241 /* Invite target to request symbol lookups. */
2243 putpkt ("qSymbol::");
2244 getpkt (&rs->buf, &rs->buf_size, 0);
2245 packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
2248 while (strncmp (reply, "qSymbol:", 8) == 0)
2251 end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
2253 sym = lookup_minimal_symbol (msg, NULL, NULL);
2255 xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
2258 CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym);
2260 /* If this is a function address, return the start of code
2261 instead of any data function descriptor. */
2262 sym_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
2266 xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
2267 paddr_nz (sym_addr), &reply[8]);
2271 getpkt (&rs->buf, &rs->buf_size, 0);
2276 static struct serial *
2277 remote_serial_open (char *name)
2279 static int udp_warning = 0;
2281 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2282 of in ser-tcp.c, because it is the remote protocol assuming that the
2283 serial connection is reliable and not the serial connection promising
2285 if (!udp_warning && strncmp (name, "udp:", 4) == 0)
2288 The remote protocol may be unreliable over UDP.\n\
2289 Some events may be lost, rendering further debugging impossible."));
2293 return serial_open (name);
2296 /* This type describes each known response to the qSupported
2298 struct protocol_feature
2300 /* The name of this protocol feature. */
2303 /* The default for this protocol feature. */
2304 enum packet_support default_support;
2306 /* The function to call when this feature is reported, or after
2307 qSupported processing if the feature is not supported.
2308 The first argument points to this structure. The second
2309 argument indicates whether the packet requested support be
2310 enabled, disabled, or probed (or the default, if this function
2311 is being called at the end of processing and this feature was
2312 not reported). The third argument may be NULL; if not NULL, it
2313 is a NUL-terminated string taken from the packet following
2314 this feature's name and an equals sign. */
2315 void (*func) (const struct protocol_feature *, enum packet_support,
2318 /* The corresponding packet for this feature. Only used if
2319 FUNC is remote_supported_packet. */
2324 remote_supported_packet (const struct protocol_feature *feature,
2325 enum packet_support support,
2326 const char *argument)
2330 warning (_("Remote qSupported response supplied an unexpected value for"
2331 " \"%s\"."), feature->name);
2335 if (remote_protocol_packets[feature->packet].support
2336 == PACKET_SUPPORT_UNKNOWN)
2337 remote_protocol_packets[feature->packet].support = support;
2341 remote_packet_size (const struct protocol_feature *feature,
2342 enum packet_support support, const char *value)
2344 struct remote_state *rs = get_remote_state ();
2349 if (support != PACKET_ENABLE)
2352 if (value == NULL || *value == '\0')
2354 warning (_("Remote target reported \"%s\" without a size."),
2360 packet_size = strtol (value, &value_end, 16);
2361 if (errno != 0 || *value_end != '\0' || packet_size < 0)
2363 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2364 feature->name, value);
2368 if (packet_size > MAX_REMOTE_PACKET_SIZE)
2370 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2371 packet_size, MAX_REMOTE_PACKET_SIZE);
2372 packet_size = MAX_REMOTE_PACKET_SIZE;
2375 /* Record the new maximum packet size. */
2376 rs->explicit_packet_size = packet_size;
2379 static struct protocol_feature remote_protocol_features[] = {
2380 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
2381 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
2382 PACKET_qXfer_auxv },
2383 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
2384 PACKET_qXfer_features },
2385 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
2386 PACKET_qXfer_libraries },
2387 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
2388 PACKET_qXfer_memory_map },
2389 { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
2390 PACKET_qXfer_spu_read },
2391 { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
2392 PACKET_qXfer_spu_write },
2393 { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
2394 PACKET_QPassSignals },
2398 remote_query_supported (void)
2400 struct remote_state *rs = get_remote_state ();
2403 unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
2405 /* The packet support flags are handled differently for this packet
2406 than for most others. We treat an error, a disabled packet, and
2407 an empty response identically: any features which must be reported
2408 to be used will be automatically disabled. An empty buffer
2409 accomplishes this, since that is also the representation for a list
2410 containing no features. */
2413 if (remote_protocol_packets[PACKET_qSupported].support != PACKET_DISABLE)
2415 putpkt ("qSupported");
2416 getpkt (&rs->buf, &rs->buf_size, 0);
2418 /* If an error occured, warn, but do not return - just reset the
2419 buffer to empty and go on to disable features. */
2420 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
2423 warning (_("Remote failure reply: %s"), rs->buf);
2428 memset (seen, 0, sizeof (seen));
2433 enum packet_support is_supported;
2434 char *p, *end, *name_end, *value;
2436 /* First separate out this item from the rest of the packet. If
2437 there's another item after this, we overwrite the separator
2438 (terminated strings are much easier to work with). */
2440 end = strchr (p, ';');
2443 end = p + strlen (p);
2453 warning (_("empty item in \"qSupported\" response"));
2458 name_end = strchr (p, '=');
2461 /* This is a name=value entry. */
2462 is_supported = PACKET_ENABLE;
2463 value = name_end + 1;
2472 is_supported = PACKET_ENABLE;
2476 is_supported = PACKET_DISABLE;
2480 is_supported = PACKET_SUPPORT_UNKNOWN;
2484 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p);
2490 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
2491 if (strcmp (remote_protocol_features[i].name, p) == 0)
2493 const struct protocol_feature *feature;
2496 feature = &remote_protocol_features[i];
2497 feature->func (feature, is_supported, value);
2502 /* If we increased the packet size, make sure to increase the global
2503 buffer size also. We delay this until after parsing the entire
2504 qSupported packet, because this is the same buffer we were
2506 if (rs->buf_size < rs->explicit_packet_size)
2508 rs->buf_size = rs->explicit_packet_size;
2509 rs->buf = xrealloc (rs->buf, rs->buf_size);
2512 /* Handle the defaults for unmentioned features. */
2513 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
2516 const struct protocol_feature *feature;
2518 feature = &remote_protocol_features[i];
2519 feature->func (feature, feature->default_support, NULL);
2525 remote_open_1 (char *name, int from_tty, struct target_ops *target,
2526 int extended_p, int async_p)
2528 struct remote_state *rs = get_remote_state ();
2530 error (_("To open a remote debug connection, you need to specify what\n"
2531 "serial device is attached to the remote system\n"
2532 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2534 /* See FIXME above. */
2536 wait_forever_enabled_p = 1;
2538 target_preopen (from_tty);
2540 unpush_target (target);
2542 /* Make sure we send the passed signals list the next time we resume. */
2543 xfree (last_pass_packet);
2544 last_pass_packet = NULL;
2546 remote_fileio_reset ();
2547 reopen_exec_file ();
2550 remote_desc = remote_serial_open (name);
2552 perror_with_name (name);
2554 if (baud_rate != -1)
2556 if (serial_setbaudrate (remote_desc, baud_rate))
2558 /* The requested speed could not be set. Error out to
2559 top level after closing remote_desc. Take care to
2560 set remote_desc to NULL to avoid closing remote_desc
2562 serial_close (remote_desc);
2564 perror_with_name (name);
2568 serial_raw (remote_desc);
2570 /* If there is something sitting in the buffer we might take it as a
2571 response to a command, which would be bad. */
2572 serial_flush_input (remote_desc);
2576 puts_filtered ("Remote debugging using ");
2577 puts_filtered (name);
2578 puts_filtered ("\n");
2580 push_target (target); /* Switch to using remote target now. */
2582 /* Reset the target state; these things will be queried either by
2583 remote_query_supported or as they are needed. */
2584 init_all_packet_configs ();
2585 rs->explicit_packet_size = 0;
2587 general_thread = -2;
2588 continue_thread = -2;
2590 /* Probe for ability to use "ThreadInfo" query, as required. */
2591 use_threadinfo_query = 1;
2592 use_threadextra_query = 1;
2594 /* The first packet we send to the target is the optional "supported
2595 packets" request. If the target can answer this, it will tell us
2596 which later probes to skip. */
2597 remote_query_supported ();
2599 /* Next, if the target can specify a description, read it. We do
2600 this before anything involving memory or registers. */
2601 target_find_description ();
2603 /* Without this, some commands which require an active target (such
2604 as kill) won't work. This variable serves (at least) double duty
2605 as both the pid of the target process (if it has such), and as a
2606 flag indicating that a target is active. These functions should
2607 be split out into seperate variables, especially since GDB will
2608 someday have a notion of debugging several processes. */
2610 inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
2614 /* With this target we start out by owning the terminal. */
2615 remote_async_terminal_ours_p = 1;
2617 /* FIXME: cagney/1999-09-23: During the initial connection it is
2618 assumed that the target is already ready and able to respond to
2619 requests. Unfortunately remote_start_remote() eventually calls
2620 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2621 around this. Eventually a mechanism that allows
2622 wait_for_inferior() to expect/get timeouts will be
2624 wait_forever_enabled_p = 0;
2627 /* First delete any symbols previously loaded from shared libraries. */
2628 no_shared_libraries (NULL, 0);
2630 /* Start the remote connection. If error() or QUIT, discard this
2631 target (we'd otherwise be in an inconsistent state) and then
2632 propogate the error on up the exception chain. This ensures that
2633 the caller doesn't stumble along blindly assuming that the
2634 function succeeded. The CLI doesn't have this problem but other
2635 UI's, such as MI do.
2637 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2638 this function should return an error indication letting the
2639 caller restore the previous state. Unfortunately the command
2640 ``target remote'' is directly wired to this function making that
2641 impossible. On a positive note, the CLI side of this problem has
2642 been fixed - the function set_cmd_context() makes it possible for
2643 all the ``target ....'' commands to share a common callback
2644 function. See cli-dump.c. */
2646 struct gdb_exception ex
2647 = catch_exception (uiout, remote_start_remote, &from_tty,
2653 wait_forever_enabled_p = 1;
2654 throw_exception (ex);
2659 wait_forever_enabled_p = 1;
2663 /* Tell the remote that we are using the extended protocol. */
2665 getpkt (&rs->buf, &rs->buf_size, 0);
2668 if (exec_bfd) /* No use without an exec file. */
2669 remote_check_symbols (symfile_objfile);
2672 /* This takes a program previously attached to and detaches it. After
2673 this is done, GDB can be used to debug some other program. We
2674 better not have left any breakpoints in the target program or it'll
2675 die when it hits one. */
2678 remote_detach (char *args, int from_tty)
2680 struct remote_state *rs = get_remote_state ();
2683 error (_("Argument given to \"detach\" when remotely debugging."));
2685 /* Tell the remote target to detach. */
2686 strcpy (rs->buf, "D");
2688 getpkt (&rs->buf, &rs->buf_size, 0);
2690 if (rs->buf[0] == 'E')
2691 error (_("Can't detach process."));
2693 /* Unregister the file descriptor from the event loop. */
2694 if (target_is_async_p ())
2695 serial_async (remote_desc, NULL, 0);
2697 target_mourn_inferior ();
2699 puts_filtered ("Ending remote debugging.\n");
2702 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2705 remote_disconnect (struct target_ops *target, char *args, int from_tty)
2708 error (_("Argument given to \"detach\" when remotely debugging."));
2710 /* Unregister the file descriptor from the event loop. */
2711 if (target_is_async_p ())
2712 serial_async (remote_desc, NULL, 0);
2714 target_mourn_inferior ();
2716 puts_filtered ("Ending remote debugging.\n");
2719 /* Convert hex digit A to a number. */
2724 if (a >= '0' && a <= '9')
2726 else if (a >= 'a' && a <= 'f')
2727 return a - 'a' + 10;
2728 else if (a >= 'A' && a <= 'F')
2729 return a - 'A' + 10;
2731 error (_("Reply contains invalid hex digit %d"), a);
2735 hex2bin (const char *hex, gdb_byte *bin, int count)
2739 for (i = 0; i < count; i++)
2741 if (hex[0] == 0 || hex[1] == 0)
2743 /* Hex string is short, or of uneven length.
2744 Return the count that has been converted so far. */
2747 *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
2753 /* Convert number NIB to a hex digit. */
2761 return 'a' + nib - 10;
2765 bin2hex (const gdb_byte *bin, char *hex, int count)
2768 /* May use a length, or a nul-terminated string as input. */
2770 count = strlen ((char *) bin);
2772 for (i = 0; i < count; i++)
2774 *hex++ = tohex ((*bin >> 4) & 0xf);
2775 *hex++ = tohex (*bin++ & 0xf);
2781 /* Check for the availability of vCont. This function should also check
2785 remote_vcont_probe (struct remote_state *rs)
2789 strcpy (rs->buf, "vCont?");
2791 getpkt (&rs->buf, &rs->buf_size, 0);
2794 /* Make sure that the features we assume are supported. */
2795 if (strncmp (buf, "vCont", 5) == 0)
2798 int support_s, support_S, support_c, support_C;
2804 while (p && *p == ';')
2807 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
2809 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
2811 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
2813 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
2816 p = strchr (p, ';');
2819 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2820 BUF will make packet_ok disable the packet. */
2821 if (!support_s || !support_S || !support_c || !support_C)
2825 packet_ok (buf, &remote_protocol_packets[PACKET_vCont]);
2828 /* Resume the remote inferior by using a "vCont" packet. The thread
2829 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2830 resumed thread should be single-stepped and/or signalled. If PTID's
2831 PID is -1, then all threads are resumed; the thread to be stepped and/or
2832 signalled is given in the global INFERIOR_PTID. This function returns
2833 non-zero iff it resumes the inferior.
2835 This function issues a strict subset of all possible vCont commands at the
2839 remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal)
2841 struct remote_state *rs = get_remote_state ();
2842 int pid = PIDGET (ptid);
2843 char *buf = NULL, *outbuf;
2844 struct cleanup *old_cleanup;
2846 if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
2847 remote_vcont_probe (rs);
2849 if (remote_protocol_packets[PACKET_vCont].support == PACKET_DISABLE)
2852 /* If we could generate a wider range of packets, we'd have to worry
2853 about overflowing BUF. Should there be a generic
2854 "multi-part-packet" packet? */
2856 if (PIDGET (inferior_ptid) == MAGIC_NULL_PID)
2858 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2859 don't have any PID numbers the inferior will understand. Make sure
2860 to only send forms that do not specify a PID. */
2861 if (step && siggnal != TARGET_SIGNAL_0)
2862 outbuf = xstrprintf ("vCont;S%02x", siggnal);
2864 outbuf = xstrprintf ("vCont;s");
2865 else if (siggnal != TARGET_SIGNAL_0)
2866 outbuf = xstrprintf ("vCont;C%02x", siggnal);
2868 outbuf = xstrprintf ("vCont;c");
2872 /* Resume all threads, with preference for INFERIOR_PTID. */
2873 if (step && siggnal != TARGET_SIGNAL_0)
2874 outbuf = xstrprintf ("vCont;S%02x:%x;c", siggnal,
2875 PIDGET (inferior_ptid));
2877 outbuf = xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid));
2878 else if (siggnal != TARGET_SIGNAL_0)
2879 outbuf = xstrprintf ("vCont;C%02x:%x;c", siggnal,
2880 PIDGET (inferior_ptid));
2882 outbuf = xstrprintf ("vCont;c");
2886 /* Scheduler locking; resume only PTID. */
2887 if (step && siggnal != TARGET_SIGNAL_0)
2888 outbuf = xstrprintf ("vCont;S%02x:%x", siggnal, pid);
2890 outbuf = xstrprintf ("vCont;s:%x", pid);
2891 else if (siggnal != TARGET_SIGNAL_0)
2892 outbuf = xstrprintf ("vCont;C%02x:%x", siggnal, pid);
2894 outbuf = xstrprintf ("vCont;c:%x", pid);
2897 gdb_assert (outbuf && strlen (outbuf) < get_remote_packet_size ());
2898 old_cleanup = make_cleanup (xfree, outbuf);
2902 do_cleanups (old_cleanup);
2907 /* Tell the remote machine to resume. */
2909 static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
2911 static int last_sent_step;
2914 remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
2916 struct remote_state *rs = get_remote_state ();
2918 int pid = PIDGET (ptid);
2920 last_sent_signal = siggnal;
2921 last_sent_step = step;
2923 /* A hook for when we need to do something at the last moment before
2925 if (deprecated_target_resume_hook)
2926 (*deprecated_target_resume_hook) ();
2928 /* Update the inferior on signals to silently pass, if they've changed. */
2929 remote_pass_signals ();
2931 /* The vCont packet doesn't need to specify threads via Hc. */
2932 if (remote_vcont_resume (ptid, step, siggnal))
2935 /* All other supported resume packets do use Hc, so call set_thread. */
2937 set_thread (0, 0); /* Run any thread. */
2939 set_thread (pid, 0); /* Run this thread. */
2942 if (siggnal != TARGET_SIGNAL_0)
2944 buf[0] = step ? 'S' : 'C';
2945 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
2946 buf[2] = tohex (((int) siggnal) & 0xf);
2950 strcpy (buf, step ? "s" : "c");
2955 /* Same as remote_resume, but with async support. */
2957 remote_async_resume (ptid_t ptid, int step, enum target_signal siggnal)
2959 remote_resume (ptid, step, siggnal);
2961 /* We are about to start executing the inferior, let's register it
2962 with the event loop. NOTE: this is the one place where all the
2963 execution commands end up. We could alternatively do this in each
2964 of the execution commands in infcmd.c. */
2965 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2966 into infcmd.c in order to allow inferior function calls to work
2967 NOT asynchronously. */
2968 if (target_can_async_p ())
2969 target_async (inferior_event_handler, 0);
2970 /* Tell the world that the target is now executing. */
2971 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2972 this? Instead, should the client of target just assume (for
2973 async targets) that the target is going to start executing? Is
2974 this information already found in the continuation block? */
2975 if (target_is_async_p ())
2976 target_executing = 1;
2980 /* Set up the signal handler for SIGINT, while the target is
2981 executing, ovewriting the 'regular' SIGINT signal handler. */
2983 initialize_sigint_signal_handler (void)
2985 sigint_remote_token =
2986 create_async_signal_handler (async_remote_interrupt, NULL);
2987 signal (SIGINT, handle_remote_sigint);
2990 /* Signal handler for SIGINT, while the target is executing. */
2992 handle_remote_sigint (int sig)
2994 signal (sig, handle_remote_sigint_twice);
2995 sigint_remote_twice_token =
2996 create_async_signal_handler (async_remote_interrupt_twice, NULL);
2997 mark_async_signal_handler_wrapper (sigint_remote_token);
3000 /* Signal handler for SIGINT, installed after SIGINT has already been
3001 sent once. It will take effect the second time that the user sends
3004 handle_remote_sigint_twice (int sig)
3006 signal (sig, handle_sigint);
3007 sigint_remote_twice_token =
3008 create_async_signal_handler (inferior_event_handler_wrapper, NULL);
3009 mark_async_signal_handler_wrapper (sigint_remote_twice_token);
3012 /* Perform the real interruption of the target execution, in response
3015 async_remote_interrupt (gdb_client_data arg)
3018 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
3023 /* Perform interrupt, if the first attempt did not succeed. Just give
3024 up on the target alltogether. */
3026 async_remote_interrupt_twice (gdb_client_data arg)
3029 fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
3030 /* Do something only if the target was not killed by the previous
3032 if (target_executing)
3035 signal (SIGINT, handle_remote_sigint);
3039 /* Reinstall the usual SIGINT handlers, after the target has
3042 cleanup_sigint_signal_handler (void *dummy)
3044 signal (SIGINT, handle_sigint);
3045 if (sigint_remote_twice_token)
3046 delete_async_signal_handler (&sigint_remote_twice_token);
3047 if (sigint_remote_token)
3048 delete_async_signal_handler (&sigint_remote_token);
3051 /* Send ^C to target to halt it. Target will respond, and send us a
3053 static void (*ofunc) (int);
3055 /* The command line interface's stop routine. This function is installed
3056 as a signal handler for SIGINT. The first time a user requests a
3057 stop, we call remote_stop to send a break or ^C. If there is no
3058 response from the target (it didn't stop when the user requested it),
3059 we ask the user if he'd like to detach from the target. */
3061 remote_interrupt (int signo)
3063 /* If this doesn't work, try more severe steps. */
3064 signal (signo, remote_interrupt_twice);
3067 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
3072 /* The user typed ^C twice. */
3075 remote_interrupt_twice (int signo)
3077 signal (signo, ofunc);
3079 signal (signo, remote_interrupt);
3082 /* This is the generic stop called via the target vector. When a target
3083 interrupt is requested, either by the command line or the GUI, we
3084 will eventually end up here. */
3088 /* Send a break or a ^C, depending on user preference. */
3090 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
3093 serial_send_break (remote_desc);
3095 serial_write (remote_desc, "\003", 1);
3098 /* Ask the user what to do when an interrupt is received. */
3101 interrupt_query (void)
3103 target_terminal_ours ();
3105 if (query ("Interrupted while waiting for the program.\n\
3106 Give up (and stop debugging it)? "))
3108 target_mourn_inferior ();
3109 deprecated_throw_reason (RETURN_QUIT);
3112 target_terminal_inferior ();
3115 /* Enable/disable target terminal ownership. Most targets can use
3116 terminal groups to control terminal ownership. Remote targets are
3117 different in that explicit transfer of ownership to/from GDB/target
3121 remote_async_terminal_inferior (void)
3123 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3124 sync_execution here. This function should only be called when
3125 GDB is resuming the inferior in the forground. A background
3126 resume (``run&'') should leave GDB in control of the terminal and
3127 consequently should not call this code. */
3128 if (!sync_execution)
3130 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3131 calls target_terminal_*() idenpotent. The event-loop GDB talking
3132 to an asynchronous target with a synchronous command calls this
3133 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3134 stops trying to transfer the terminal to the target when it
3135 shouldn't this guard can go away. */
3136 if (!remote_async_terminal_ours_p)
3138 delete_file_handler (input_fd);
3139 remote_async_terminal_ours_p = 0;
3140 initialize_sigint_signal_handler ();
3141 /* NOTE: At this point we could also register our selves as the
3142 recipient of all input. Any characters typed could then be
3143 passed on down to the target. */
3147 remote_async_terminal_ours (void)
3149 /* See FIXME in remote_async_terminal_inferior. */
3150 if (!sync_execution)
3152 /* See FIXME in remote_async_terminal_inferior. */
3153 if (remote_async_terminal_ours_p)
3155 cleanup_sigint_signal_handler (NULL);
3156 add_file_handler (input_fd, stdin_event_handler, 0);
3157 remote_async_terminal_ours_p = 1;
3160 /* If nonzero, ignore the next kill. */
3165 remote_console_output (char *msg)
3169 for (p = msg; p[0] && p[1]; p += 2)
3172 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
3175 fputs_unfiltered (tb, gdb_stdtarg);
3177 gdb_flush (gdb_stdtarg);
3180 /* Wait until the remote machine stops, then return,
3181 storing status in STATUS just as `wait' would.
3182 Returns "pid", which in the case of a multi-threaded
3183 remote OS, is the thread-id. */
3186 remote_wait (ptid_t ptid, struct target_waitstatus *status)
3188 struct remote_state *rs = get_remote_state ();
3189 struct remote_arch_state *rsa = get_remote_arch_state ();
3190 ULONGEST thread_num = -1;
3192 int solibs_changed = 0;
3194 status->kind = TARGET_WAITKIND_EXITED;
3195 status->value.integer = 0;
3201 ofunc = signal (SIGINT, remote_interrupt);
3202 getpkt (&rs->buf, &rs->buf_size, 1);
3203 signal (SIGINT, ofunc);
3207 /* This is a hook for when we need to do something (perhaps the
3208 collection of trace data) every time the target stops. */
3209 if (deprecated_target_wait_loop_hook)
3210 (*deprecated_target_wait_loop_hook) ();
3212 remote_stopped_by_watchpoint_p = 0;
3216 case 'E': /* Error of some sort. */
3217 warning (_("Remote failure reply: %s"), buf);
3219 case 'F': /* File-I/O request. */
3220 remote_fileio_request (buf);
3222 case 'T': /* Status with PC, SP, FP, ... */
3224 gdb_byte regs[MAX_REGISTER_SIZE];
3226 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3227 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3229 n... = register number
3230 r... = register contents
3232 p = &buf[3]; /* after Txx */
3241 /* If the packet contains a register number save it in
3242 pnum and set p1 to point to the character following
3243 it. Otherwise p1 points to p. */
3245 /* If this packet is an awatch packet, don't parse the
3246 'a' as a register number. */
3248 if (strncmp (p, "awatch", strlen("awatch")) != 0)
3250 /* Read the ``P'' register number. */
3251 pnum = strtol (p, &p_temp, 16);
3257 if (p1 == p) /* No register number present here. */
3259 p1 = strchr (p, ':');
3261 error (_("Malformed packet(a) (missing colon): %s\n\
3264 if (strncmp (p, "thread", p1 - p) == 0)
3266 p_temp = unpack_varlen_hex (++p1, &thread_num);
3267 record_currthread (thread_num);
3270 else if ((strncmp (p, "watch", p1 - p) == 0)
3271 || (strncmp (p, "rwatch", p1 - p) == 0)
3272 || (strncmp (p, "awatch", p1 - p) == 0))
3274 remote_stopped_by_watchpoint_p = 1;
3275 p = unpack_varlen_hex (++p1, &addr);
3276 remote_watch_data_address = (CORE_ADDR)addr;
3278 else if (strncmp (p, "library", p1 - p) == 0)
3282 while (*p_temp && *p_temp != ';')
3290 /* Silently skip unknown optional info. */
3291 p_temp = strchr (p1 + 1, ';');
3298 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
3302 error (_("Malformed packet(b) (missing colon): %s\n\
3307 error (_("Remote sent bad register number %s: %s\n\
3309 phex_nz (pnum, 0), p, buf);
3311 fieldsize = hex2bin (p, regs,
3312 register_size (current_gdbarch,
3315 if (fieldsize < register_size (current_gdbarch,
3317 warning (_("Remote reply is too short: %s"), buf);
3318 regcache_raw_supply (get_current_regcache (),
3323 error (_("Remote register badly formatted: %s\nhere: %s"),
3328 case 'S': /* Old style status, just signal only. */
3330 status->kind = TARGET_WAITKIND_LOADED;
3333 status->kind = TARGET_WAITKIND_STOPPED;
3334 status->value.sig = (enum target_signal)
3335 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3340 thread_num = strtol ((const char *) &buf[4], NULL, 16);
3341 record_currthread (thread_num);
3344 case 'W': /* Target exited. */
3346 /* The remote process exited. */
3347 status->kind = TARGET_WAITKIND_EXITED;
3348 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3352 status->kind = TARGET_WAITKIND_SIGNALLED;
3353 status->value.sig = (enum target_signal)
3354 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3358 case 'O': /* Console output. */
3359 remote_console_output (buf + 1);
3362 if (last_sent_signal != TARGET_SIGNAL_0)
3364 /* Zero length reply means that we tried 'S' or 'C' and
3365 the remote system doesn't support it. */
3366 target_terminal_ours_for_output ();
3368 ("Can't send signals to this remote system. %s not sent.\n",
3369 target_signal_to_name (last_sent_signal));
3370 last_sent_signal = TARGET_SIGNAL_0;
3371 target_terminal_inferior ();
3373 strcpy ((char *) buf, last_sent_step ? "s" : "c");
3374 putpkt ((char *) buf);
3377 /* else fallthrough */
3379 warning (_("Invalid remote reply: %s"), buf);
3384 if (thread_num != -1)
3386 return pid_to_ptid (thread_num);
3388 return inferior_ptid;
3391 /* Async version of remote_wait. */
3393 remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
3395 struct remote_state *rs = get_remote_state ();
3396 struct remote_arch_state *rsa = get_remote_arch_state ();
3397 ULONGEST thread_num = -1;
3399 int solibs_changed = 0;
3401 status->kind = TARGET_WAITKIND_EXITED;
3402 status->value.integer = 0;
3404 remote_stopped_by_watchpoint_p = 0;
3410 if (!target_is_async_p ())
3411 ofunc = signal (SIGINT, remote_interrupt);
3412 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3413 _never_ wait for ever -> test on target_is_async_p().
3414 However, before we do that we need to ensure that the caller
3415 knows how to take the target into/out of async mode. */
3416 getpkt (&rs->buf, &rs->buf_size, wait_forever_enabled_p);
3417 if (!target_is_async_p ())
3418 signal (SIGINT, ofunc);
3422 /* This is a hook for when we need to do something (perhaps the
3423 collection of trace data) every time the target stops. */
3424 if (deprecated_target_wait_loop_hook)
3425 (*deprecated_target_wait_loop_hook) ();
3429 case 'E': /* Error of some sort. */
3430 warning (_("Remote failure reply: %s"), buf);
3432 case 'F': /* File-I/O request. */
3433 remote_fileio_request (buf);
3435 case 'T': /* Status with PC, SP, FP, ... */
3437 gdb_byte regs[MAX_REGISTER_SIZE];
3439 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3440 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3442 n... = register number
3443 r... = register contents
3445 p = &buf[3]; /* after Txx */
3454 /* If the packet contains a register number, save it
3455 in pnum and set p1 to point to the character
3456 following it. Otherwise p1 points to p. */
3458 /* If this packet is an awatch packet, don't parse the 'a'
3459 as a register number. */
3461 if (strncmp (p, "awatch", strlen("awatch")) != 0)
3463 /* Read the register number. */
3464 pnum = strtol (p, &p_temp, 16);
3470 if (p1 == p) /* No register number present here. */
3472 p1 = strchr (p, ':');
3474 error (_("Malformed packet(a) (missing colon): %s\n\
3477 if (strncmp (p, "thread", p1 - p) == 0)
3479 p_temp = unpack_varlen_hex (++p1, &thread_num);
3480 record_currthread (thread_num);
3483 else if ((strncmp (p, "watch", p1 - p) == 0)
3484 || (strncmp (p, "rwatch", p1 - p) == 0)
3485 || (strncmp (p, "awatch", p1 - p) == 0))
3487 remote_stopped_by_watchpoint_p = 1;
3488 p = unpack_varlen_hex (++p1, &addr);
3489 remote_watch_data_address = (CORE_ADDR)addr;
3491 else if (strncmp (p, "library", p1 - p) == 0)
3495 while (*p_temp && *p_temp != ';')
3503 /* Silently skip unknown optional info. */
3504 p_temp = strchr (p1 + 1, ';');
3512 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
3515 error (_("Malformed packet(b) (missing colon): %s\n\
3520 error (_("Remote sent bad register number %ld: %s\n\
3524 fieldsize = hex2bin (p, regs,
3525 register_size (current_gdbarch,
3528 if (fieldsize < register_size (current_gdbarch,
3530 warning (_("Remote reply is too short: %s"), buf);
3531 regcache_raw_supply (get_current_regcache (),
3536 error (_("Remote register badly formatted: %s\nhere: %s"),
3541 case 'S': /* Old style status, just signal only. */
3543 status->kind = TARGET_WAITKIND_LOADED;
3546 status->kind = TARGET_WAITKIND_STOPPED;
3547 status->value.sig = (enum target_signal)
3548 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3553 thread_num = strtol ((const char *) &buf[4], NULL, 16);
3554 record_currthread (thread_num);
3557 case 'W': /* Target exited. */
3559 /* The remote process exited. */
3560 status->kind = TARGET_WAITKIND_EXITED;
3561 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3565 status->kind = TARGET_WAITKIND_SIGNALLED;
3566 status->value.sig = (enum target_signal)
3567 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3571 case 'O': /* Console output. */
3572 remote_console_output (buf + 1);
3573 /* Return immediately to the event loop. The event loop will
3574 still be waiting on the inferior afterwards. */
3575 status->kind = TARGET_WAITKIND_IGNORE;
3578 if (last_sent_signal != TARGET_SIGNAL_0)
3580 /* Zero length reply means that we tried 'S' or 'C' and
3581 the remote system doesn't support it. */
3582 target_terminal_ours_for_output ();
3584 ("Can't send signals to this remote system. %s not sent.\n",
3585 target_signal_to_name (last_sent_signal));
3586 last_sent_signal = TARGET_SIGNAL_0;
3587 target_terminal_inferior ();
3589 strcpy ((char *) buf, last_sent_step ? "s" : "c");
3590 putpkt ((char *) buf);
3593 /* else fallthrough */
3595 warning (_("Invalid remote reply: %s"), buf);
3600 if (thread_num != -1)
3602 return pid_to_ptid (thread_num);
3604 return inferior_ptid;
3607 /* Fetch a single register using a 'p' packet. */
3610 fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
3612 struct remote_state *rs = get_remote_state ();
3614 char regp[MAX_REGISTER_SIZE];
3617 if (remote_protocol_packets[PACKET_p].support == PACKET_DISABLE)
3620 if (reg->pnum == -1)
3625 p += hexnumstr (p, reg->pnum);
3627 remote_send (&rs->buf, &rs->buf_size);
3631 switch (packet_ok (buf, &remote_protocol_packets[PACKET_p]))
3635 case PACKET_UNKNOWN:
3638 error (_("Could not fetch register \"%s\""),
3639 gdbarch_register_name (current_gdbarch, reg->regnum));
3642 /* If this register is unfetchable, tell the regcache. */
3645 regcache_raw_supply (regcache, reg->regnum, NULL);
3649 /* Otherwise, parse and supply the value. */
3655 error (_("fetch_register_using_p: early buf termination"));
3657 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
3660 regcache_raw_supply (regcache, reg->regnum, regp);
3664 /* Fetch the registers included in the target's 'g' packet. */
3667 send_g_packet (void)
3669 struct remote_state *rs = get_remote_state ();
3674 sprintf (rs->buf, "g");
3675 remote_send (&rs->buf, &rs->buf_size);
3677 /* We can get out of synch in various cases. If the first character
3678 in the buffer is not a hex character, assume that has happened
3679 and try to fetch another packet to read. */
3680 while ((rs->buf[0] < '0' || rs->buf[0] > '9')
3681 && (rs->buf[0] < 'A' || rs->buf[0] > 'F')
3682 && (rs->buf[0] < 'a' || rs->buf[0] > 'f')
3683 && rs->buf[0] != 'x') /* New: unavailable register value. */
3686 fprintf_unfiltered (gdb_stdlog,
3687 "Bad register packet; fetching a new packet\n");
3688 getpkt (&rs->buf, &rs->buf_size, 0);
3691 buf_len = strlen (rs->buf);
3693 /* Sanity check the received packet. */
3694 if (buf_len % 2 != 0)
3695 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf);
3701 process_g_packet (struct regcache *regcache)
3703 struct remote_state *rs = get_remote_state ();
3704 struct remote_arch_state *rsa = get_remote_arch_state ();
3709 buf_len = strlen (rs->buf);
3711 /* Further sanity checks, with knowledge of the architecture. */
3712 if (buf_len > 2 * rsa->sizeof_g_packet)
3713 error (_("Remote 'g' packet reply is too long: %s"), rs->buf);
3715 /* Save the size of the packet sent to us by the target. It is used
3716 as a heuristic when determining the max size of packets that the
3717 target can safely receive. */
3718 if (rsa->actual_register_packet_size == 0)
3719 rsa->actual_register_packet_size = buf_len;
3721 /* If this is smaller than we guessed the 'g' packet would be,
3722 update our records. A 'g' reply that doesn't include a register's
3723 value implies either that the register is not available, or that
3724 the 'p' packet must be used. */
3725 if (buf_len < 2 * rsa->sizeof_g_packet)
3727 rsa->sizeof_g_packet = buf_len / 2;
3729 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3731 if (rsa->regs[i].pnum == -1)
3734 if (rsa->regs[i].offset >= rsa->sizeof_g_packet)
3735 rsa->regs[i].in_g_packet = 0;
3737 rsa->regs[i].in_g_packet = 1;
3741 regs = alloca (rsa->sizeof_g_packet);
3743 /* Unimplemented registers read as all bits zero. */
3744 memset (regs, 0, rsa->sizeof_g_packet);
3746 /* Reply describes registers byte by byte, each byte encoded as two
3747 hex characters. Suck them all up, then supply them to the
3748 register cacheing/storage mechanism. */
3751 for (i = 0; i < rsa->sizeof_g_packet; i++)
3753 if (p[0] == 0 || p[1] == 0)
3754 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3755 internal_error (__FILE__, __LINE__,
3756 "unexpected end of 'g' packet reply");
3758 if (p[0] == 'x' && p[1] == 'x')
3759 regs[i] = 0; /* 'x' */
3761 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
3767 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3769 struct packet_reg *r = &rsa->regs[i];
3772 if (r->offset * 2 >= strlen (rs->buf))
3773 /* This shouldn't happen - we adjusted in_g_packet above. */
3774 internal_error (__FILE__, __LINE__,
3775 "unexpected end of 'g' packet reply");
3776 else if (rs->buf[r->offset * 2] == 'x')
3778 gdb_assert (r->offset * 2 < strlen (rs->buf));
3779 /* The register isn't available, mark it as such (at
3780 the same time setting the value to zero). */
3781 regcache_raw_supply (regcache, r->regnum, NULL);
3784 regcache_raw_supply (regcache, r->regnum,
3792 fetch_registers_using_g (struct regcache *regcache)
3795 process_g_packet (regcache);
3799 remote_fetch_registers (struct regcache *regcache, int regnum)
3801 struct remote_state *rs = get_remote_state ();
3802 struct remote_arch_state *rsa = get_remote_arch_state ();
3805 set_thread (PIDGET (inferior_ptid), 1);
3809 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
3810 gdb_assert (reg != NULL);
3812 /* If this register might be in the 'g' packet, try that first -
3813 we are likely to read more than one register. If this is the
3814 first 'g' packet, we might be overly optimistic about its
3815 contents, so fall back to 'p'. */
3816 if (reg->in_g_packet)
3818 fetch_registers_using_g (regcache);
3819 if (reg->in_g_packet)
3823 if (fetch_register_using_p (regcache, reg))
3826 /* This register is not available. */
3827 regcache_raw_supply (regcache, reg->regnum, NULL);
3832 fetch_registers_using_g (regcache);
3834 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3835 if (!rsa->regs[i].in_g_packet)
3836 if (!fetch_register_using_p (regcache, &rsa->regs[i]))
3838 /* This register is not available. */
3839 regcache_raw_supply (regcache, i, NULL);
3843 /* Prepare to store registers. Since we may send them all (using a
3844 'G' request), we have to read out the ones we don't want to change
3848 remote_prepare_to_store (struct regcache *regcache)
3850 struct remote_arch_state *rsa = get_remote_arch_state ();
3852 gdb_byte buf[MAX_REGISTER_SIZE];
3854 /* Make sure the entire registers array is valid. */
3855 switch (remote_protocol_packets[PACKET_P].support)
3857 case PACKET_DISABLE:
3858 case PACKET_SUPPORT_UNKNOWN:
3859 /* Make sure all the necessary registers are cached. */
3860 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3861 if (rsa->regs[i].in_g_packet)
3862 regcache_raw_read (regcache, rsa->regs[i].regnum, buf);
3869 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3870 packet was not recognized. */
3873 store_register_using_P (const struct regcache *regcache, struct packet_reg *reg)
3875 struct remote_state *rs = get_remote_state ();
3876 struct remote_arch_state *rsa = get_remote_arch_state ();
3877 /* Try storing a single register. */
3878 char *buf = rs->buf;
3879 gdb_byte regp[MAX_REGISTER_SIZE];
3882 if (remote_protocol_packets[PACKET_P].support == PACKET_DISABLE)
3885 if (reg->pnum == -1)
3888 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
3889 p = buf + strlen (buf);
3890 regcache_raw_collect (regcache, reg->regnum, regp);
3891 bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
3892 remote_send (&rs->buf, &rs->buf_size);
3894 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
3899 error (_("Could not write register \"%s\""),
3900 gdbarch_register_name (current_gdbarch, reg->regnum));
3901 case PACKET_UNKNOWN:
3904 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
3908 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3909 contents of the register cache buffer. FIXME: ignores errors. */
3912 store_registers_using_G (const struct regcache *regcache)
3914 struct remote_state *rs = get_remote_state ();
3915 struct remote_arch_state *rsa = get_remote_arch_state ();
3919 /* Extract all the registers in the regcache copying them into a
3923 regs = alloca (rsa->sizeof_g_packet);
3924 memset (regs, 0, rsa->sizeof_g_packet);
3925 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3927 struct packet_reg *r = &rsa->regs[i];
3929 regcache_raw_collect (regcache, r->regnum, regs + r->offset);
3933 /* Command describes registers byte by byte,
3934 each byte encoded as two hex characters. */
3937 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3939 bin2hex (regs, p, rsa->sizeof_g_packet);
3940 remote_send (&rs->buf, &rs->buf_size);
3943 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3944 of the register cache buffer. FIXME: ignores errors. */
3947 remote_store_registers (struct regcache *regcache, int regnum)
3949 struct remote_state *rs = get_remote_state ();
3950 struct remote_arch_state *rsa = get_remote_arch_state ();
3953 set_thread (PIDGET (inferior_ptid), 1);
3957 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
3958 gdb_assert (reg != NULL);
3960 /* Always prefer to store registers using the 'P' packet if
3961 possible; we often change only a small number of registers.
3962 Sometimes we change a larger number; we'd need help from a
3963 higher layer to know to use 'G'. */
3964 if (store_register_using_P (regcache, reg))
3967 /* For now, don't complain if we have no way to write the
3968 register. GDB loses track of unavailable registers too
3969 easily. Some day, this may be an error. We don't have
3970 any way to read the register, either... */
3971 if (!reg->in_g_packet)
3974 store_registers_using_G (regcache);
3978 store_registers_using_G (regcache);
3980 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
3981 if (!rsa->regs[i].in_g_packet)
3982 if (!store_register_using_P (regcache, &rsa->regs[i]))
3983 /* See above for why we do not issue an error here. */
3988 /* Return the number of hex digits in num. */
3991 hexnumlen (ULONGEST num)
3995 for (i = 0; num != 0; i++)
4001 /* Set BUF to the minimum number of hex digits representing NUM. */
4004 hexnumstr (char *buf, ULONGEST num)
4006 int len = hexnumlen (num);
4007 return hexnumnstr (buf, num, len);
4011 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
4014 hexnumnstr (char *buf, ULONGEST num, int width)
4020 for (i = width - 1; i >= 0; i--)
4022 buf[i] = "0123456789abcdef"[(num & 0xf)];
4029 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
4032 remote_address_masked (CORE_ADDR addr)
4034 int address_size = remote_address_size;
4035 /* If "remoteaddresssize" was not set, default to target address size. */
4037 address_size = gdbarch_addr_bit (current_gdbarch);
4039 if (address_size > 0
4040 && address_size < (sizeof (ULONGEST) * 8))
4042 /* Only create a mask when that mask can safely be constructed
4043 in a ULONGEST variable. */
4045 mask = (mask << address_size) - 1;
4051 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
4052 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
4053 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
4054 (which may be more than *OUT_LEN due to escape characters). The
4055 total number of bytes in the output buffer will be at most
4059 remote_escape_output (const gdb_byte *buffer, int len,
4060 gdb_byte *out_buf, int *out_len,
4063 int input_index, output_index;
4066 for (input_index = 0; input_index < len; input_index++)
4068 gdb_byte b = buffer[input_index];
4070 if (b == '$' || b == '#' || b == '}')
4072 /* These must be escaped. */
4073 if (output_index + 2 > out_maxlen)
4075 out_buf[output_index++] = '}';
4076 out_buf[output_index++] = b ^ 0x20;
4080 if (output_index + 1 > out_maxlen)
4082 out_buf[output_index++] = b;
4086 *out_len = input_index;
4087 return output_index;
4090 /* Convert BUFFER, escaped data LEN bytes long, into binary data
4091 in OUT_BUF. Return the number of bytes written to OUT_BUF.
4092 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
4094 This function reverses remote_escape_output. It allows more
4095 escaped characters than that function does, in particular because
4096 '*' must be escaped to avoid the run-length encoding processing
4097 in reading packets. */
4100 remote_unescape_input (const gdb_byte *buffer, int len,
4101 gdb_byte *out_buf, int out_maxlen)
4103 int input_index, output_index;
4108 for (input_index = 0; input_index < len; input_index++)
4110 gdb_byte b = buffer[input_index];
4112 if (output_index + 1 > out_maxlen)
4114 warning (_("Received too much data from remote target;"
4115 " ignoring overflow."));
4116 return output_index;
4121 out_buf[output_index++] = b ^ 0x20;
4127 out_buf[output_index++] = b;
4131 error (_("Unmatched escape character in target response."));
4133 return output_index;
4136 /* Determine whether the remote target supports binary downloading.
4137 This is accomplished by sending a no-op memory write of zero length
4138 to the target at the specified address. It does not suffice to send
4139 the whole packet, since many stubs strip the eighth bit and
4140 subsequently compute a wrong checksum, which causes real havoc with
4143 NOTE: This can still lose if the serial line is not eight-bit
4144 clean. In cases like this, the user should clear "remote
4148 check_binary_download (CORE_ADDR addr)
4150 struct remote_state *rs = get_remote_state ();
4152 switch (remote_protocol_packets[PACKET_X].support)
4154 case PACKET_DISABLE:
4158 case PACKET_SUPPORT_UNKNOWN:
4164 p += hexnumstr (p, (ULONGEST) addr);
4166 p += hexnumstr (p, (ULONGEST) 0);
4170 putpkt_binary (rs->buf, (int) (p - rs->buf));
4171 getpkt (&rs->buf, &rs->buf_size, 0);
4173 if (rs->buf[0] == '\0')
4176 fprintf_unfiltered (gdb_stdlog,
4177 "binary downloading NOT suppported by target\n");
4178 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
4183 fprintf_unfiltered (gdb_stdlog,
4184 "binary downloading suppported by target\n");
4185 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
4192 /* Write memory data directly to the remote machine.
4193 This does not inform the data cache; the data cache uses this.
4194 HEADER is the starting part of the packet.
4195 MEMADDR is the address in the remote memory space.
4196 MYADDR is the address of the buffer in our space.
4197 LEN is the number of bytes.
4198 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4199 should send data as binary ('X'), or hex-encoded ('M').
4201 The function creates packet of the form
4202 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4204 where encoding of <DATA> is termined by PACKET_FORMAT.
4206 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4209 Returns the number of bytes transferred, or 0 (setting errno) for
4210 error. Only transfer a single packet. */
4213 remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
4214 const gdb_byte *myaddr, int len,
4215 char packet_format, int use_length)
4217 struct remote_state *rs = get_remote_state ();
4227 if (packet_format != 'X' && packet_format != 'M')
4228 internal_error (__FILE__, __LINE__,
4229 "remote_write_bytes_aux: bad packet format");
4234 payload_size = get_memory_write_packet_size ();
4236 /* The packet buffer will be large enough for the payload;
4237 get_memory_packet_size ensures this. */
4240 /* Compute the size of the actual payload by subtracting out the
4241 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4243 payload_size -= strlen ("$,:#NN");
4245 /* The comma won't be used. */
4247 header_length = strlen (header);
4248 payload_size -= header_length;
4249 payload_size -= hexnumlen (memaddr);
4251 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4253 strcat (rs->buf, header);
4254 p = rs->buf + strlen (header);
4256 /* Compute a best guess of the number of bytes actually transfered. */
4257 if (packet_format == 'X')
4259 /* Best guess at number of bytes that will fit. */
4260 todo = min (len, payload_size);
4262 payload_size -= hexnumlen (todo);
4263 todo = min (todo, payload_size);
4267 /* Num bytes that will fit. */
4268 todo = min (len, payload_size / 2);
4270 payload_size -= hexnumlen (todo);
4271 todo = min (todo, payload_size / 2);
4275 internal_error (__FILE__, __LINE__,
4276 _("minumum packet size too small to write data"));
4278 /* If we already need another packet, then try to align the end
4279 of this packet to a useful boundary. */
4280 if (todo > 2 * REMOTE_ALIGN_WRITES && todo < len)
4281 todo = ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
4283 /* Append "<memaddr>". */
4284 memaddr = remote_address_masked (memaddr);
4285 p += hexnumstr (p, (ULONGEST) memaddr);
4292 /* Append <len>. Retain the location/size of <len>. It may need to
4293 be adjusted once the packet body has been created. */
4295 plenlen = hexnumstr (p, (ULONGEST) todo);
4303 /* Append the packet body. */
4304 if (packet_format == 'X')
4306 /* Binary mode. Send target system values byte by byte, in
4307 increasing byte addresses. Only escape certain critical
4309 payload_length = remote_escape_output (myaddr, todo, p, &nr_bytes,
4312 /* If not all TODO bytes fit, then we'll need another packet. Make
4313 a second try to keep the end of the packet aligned. Don't do
4314 this if the packet is tiny. */
4315 if (nr_bytes < todo && nr_bytes > 2 * REMOTE_ALIGN_WRITES)
4319 new_nr_bytes = (((memaddr + nr_bytes) & ~(REMOTE_ALIGN_WRITES - 1))
4321 if (new_nr_bytes != nr_bytes)
4322 payload_length = remote_escape_output (myaddr, new_nr_bytes,
4327 p += payload_length;
4328 if (use_length && nr_bytes < todo)
4330 /* Escape chars have filled up the buffer prematurely,
4331 and we have actually sent fewer bytes than planned.
4332 Fix-up the length field of the packet. Use the same
4333 number of characters as before. */
4334 plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
4335 *plen = ':'; /* overwrite \0 from hexnumnstr() */
4340 /* Normal mode: Send target system values byte by byte, in
4341 increasing byte addresses. Each byte is encoded as a two hex
4343 nr_bytes = bin2hex (myaddr, p, todo);
4347 putpkt_binary (rs->buf, (int) (p - rs->buf));
4348 getpkt (&rs->buf, &rs->buf_size, 0);
4350 if (rs->buf[0] == 'E')
4352 /* There is no correspondance between what the remote protocol
4353 uses for errors and errno codes. We would like a cleaner way
4354 of representing errors (big enough to include errno codes,
4355 bfd_error codes, and others). But for now just return EIO. */
4360 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4361 fewer bytes than we'd planned. */
4365 /* Write memory data directly to the remote machine.
4366 This does not inform the data cache; the data cache uses this.
4367 MEMADDR is the address in the remote memory space.
4368 MYADDR is the address of the buffer in our space.
4369 LEN is the number of bytes.
4371 Returns number of bytes transferred, or 0 (setting errno) for
4372 error. Only transfer a single packet. */
4375 remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
4377 char *packet_format = 0;
4379 /* Check whether the target supports binary download. */
4380 check_binary_download (memaddr);
4382 switch (remote_protocol_packets[PACKET_X].support)
4385 packet_format = "X";
4387 case PACKET_DISABLE:
4388 packet_format = "M";
4390 case PACKET_SUPPORT_UNKNOWN:
4391 internal_error (__FILE__, __LINE__,
4392 _("remote_write_bytes: bad internal state"));
4394 internal_error (__FILE__, __LINE__, _("bad switch"));
4397 return remote_write_bytes_aux (packet_format,
4398 memaddr, myaddr, len, packet_format[0], 1);
4401 /* Read memory data directly from the remote machine.
4402 This does not use the data cache; the data cache uses this.
4403 MEMADDR is the address in the remote memory space.
4404 MYADDR is the address of the buffer in our space.
4405 LEN is the number of bytes.
4407 Returns number of bytes transferred, or 0 for error. */
4409 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4410 remote targets) shouldn't attempt to read the entire buffer.
4411 Instead it should read a single packet worth of data and then
4412 return the byte size of that packet to the caller. The caller (its
4413 caller and its callers caller ;-) already contains code for
4414 handling partial reads. */
4417 remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
4419 struct remote_state *rs = get_remote_state ();
4420 int max_buf_size; /* Max size of packet output buffer. */
4426 max_buf_size = get_memory_read_packet_size ();
4427 /* The packet buffer will be large enough for the payload;
4428 get_memory_packet_size ensures this. */
4437 todo = min (len, max_buf_size / 2); /* num bytes that will fit */
4439 /* construct "m"<memaddr>","<len>" */
4440 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4441 memaddr = remote_address_masked (memaddr);
4444 p += hexnumstr (p, (ULONGEST) memaddr);
4446 p += hexnumstr (p, (ULONGEST) todo);
4450 getpkt (&rs->buf, &rs->buf_size, 0);
4452 if (rs->buf[0] == 'E'
4453 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
4454 && rs->buf[3] == '\0')
4456 /* There is no correspondance between what the remote
4457 protocol uses for errors and errno codes. We would like
4458 a cleaner way of representing errors (big enough to
4459 include errno codes, bfd_error codes, and others). But
4460 for now just return EIO. */
4465 /* Reply describes memory byte by byte,
4466 each byte encoded as two hex characters. */
4469 if ((i = hex2bin (p, myaddr, todo)) < todo)
4471 /* Reply is short. This means that we were able to read
4472 only part of what we wanted to. */
4473 return i + (origlen - len);
4482 /* Read or write LEN bytes from inferior memory at MEMADDR,
4483 transferring to or from debugger address BUFFER. Write to inferior
4484 if SHOULD_WRITE is nonzero. Returns length of data written or
4485 read; 0 for error. TARGET is unused. */
4488 remote_xfer_memory (CORE_ADDR mem_addr, gdb_byte *buffer, int mem_len,
4489 int should_write, struct mem_attrib *attrib,
4490 struct target_ops *target)
4495 res = remote_write_bytes (mem_addr, buffer, mem_len);
4497 res = remote_read_bytes (mem_addr, buffer, mem_len);
4502 /* Sends a packet with content determined by the printf format string
4503 FORMAT and the remaining arguments, then gets the reply. Returns
4504 whether the packet was a success, a failure, or unknown. */
4507 remote_send_printf (const char *format, ...)
4509 struct remote_state *rs = get_remote_state ();
4510 int max_size = get_remote_packet_size ();
4513 va_start (ap, format);
4516 if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
4517 internal_error (__FILE__, __LINE__, "Too long remote packet.");
4519 if (putpkt (rs->buf) < 0)
4520 error (_("Communication problem with target."));
4523 getpkt (&rs->buf, &rs->buf_size, 0);
4525 return packet_check_result (rs->buf);
4529 restore_remote_timeout (void *p)
4531 int value = *(int *)p;
4532 remote_timeout = value;
4535 /* Flash writing can take quite some time. We'll set
4536 effectively infinite timeout for flash operations.
4537 In future, we'll need to decide on a better approach. */
4538 static const int remote_flash_timeout = 1000;
4541 remote_flash_erase (struct target_ops *ops,
4542 ULONGEST address, LONGEST length)
4544 int saved_remote_timeout = remote_timeout;
4545 enum packet_result ret;
4547 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
4548 &saved_remote_timeout);
4549 remote_timeout = remote_flash_timeout;
4551 ret = remote_send_printf ("vFlashErase:%s,%s",
4556 case PACKET_UNKNOWN:
4557 error (_("Remote target does not support flash erase"));
4559 error (_("Error erasing flash with vFlashErase packet"));
4564 do_cleanups (back_to);
4568 remote_flash_write (struct target_ops *ops,
4569 ULONGEST address, LONGEST length,
4570 const gdb_byte *data)
4572 int saved_remote_timeout = remote_timeout;
4574 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
4575 &saved_remote_timeout);
4577 remote_timeout = remote_flash_timeout;
4578 ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 'X', 0);
4579 do_cleanups (back_to);
4585 remote_flash_done (struct target_ops *ops)
4587 int saved_remote_timeout = remote_timeout;
4589 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
4590 &saved_remote_timeout);
4592 remote_timeout = remote_flash_timeout;
4593 ret = remote_send_printf ("vFlashDone");
4594 do_cleanups (back_to);
4598 case PACKET_UNKNOWN:
4599 error (_("Remote target does not support vFlashDone"));
4601 error (_("Error finishing flash operation"));
4608 remote_files_info (struct target_ops *ignore)
4610 puts_filtered ("Debugging a target over a serial line.\n");
4613 /* Stuff for dealing with the packets which are part of this protocol.
4614 See comment at top of file for details. */
4616 /* Read a single character from the remote end. */
4619 readchar (int timeout)
4623 ch = serial_readchar (remote_desc, timeout);
4628 switch ((enum serial_rc) ch)
4631 target_mourn_inferior ();
4632 error (_("Remote connection closed"));
4635 perror_with_name (_("Remote communication error"));
4637 case SERIAL_TIMEOUT:
4643 /* Send the command in *BUF to the remote machine, and read the reply
4644 into *BUF. Report an error if we get an error reply. Resize
4645 *BUF using xrealloc if necessary to hold the result, and update
4649 remote_send (char **buf,
4653 getpkt (buf, sizeof_buf, 0);
4655 if ((*buf)[0] == 'E')
4656 error (_("Remote failure reply: %s"), *buf);
4659 /* Display a null-terminated packet on stdout, for debugging, using C
4663 print_packet (char *buf)
4665 puts_filtered ("\"");
4666 fputstr_filtered (buf, '"', gdb_stdout);
4667 puts_filtered ("\"");
4673 return putpkt_binary (buf, strlen (buf));
4676 /* Send a packet to the remote machine, with error checking. The data
4677 of the packet is in BUF. The string in BUF can be at most
4678 get_remote_packet_size () - 5 to account for the $, # and checksum,
4679 and for a possible /0 if we are debugging (remote_debug) and want
4680 to print the sent packet as a string. */
4683 putpkt_binary (char *buf, int cnt)
4686 unsigned char csum = 0;
4687 char *buf2 = alloca (cnt + 6);
4693 /* Copy the packet into buffer BUF2, encapsulating it
4694 and giving it a checksum. */
4699 for (i = 0; i < cnt; i++)
4705 *p++ = tohex ((csum >> 4) & 0xf);
4706 *p++ = tohex (csum & 0xf);
4708 /* Send it over and over until we get a positive ack. */
4712 int started_error_output = 0;
4717 fprintf_unfiltered (gdb_stdlog, "Sending packet: ");
4718 fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog);
4719 fprintf_unfiltered (gdb_stdlog, "...");
4720 gdb_flush (gdb_stdlog);
4722 if (serial_write (remote_desc, buf2, p - buf2))
4723 perror_with_name (_("putpkt: write failed"));
4725 /* Read until either a timeout occurs (-2) or '+' is read. */
4728 ch = readchar (remote_timeout);
4736 case SERIAL_TIMEOUT:
4738 if (started_error_output)
4740 putchar_unfiltered ('\n');
4741 started_error_output = 0;
4750 fprintf_unfiltered (gdb_stdlog, "Ack\n");
4754 fprintf_unfiltered (gdb_stdlog, "Nak\n");
4755 case SERIAL_TIMEOUT:
4759 break; /* Retransmit buffer. */
4763 fprintf_unfiltered (gdb_stdlog,
4764 "Packet instead of Ack, ignoring it\n");
4765 /* It's probably an old response sent because an ACK
4766 was lost. Gobble up the packet and ack it so it
4767 doesn't get retransmitted when we resend this
4770 serial_write (remote_desc, "+", 1);
4771 continue; /* Now, go look for +. */
4776 if (!started_error_output)
4778 started_error_output = 1;
4779 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
4781 fputc_unfiltered (ch & 0177, gdb_stdlog);
4785 break; /* Here to retransmit. */
4789 /* This is wrong. If doing a long backtrace, the user should be
4790 able to get out next time we call QUIT, without anything as
4791 violent as interrupt_query. If we want to provide a way out of
4792 here without getting to the next QUIT, it should be based on
4793 hitting ^C twice as in remote_wait. */
4803 /* Come here after finding the start of a frame when we expected an
4804 ack. Do our best to discard the rest of this packet. */
4813 c = readchar (remote_timeout);
4816 case SERIAL_TIMEOUT:
4817 /* Nothing we can do. */
4820 /* Discard the two bytes of checksum and stop. */
4821 c = readchar (remote_timeout);
4823 c = readchar (remote_timeout);
4826 case '*': /* Run length encoding. */
4827 /* Discard the repeat count. */
4828 c = readchar (remote_timeout);
4833 /* A regular character. */
4839 /* Come here after finding the start of the frame. Collect the rest
4840 into *BUF, verifying the checksum, length, and handling run-length
4841 compression. NUL terminate the buffer. If there is not enough room,
4842 expand *BUF using xrealloc.
4844 Returns -1 on error, number of characters in buffer (ignoring the
4845 trailing NULL) on success. (could be extended to return one of the
4846 SERIAL status indications). */
4849 read_frame (char **buf_p,
4862 c = readchar (remote_timeout);
4865 case SERIAL_TIMEOUT:
4867 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
4871 fputs_filtered ("Saw new packet start in middle of old one\n",
4873 return -1; /* Start a new packet, count retries. */
4876 unsigned char pktcsum;
4882 check_0 = readchar (remote_timeout);
4884 check_1 = readchar (remote_timeout);
4886 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
4889 fputs_filtered ("Timeout in checksum, retrying\n",
4893 else if (check_0 < 0 || check_1 < 0)
4896 fputs_filtered ("Communication error in checksum\n",
4901 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
4902 if (csum == pktcsum)
4907 fprintf_filtered (gdb_stdlog,
4908 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4910 fputstrn_filtered (buf, bc, 0, gdb_stdlog);
4911 fputs_filtered ("\n", gdb_stdlog);
4913 /* Number of characters in buffer ignoring trailing
4917 case '*': /* Run length encoding. */
4922 c = readchar (remote_timeout);
4924 repeat = c - ' ' + 3; /* Compute repeat count. */
4926 /* The character before ``*'' is repeated. */
4928 if (repeat > 0 && repeat <= 255 && bc > 0)
4930 if (bc + repeat - 1 >= *sizeof_buf - 1)
4932 /* Make some more room in the buffer. */
4933 *sizeof_buf += repeat;
4934 *buf_p = xrealloc (*buf_p, *sizeof_buf);
4938 memset (&buf[bc], buf[bc - 1], repeat);
4944 printf_filtered (_("Invalid run length encoding: %s\n"), buf);
4948 if (bc >= *sizeof_buf - 1)
4950 /* Make some more room in the buffer. */
4952 *buf_p = xrealloc (*buf_p, *sizeof_buf);
4963 /* Read a packet from the remote machine, with error checking, and
4964 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4965 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4966 rather than timing out; this is used (in synchronous mode) to wait
4967 for a target that is is executing user code to stop. */
4968 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4969 don't have to change all the calls to getpkt to deal with the
4970 return value, because at the moment I don't know what the right
4971 thing to do it for those. */
4979 timed_out = getpkt_sane (buf, sizeof_buf, forever);
4983 /* Read a packet from the remote machine, with error checking, and
4984 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4985 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4986 rather than timing out; this is used (in synchronous mode) to wait
4987 for a target that is is executing user code to stop. If FOREVER ==
4988 0, this function is allowed to time out gracefully and return an
4989 indication of this to the caller. Otherwise return the number
4992 getpkt_sane (char **buf, long *sizeof_buf, int forever)
4999 strcpy (*buf, "timeout");
5003 timeout = watchdog > 0 ? watchdog : -1;
5007 timeout = remote_timeout;
5011 for (tries = 1; tries <= MAX_TRIES; tries++)
5013 /* This can loop forever if the remote side sends us characters
5014 continuously, but if it pauses, we'll get a zero from
5015 readchar because of timeout. Then we'll count that as a
5018 /* Note that we will only wait forever prior to the start of a
5019 packet. After that, we expect characters to arrive at a
5020 brisk pace. They should show up within remote_timeout
5025 c = readchar (timeout);
5027 if (c == SERIAL_TIMEOUT)
5029 if (forever) /* Watchdog went off? Kill the target. */
5032 target_mourn_inferior ();
5033 error (_("Watchdog has expired. Target detached."));
5036 fputs_filtered ("Timed out.\n", gdb_stdlog);
5042 /* We've found the start of a packet, now collect the data. */
5044 val = read_frame (buf, sizeof_buf);
5050 fprintf_unfiltered (gdb_stdlog, "Packet received: ");
5051 fputstrn_unfiltered (*buf, val, 0, gdb_stdlog);
5052 fprintf_unfiltered (gdb_stdlog, "\n");
5054 serial_write (remote_desc, "+", 1);
5058 /* Try the whole thing again. */
5060 serial_write (remote_desc, "-", 1);
5063 /* We have tried hard enough, and just can't receive the packet.
5066 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
5067 serial_write (remote_desc, "+", 1);
5074 /* For some mysterious reason, wait_for_inferior calls kill instead of
5075 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5079 target_mourn_inferior ();
5083 /* Use catch_errors so the user can quit from gdb even when we aren't on
5084 speaking terms with the remote system. */
5085 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
5087 /* Don't wait for it to die. I'm not really sure it matters whether
5088 we do or not. For the existing stubs, kill is a noop. */
5089 target_mourn_inferior ();
5092 /* Async version of remote_kill. */
5094 remote_async_kill (void)
5096 /* Unregister the file descriptor from the event loop. */
5097 if (target_is_async_p ())
5098 serial_async (remote_desc, NULL, 0);
5100 /* For some mysterious reason, wait_for_inferior calls kill instead of
5101 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5105 target_mourn_inferior ();
5109 /* Use catch_errors so the user can quit from gdb even when we
5110 aren't on speaking terms with the remote system. */
5111 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
5113 /* Don't wait for it to die. I'm not really sure it matters whether
5114 we do or not. For the existing stubs, kill is a noop. */
5115 target_mourn_inferior ();
5121 remote_mourn_1 (&remote_ops);
5125 remote_async_mourn (void)
5127 remote_mourn_1 (&remote_async_ops);
5131 extended_remote_mourn (void)
5133 /* We do _not_ want to mourn the target like this; this will
5134 remove the extended remote target from the target stack,
5135 and the next time the user says "run" it'll fail.
5137 FIXME: What is the right thing to do here? */
5139 remote_mourn_1 (&extended_remote_ops);
5143 /* Worker function for remote_mourn. */
5145 remote_mourn_1 (struct target_ops *target)
5147 unpush_target (target);
5148 generic_mourn_inferior ();
5151 /* In the extended protocol we want to be able to do things like
5152 "run" and have them basically work as expected. So we need
5153 a special create_inferior function.
5155 FIXME: One day add support for changing the exec file
5156 we're debugging, arguments and an environment. */
5159 extended_remote_create_inferior (char *exec_file, char *args,
5160 char **env, int from_tty)
5162 /* Rip out the breakpoints; we'll reinsert them after restarting
5163 the remote server. */
5164 remove_breakpoints ();
5166 /* Now restart the remote server. */
5167 extended_remote_restart ();
5169 /* NOTE: We don't need to recheck for a target description here; but
5170 if we gain the ability to switch the remote executable we may
5171 need to, if for instance we are running a process which requested
5172 different emulated hardware from the operating system. A
5173 concrete example of this is ARM GNU/Linux, where some binaries
5174 will have a legacy FPA coprocessor emulated and others may have
5175 access to a hardware VFP unit. */
5177 /* Now put the breakpoints back in. This way we're safe if the
5178 restart function works via a unix fork on the remote side. */
5179 insert_breakpoints ();
5181 /* Clean up from the last time we were running. */
5182 clear_proceed_status ();
5185 /* Async version of extended_remote_create_inferior. */
5187 extended_remote_async_create_inferior (char *exec_file, char *args,
5188 char **env, int from_tty)
5190 /* Rip out the breakpoints; we'll reinsert them after restarting
5191 the remote server. */
5192 remove_breakpoints ();
5194 /* If running asynchronously, register the target file descriptor
5195 with the event loop. */
5196 if (target_can_async_p ())
5197 target_async (inferior_event_handler, 0);
5199 /* Now restart the remote server. */
5200 extended_remote_restart ();
5202 /* NOTE: We don't need to recheck for a target description here; but
5203 if we gain the ability to switch the remote executable we may
5204 need to, if for instance we are running a process which requested
5205 different emulated hardware from the operating system. A
5206 concrete example of this is ARM GNU/Linux, where some binaries
5207 will have a legacy FPA coprocessor emulated and others may have
5208 access to a hardware VFP unit. */
5210 /* Now put the breakpoints back in. This way we're safe if the
5211 restart function works via a unix fork on the remote side. */
5212 insert_breakpoints ();
5214 /* Clean up from the last time we were running. */
5215 clear_proceed_status ();
5219 /* Insert a breakpoint. On targets that have software breakpoint
5220 support, we ask the remote target to do the work; on targets
5221 which don't, we insert a traditional memory breakpoint. */
5224 remote_insert_breakpoint (struct bp_target_info *bp_tgt)
5226 CORE_ADDR addr = bp_tgt->placed_address;
5227 struct remote_state *rs = get_remote_state ();
5229 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5230 If it succeeds, then set the support to PACKET_ENABLE. If it
5231 fails, and the user has explicitly requested the Z support then
5232 report an error, otherwise, mark it disabled and go on. */
5234 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
5241 gdbarch_breakpoint_from_pc
5242 (current_gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
5243 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
5244 p += hexnumstr (p, addr);
5245 sprintf (p, ",%d", bp_tgt->placed_size);
5248 getpkt (&rs->buf, &rs->buf_size, 0);
5250 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
5256 case PACKET_UNKNOWN:
5261 return memory_insert_breakpoint (bp_tgt);
5265 remote_remove_breakpoint (struct bp_target_info *bp_tgt)
5267 CORE_ADDR addr = bp_tgt->placed_address;
5268 struct remote_state *rs = get_remote_state ();
5271 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
5279 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
5280 p += hexnumstr (p, addr);
5281 sprintf (p, ",%d", bp_tgt->placed_size);
5284 getpkt (&rs->buf, &rs->buf_size, 0);
5286 return (rs->buf[0] == 'E');
5289 return memory_remove_breakpoint (bp_tgt);
5293 watchpoint_to_Z_packet (int type)
5298 return Z_PACKET_WRITE_WP;
5301 return Z_PACKET_READ_WP;
5304 return Z_PACKET_ACCESS_WP;
5307 internal_error (__FILE__, __LINE__,
5308 _("hw_bp_to_z: bad watchpoint type %d"), type);
5313 remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
5315 struct remote_state *rs = get_remote_state ();
5317 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
5319 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
5322 sprintf (rs->buf, "Z%x,", packet);
5323 p = strchr (rs->buf, '\0');
5324 addr = remote_address_masked (addr);
5325 p += hexnumstr (p, (ULONGEST) addr);
5326 sprintf (p, ",%x", len);
5329 getpkt (&rs->buf, &rs->buf_size, 0);
5331 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
5334 case PACKET_UNKNOWN:
5339 internal_error (__FILE__, __LINE__,
5340 _("remote_insert_watchpoint: reached end of function"));
5345 remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
5347 struct remote_state *rs = get_remote_state ();
5349 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
5351 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
5354 sprintf (rs->buf, "z%x,", packet);
5355 p = strchr (rs->buf, '\0');
5356 addr = remote_address_masked (addr);
5357 p += hexnumstr (p, (ULONGEST) addr);
5358 sprintf (p, ",%x", len);
5360 getpkt (&rs->buf, &rs->buf_size, 0);
5362 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
5365 case PACKET_UNKNOWN:
5370 internal_error (__FILE__, __LINE__,
5371 _("remote_remove_watchpoint: reached end of function"));
5375 int remote_hw_watchpoint_limit = -1;
5376 int remote_hw_breakpoint_limit = -1;
5379 remote_check_watch_resources (int type, int cnt, int ot)
5381 if (type == bp_hardware_breakpoint)
5383 if (remote_hw_breakpoint_limit == 0)
5385 else if (remote_hw_breakpoint_limit < 0)
5387 else if (cnt <= remote_hw_breakpoint_limit)
5392 if (remote_hw_watchpoint_limit == 0)
5394 else if (remote_hw_watchpoint_limit < 0)
5398 else if (cnt <= remote_hw_watchpoint_limit)
5405 remote_stopped_by_watchpoint (void)
5407 return remote_stopped_by_watchpoint_p;
5410 extern int stepped_after_stopped_by_watchpoint;
5413 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
5416 if (remote_stopped_by_watchpoint ()
5417 || stepped_after_stopped_by_watchpoint)
5419 *addr_p = remote_watch_data_address;
5428 remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
5431 struct remote_state *rs = get_remote_state ();
5434 /* The length field should be set to the size of a breakpoint
5435 instruction, even though we aren't inserting one ourselves. */
5437 gdbarch_breakpoint_from_pc
5438 (current_gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
5440 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
5447 addr = remote_address_masked (bp_tgt->placed_address);
5448 p += hexnumstr (p, (ULONGEST) addr);
5449 sprintf (p, ",%x", bp_tgt->placed_size);
5452 getpkt (&rs->buf, &rs->buf_size, 0);
5454 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
5457 case PACKET_UNKNOWN:
5462 internal_error (__FILE__, __LINE__,
5463 _("remote_insert_hw_breakpoint: reached end of function"));
5468 remote_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
5471 struct remote_state *rs = get_remote_state ();
5474 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
5481 addr = remote_address_masked (bp_tgt->placed_address);
5482 p += hexnumstr (p, (ULONGEST) addr);
5483 sprintf (p, ",%x", bp_tgt->placed_size);
5486 getpkt (&rs->buf, &rs->buf_size, 0);
5488 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
5491 case PACKET_UNKNOWN:
5496 internal_error (__FILE__, __LINE__,
5497 _("remote_remove_hw_breakpoint: reached end of function"));
5500 /* Some targets are only capable of doing downloads, and afterwards
5501 they switch to the remote serial protocol. This function provides
5502 a clean way to get from the download target to the remote target.
5503 It's basically just a wrapper so that we don't have to expose any
5504 of the internal workings of remote.c.
5506 Prior to calling this routine, you should shutdown the current
5507 target code, else you will get the "A program is being debugged
5508 already..." message. Usually a call to pop_target() suffices. */
5511 push_remote_target (char *name, int from_tty)
5513 printf_filtered (_("Switching to remote protocol\n"));
5514 remote_open (name, from_tty);
5517 /* Table used by the crc32 function to calcuate the checksum. */
5519 static unsigned long crc32_table[256] =
5522 static unsigned long
5523 crc32 (unsigned char *buf, int len, unsigned int crc)
5525 if (!crc32_table[1])
5527 /* Initialize the CRC table and the decoding table. */
5531 for (i = 0; i < 256; i++)
5533 for (c = i << 24, j = 8; j > 0; --j)
5534 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
5541 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
5547 /* compare-sections command
5549 With no arguments, compares each loadable section in the exec bfd
5550 with the same memory range on the target, and reports mismatches.
5551 Useful for verifying the image on the target against the exec file.
5552 Depends on the target understanding the new "qCRC:" request. */
5554 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5555 target method (target verify memory) and generic version of the
5556 actual command. This will allow other high-level code (especially
5557 generic_load()) to make use of this target functionality. */
5560 compare_sections_command (char *args, int from_tty)
5562 struct remote_state *rs = get_remote_state ();
5564 unsigned long host_crc, target_crc;
5565 extern bfd *exec_bfd;
5566 struct cleanup *old_chain;
5569 const char *sectname;
5576 error (_("command cannot be used without an exec file"));
5577 if (!current_target.to_shortname ||
5578 strcmp (current_target.to_shortname, "remote") != 0)
5579 error (_("command can only be used with remote target"));
5581 for (s = exec_bfd->sections; s; s = s->next)
5583 if (!(s->flags & SEC_LOAD))
5584 continue; /* skip non-loadable section */
5586 size = bfd_get_section_size (s);
5588 continue; /* skip zero-length section */
5590 sectname = bfd_get_section_name (exec_bfd, s);
5591 if (args && strcmp (args, sectname) != 0)
5592 continue; /* not the section selected by user */
5594 matched = 1; /* do this section */
5596 /* FIXME: assumes lma can fit into long. */
5597 xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
5598 (long) lma, (long) size);
5601 /* Be clever; compute the host_crc before waiting for target
5603 sectdata = xmalloc (size);
5604 old_chain = make_cleanup (xfree, sectdata);
5605 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
5606 host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
5608 getpkt (&rs->buf, &rs->buf_size, 0);
5609 if (rs->buf[0] == 'E')
5610 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5611 sectname, paddr (lma), paddr (lma + size));
5612 if (rs->buf[0] != 'C')
5613 error (_("remote target does not support this operation"));
5615 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
5616 target_crc = target_crc * 16 + fromhex (*tmp);
5618 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5619 sectname, paddr (lma), paddr (lma + size));
5620 if (host_crc == target_crc)
5621 printf_filtered ("matched.\n");
5624 printf_filtered ("MIS-MATCHED!\n");
5628 do_cleanups (old_chain);
5631 warning (_("One or more sections of the remote executable does not match\n\
5632 the loaded file\n"));
5633 if (args && !matched)
5634 printf_filtered (_("No loaded section named '%s'.\n"), args);
5637 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5638 into remote target. The number of bytes written to the remote
5639 target is returned, or -1 for error. */
5642 remote_write_qxfer (struct target_ops *ops, const char *object_name,
5643 const char *annex, const gdb_byte *writebuf,
5644 ULONGEST offset, LONGEST len,
5645 struct packet_config *packet)
5650 struct remote_state *rs = get_remote_state ();
5651 int max_size = get_memory_write_packet_size ();
5653 if (packet->support == PACKET_DISABLE)
5656 /* Insert header. */
5657 i = snprintf (rs->buf, max_size,
5658 "qXfer:%s:write:%s:%s:",
5659 object_name, annex ? annex : "",
5660 phex_nz (offset, sizeof offset));
5661 max_size -= (i + 1);
5663 /* Escape as much data as fits into rs->buf. */
5664 buf_len = remote_escape_output
5665 (writebuf, len, (rs->buf + i), &max_size, max_size);
5667 if (putpkt_binary (rs->buf, i + buf_len) < 0
5668 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
5669 || packet_ok (rs->buf, packet) != PACKET_OK)
5672 unpack_varlen_hex (rs->buf, &n);
5676 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5677 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5678 number of bytes read is returned, or 0 for EOF, or -1 for error.
5679 The number of bytes read may be less than LEN without indicating an
5680 EOF. PACKET is checked and updated to indicate whether the remote
5681 target supports this object. */
5684 remote_read_qxfer (struct target_ops *ops, const char *object_name,
5686 gdb_byte *readbuf, ULONGEST offset, LONGEST len,
5687 struct packet_config *packet)
5689 static char *finished_object;
5690 static char *finished_annex;
5691 static ULONGEST finished_offset;
5693 struct remote_state *rs = get_remote_state ();
5694 unsigned int total = 0;
5695 LONGEST i, n, packet_len;
5697 if (packet->support == PACKET_DISABLE)
5700 /* Check whether we've cached an end-of-object packet that matches
5702 if (finished_object)
5704 if (strcmp (object_name, finished_object) == 0
5705 && strcmp (annex ? annex : "", finished_annex) == 0
5706 && offset == finished_offset)
5709 /* Otherwise, we're now reading something different. Discard
5711 xfree (finished_object);
5712 xfree (finished_annex);
5713 finished_object = NULL;
5714 finished_annex = NULL;
5717 /* Request only enough to fit in a single packet. The actual data
5718 may not, since we don't know how much of it will need to be escaped;
5719 the target is free to respond with slightly less data. We subtract
5720 five to account for the response type and the protocol frame. */
5721 n = min (get_remote_packet_size () - 5, len);
5722 snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5723 object_name, annex ? annex : "",
5724 phex_nz (offset, sizeof offset),
5725 phex_nz (n, sizeof n));
5726 i = putpkt (rs->buf);
5731 packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
5732 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
5735 if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
5736 error (_("Unknown remote qXfer reply: %s"), rs->buf);
5738 /* 'm' means there is (or at least might be) more data after this
5739 batch. That does not make sense unless there's at least one byte
5740 of data in this reply. */
5741 if (rs->buf[0] == 'm' && packet_len == 1)
5742 error (_("Remote qXfer reply contained no data."));
5744 /* Got some data. */
5745 i = remote_unescape_input (rs->buf + 1, packet_len - 1, readbuf, n);
5747 /* 'l' is an EOF marker, possibly including a final block of data,
5748 or possibly empty. If we have the final block of a non-empty
5749 object, record this fact to bypass a subsequent partial read. */
5750 if (rs->buf[0] == 'l' && offset + i > 0)
5752 finished_object = xstrdup (object_name);
5753 finished_annex = xstrdup (annex ? annex : "");
5754 finished_offset = offset + i;
5761 remote_xfer_partial (struct target_ops *ops, enum target_object object,
5762 const char *annex, gdb_byte *readbuf,
5763 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5765 struct remote_state *rs = get_remote_state ();
5770 /* Handle memory using the standard memory routines. */
5771 if (object == TARGET_OBJECT_MEMORY)
5776 if (writebuf != NULL)
5777 xfered = remote_write_bytes (offset, writebuf, len);
5779 xfered = remote_read_bytes (offset, readbuf, len);
5783 else if (xfered == 0 && errno == 0)
5789 /* Handle SPU memory using qxfer packets. */
5790 if (object == TARGET_OBJECT_SPU)
5793 return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len,
5794 &remote_protocol_packets
5795 [PACKET_qXfer_spu_read]);
5797 return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len,
5798 &remote_protocol_packets
5799 [PACKET_qXfer_spu_write]);
5802 /* Only handle flash writes. */
5803 if (writebuf != NULL)
5809 case TARGET_OBJECT_FLASH:
5810 xfered = remote_flash_write (ops, offset, len, writebuf);
5814 else if (xfered == 0 && errno == 0)
5824 /* Map pre-existing objects onto letters. DO NOT do this for new
5825 objects!!! Instead specify new query packets. */
5828 case TARGET_OBJECT_AVR:
5832 case TARGET_OBJECT_AUXV:
5833 gdb_assert (annex == NULL);
5834 return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
5835 &remote_protocol_packets[PACKET_qXfer_auxv]);
5837 case TARGET_OBJECT_AVAILABLE_FEATURES:
5838 return remote_read_qxfer
5839 (ops, "features", annex, readbuf, offset, len,
5840 &remote_protocol_packets[PACKET_qXfer_features]);
5842 case TARGET_OBJECT_LIBRARIES:
5843 return remote_read_qxfer
5844 (ops, "libraries", annex, readbuf, offset, len,
5845 &remote_protocol_packets[PACKET_qXfer_libraries]);
5847 case TARGET_OBJECT_MEMORY_MAP:
5848 gdb_assert (annex == NULL);
5849 return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,
5850 &remote_protocol_packets[PACKET_qXfer_memory_map]);
5856 /* Note: a zero OFFSET and LEN can be used to query the minimum
5858 if (offset == 0 && len == 0)
5859 return (get_remote_packet_size ());
5860 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5861 large enough let the caller deal with it. */
5862 if (len < get_remote_packet_size ())
5864 len = get_remote_packet_size ();
5866 /* Except for querying the minimum buffer size, target must be open. */
5868 error (_("remote query is only available after target open"));
5870 gdb_assert (annex != NULL);
5871 gdb_assert (readbuf != NULL);
5877 /* We used one buffer char for the remote protocol q command and
5878 another for the query type. As the remote protocol encapsulation
5879 uses 4 chars plus one extra in case we are debugging
5880 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5883 while (annex[i] && (i < (get_remote_packet_size () - 8)))
5885 /* Bad caller may have sent forbidden characters. */
5886 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
5891 gdb_assert (annex[i] == '\0');
5893 i = putpkt (rs->buf);
5897 getpkt (&rs->buf, &rs->buf_size, 0);
5898 strcpy ((char *) readbuf, rs->buf);
5900 return strlen ((char *) readbuf);
5904 remote_rcmd (char *command,
5905 struct ui_file *outbuf)
5907 struct remote_state *rs = get_remote_state ();
5911 error (_("remote rcmd is only available after target open"));
5913 /* Send a NULL command across as an empty command. */
5914 if (command == NULL)
5917 /* The query prefix. */
5918 strcpy (rs->buf, "qRcmd,");
5919 p = strchr (rs->buf, '\0');
5921 if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
5922 error (_("\"monitor\" command ``%s'' is too long."), command);
5924 /* Encode the actual command. */
5925 bin2hex ((gdb_byte *) command, p, 0);
5927 if (putpkt (rs->buf) < 0)
5928 error (_("Communication problem with target."));
5930 /* get/display the response */
5935 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5937 getpkt (&rs->buf, &rs->buf_size, 0);
5940 error (_("Target does not support this command."));
5941 if (buf[0] == 'O' && buf[1] != 'K')
5943 remote_console_output (buf + 1); /* 'O' message from stub. */
5946 if (strcmp (buf, "OK") == 0)
5948 if (strlen (buf) == 3 && buf[0] == 'E'
5949 && isdigit (buf[1]) && isdigit (buf[2]))
5951 error (_("Protocol error with Rcmd"));
5953 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
5955 char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
5956 fputc_unfiltered (c, outbuf);
5962 static VEC(mem_region_s) *
5963 remote_memory_map (struct target_ops *ops)
5965 VEC(mem_region_s) *result = NULL;
5966 char *text = target_read_stralloc (¤t_target,
5967 TARGET_OBJECT_MEMORY_MAP, NULL);
5971 struct cleanup *back_to = make_cleanup (xfree, text);
5972 result = parse_memory_map (text);
5973 do_cleanups (back_to);
5980 packet_command (char *args, int from_tty)
5982 struct remote_state *rs = get_remote_state ();
5985 error (_("command can only be used with remote target"));
5988 error (_("remote-packet command requires packet text as argument"));
5990 puts_filtered ("sending: ");
5991 print_packet (args);
5992 puts_filtered ("\n");
5995 getpkt (&rs->buf, &rs->buf_size, 0);
5996 puts_filtered ("received: ");
5997 print_packet (rs->buf);
5998 puts_filtered ("\n");
6002 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
6004 static void display_thread_info (struct gdb_ext_thread_info *info);
6006 static void threadset_test_cmd (char *cmd, int tty);
6008 static void threadalive_test (char *cmd, int tty);
6010 static void threadlist_test_cmd (char *cmd, int tty);
6012 int get_and_display_threadinfo (threadref *ref);
6014 static void threadinfo_test_cmd (char *cmd, int tty);
6016 static int thread_display_step (threadref *ref, void *context);
6018 static void threadlist_update_test_cmd (char *cmd, int tty);
6020 static void init_remote_threadtests (void);
6022 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
6025 threadset_test_cmd (char *cmd, int tty)
6027 int sample_thread = SAMPLE_THREAD;
6029 printf_filtered (_("Remote threadset test\n"));
6030 set_thread (sample_thread, 1);
6035 threadalive_test (char *cmd, int tty)
6037 int sample_thread = SAMPLE_THREAD;
6039 if (remote_thread_alive (pid_to_ptid (sample_thread)))
6040 printf_filtered ("PASS: Thread alive test\n");
6042 printf_filtered ("FAIL: Thread alive test\n");
6045 void output_threadid (char *title, threadref *ref);
6048 output_threadid (char *title, threadref *ref)
6052 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */
6054 printf_filtered ("%s %s\n", title, (&hexid[0]));
6058 threadlist_test_cmd (char *cmd, int tty)
6061 threadref nextthread;
6062 int done, result_count;
6063 threadref threadlist[3];
6065 printf_filtered ("Remote Threadlist test\n");
6066 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
6067 &result_count, &threadlist[0]))
6068 printf_filtered ("FAIL: threadlist test\n");
6071 threadref *scan = threadlist;
6072 threadref *limit = scan + result_count;
6074 while (scan < limit)
6075 output_threadid (" thread ", scan++);
6080 display_thread_info (struct gdb_ext_thread_info *info)
6082 output_threadid ("Threadid: ", &info->threadid);
6083 printf_filtered ("Name: %s\n ", info->shortname);
6084 printf_filtered ("State: %s\n", info->display);
6085 printf_filtered ("other: %s\n\n", info->more_display);
6089 get_and_display_threadinfo (threadref *ref)
6093 struct gdb_ext_thread_info threadinfo;
6095 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
6096 | TAG_MOREDISPLAY | TAG_DISPLAY;
6097 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
6098 display_thread_info (&threadinfo);
6103 threadinfo_test_cmd (char *cmd, int tty)
6105 int athread = SAMPLE_THREAD;
6109 int_to_threadref (&thread, athread);
6110 printf_filtered ("Remote Threadinfo test\n");
6111 if (!get_and_display_threadinfo (&thread))
6112 printf_filtered ("FAIL cannot get thread info\n");
6116 thread_display_step (threadref *ref, void *context)
6118 /* output_threadid(" threadstep ",ref); *//* simple test */
6119 return get_and_display_threadinfo (ref);
6123 threadlist_update_test_cmd (char *cmd, int tty)
6125 printf_filtered ("Remote Threadlist update test\n");
6126 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
6130 init_remote_threadtests (void)
6132 add_com ("tlist", class_obscure, threadlist_test_cmd, _("\
6133 Fetch and print the remote list of thread identifiers, one pkt only"));
6134 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
6135 _("Fetch and display info about one thread"));
6136 add_com ("tset", class_obscure, threadset_test_cmd,
6137 _("Test setting to a different thread"));
6138 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
6139 _("Iterate through updating all remote thread info"));
6140 add_com ("talive", class_obscure, threadalive_test,
6141 _(" Remote thread alive test "));
6146 /* Convert a thread ID to a string. Returns the string in a static
6150 remote_pid_to_str (ptid_t ptid)
6152 static char buf[32];
6154 xsnprintf (buf, sizeof buf, "Thread %d", ptid_get_pid (ptid));
6158 /* Get the address of the thread local variable in OBJFILE which is
6159 stored at OFFSET within the thread local storage for thread PTID. */
6162 remote_get_thread_local_address (ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
6164 if (remote_protocol_packets[PACKET_qGetTLSAddr].support != PACKET_DISABLE)
6166 struct remote_state *rs = get_remote_state ();
6168 enum packet_result result;
6170 strcpy (p, "qGetTLSAddr:");
6172 p += hexnumstr (p, PIDGET (ptid));
6174 p += hexnumstr (p, offset);
6176 p += hexnumstr (p, lm);
6180 getpkt (&rs->buf, &rs->buf_size, 0);
6181 result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTLSAddr]);
6182 if (result == PACKET_OK)
6186 unpack_varlen_hex (rs->buf, &result);
6189 else if (result == PACKET_UNKNOWN)
6190 throw_error (TLS_GENERIC_ERROR,
6191 _("Remote target doesn't support qGetTLSAddr packet"));
6193 throw_error (TLS_GENERIC_ERROR,
6194 _("Remote target failed to process qGetTLSAddr request"));
6197 throw_error (TLS_GENERIC_ERROR,
6198 _("TLS not supported or disabled on this target"));
6203 /* Support for inferring a target description based on the current
6204 architecture and the size of a 'g' packet. While the 'g' packet
6205 can have any size (since optional registers can be left off the
6206 end), some sizes are easily recognizable given knowledge of the
6207 approximate architecture. */
6209 struct remote_g_packet_guess
6212 const struct target_desc *tdesc;
6214 typedef struct remote_g_packet_guess remote_g_packet_guess_s;
6215 DEF_VEC_O(remote_g_packet_guess_s);
6217 struct remote_g_packet_data
6219 VEC(remote_g_packet_guess_s) *guesses;
6222 static struct gdbarch_data *remote_g_packet_data_handle;
6225 remote_g_packet_data_init (struct obstack *obstack)
6227 return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data);
6231 register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes,
6232 const struct target_desc *tdesc)
6234 struct remote_g_packet_data *data
6235 = gdbarch_data (gdbarch, remote_g_packet_data_handle);
6236 struct remote_g_packet_guess new_guess, *guess;
6239 gdb_assert (tdesc != NULL);
6242 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
6244 if (guess->bytes == bytes)
6245 internal_error (__FILE__, __LINE__,
6246 "Duplicate g packet description added for size %d",
6249 new_guess.bytes = bytes;
6250 new_guess.tdesc = tdesc;
6251 VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess);
6254 static const struct target_desc *
6255 remote_read_description (struct target_ops *target)
6257 struct remote_g_packet_data *data
6258 = gdbarch_data (current_gdbarch, remote_g_packet_data_handle);
6260 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
6262 struct remote_g_packet_guess *guess;
6264 int bytes = send_g_packet ();
6267 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
6269 if (guess->bytes == bytes)
6270 return guess->tdesc;
6272 /* We discard the g packet. A minor optimization would be to
6273 hold on to it, and fill the register cache once we have selected
6274 an architecture, but it's too tricky to do safely. */
6281 init_remote_ops (void)
6283 remote_ops.to_shortname = "remote";
6284 remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
6286 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6287 Specify the serial device it is connected to\n\
6288 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6289 remote_ops.to_open = remote_open;
6290 remote_ops.to_close = remote_close;
6291 remote_ops.to_detach = remote_detach;
6292 remote_ops.to_disconnect = remote_disconnect;
6293 remote_ops.to_resume = remote_resume;
6294 remote_ops.to_wait = remote_wait;
6295 remote_ops.to_fetch_registers = remote_fetch_registers;
6296 remote_ops.to_store_registers = remote_store_registers;
6297 remote_ops.to_prepare_to_store = remote_prepare_to_store;
6298 remote_ops.deprecated_xfer_memory = remote_xfer_memory;
6299 remote_ops.to_files_info = remote_files_info;
6300 remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
6301 remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
6302 remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
6303 remote_ops.to_stopped_data_address = remote_stopped_data_address;
6304 remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
6305 remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
6306 remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
6307 remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
6308 remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
6309 remote_ops.to_kill = remote_kill;
6310 remote_ops.to_load = generic_load;
6311 remote_ops.to_mourn_inferior = remote_mourn;
6312 remote_ops.to_thread_alive = remote_thread_alive;
6313 remote_ops.to_find_new_threads = remote_threads_info;
6314 remote_ops.to_pid_to_str = remote_pid_to_str;
6315 remote_ops.to_extra_thread_info = remote_threads_extra_info;
6316 remote_ops.to_stop = remote_stop;
6317 remote_ops.to_xfer_partial = remote_xfer_partial;
6318 remote_ops.to_rcmd = remote_rcmd;
6319 remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
6320 remote_ops.to_stratum = process_stratum;
6321 remote_ops.to_has_all_memory = 1;
6322 remote_ops.to_has_memory = 1;
6323 remote_ops.to_has_stack = 1;
6324 remote_ops.to_has_registers = 1;
6325 remote_ops.to_has_execution = 1;
6326 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
6327 remote_ops.to_magic = OPS_MAGIC;
6328 remote_ops.to_memory_map = remote_memory_map;
6329 remote_ops.to_flash_erase = remote_flash_erase;
6330 remote_ops.to_flash_done = remote_flash_done;
6331 remote_ops.to_read_description = remote_read_description;
6334 /* Set up the extended remote vector by making a copy of the standard
6335 remote vector and adding to it. */
6338 init_extended_remote_ops (void)
6340 extended_remote_ops = remote_ops;
6342 extended_remote_ops.to_shortname = "extended-remote";
6343 extended_remote_ops.to_longname =
6344 "Extended remote serial target in gdb-specific protocol";
6345 extended_remote_ops.to_doc =
6346 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6347 Specify the serial device it is connected to (e.g. /dev/ttya).",
6348 extended_remote_ops.to_open = extended_remote_open;
6349 extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
6350 extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
6354 remote_can_async_p (void)
6356 /* We're async whenever the serial device is. */
6357 return (current_target.to_async_mask_value) && serial_can_async_p (remote_desc);
6361 remote_is_async_p (void)
6363 /* We're async whenever the serial device is. */
6364 return (current_target.to_async_mask_value) && serial_is_async_p (remote_desc);
6367 /* Pass the SERIAL event on and up to the client. One day this code
6368 will be able to delay notifying the client of an event until the
6369 point where an entire packet has been received. */
6371 static void (*async_client_callback) (enum inferior_event_type event_type,
6373 static void *async_client_context;
6374 static serial_event_ftype remote_async_serial_handler;
6377 remote_async_serial_handler (struct serial *scb, void *context)
6379 /* Don't propogate error information up to the client. Instead let
6380 the client find out about the error by querying the target. */
6381 async_client_callback (INF_REG_EVENT, async_client_context);
6385 remote_async (void (*callback) (enum inferior_event_type event_type,
6386 void *context), void *context)
6388 if (current_target.to_async_mask_value == 0)
6389 internal_error (__FILE__, __LINE__,
6390 _("Calling remote_async when async is masked"));
6392 if (callback != NULL)
6394 serial_async (remote_desc, remote_async_serial_handler, NULL);
6395 async_client_callback = callback;
6396 async_client_context = context;
6399 serial_async (remote_desc, NULL, NULL);
6402 /* Target async and target extended-async.
6404 This are temporary targets, until it is all tested. Eventually
6405 async support will be incorporated int the usual 'remote'
6409 init_remote_async_ops (void)
6411 remote_async_ops.to_shortname = "async";
6412 remote_async_ops.to_longname =
6413 "Remote serial target in async version of the gdb-specific protocol";
6414 remote_async_ops.to_doc =
6415 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6416 Specify the serial device it is connected to (e.g. /dev/ttya).";
6417 remote_async_ops.to_open = remote_async_open;
6418 remote_async_ops.to_close = remote_close;
6419 remote_async_ops.to_detach = remote_detach;
6420 remote_async_ops.to_disconnect = remote_disconnect;
6421 remote_async_ops.to_resume = remote_async_resume;
6422 remote_async_ops.to_wait = remote_async_wait;
6423 remote_async_ops.to_fetch_registers = remote_fetch_registers;
6424 remote_async_ops.to_store_registers = remote_store_registers;
6425 remote_async_ops.to_prepare_to_store = remote_prepare_to_store;
6426 remote_async_ops.deprecated_xfer_memory = remote_xfer_memory;
6427 remote_async_ops.to_files_info = remote_files_info;
6428 remote_async_ops.to_insert_breakpoint = remote_insert_breakpoint;
6429 remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
6430 remote_async_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
6431 remote_async_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
6432 remote_async_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
6433 remote_async_ops.to_insert_watchpoint = remote_insert_watchpoint;
6434 remote_async_ops.to_remove_watchpoint = remote_remove_watchpoint;
6435 remote_async_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
6436 remote_async_ops.to_stopped_data_address = remote_stopped_data_address;
6437 remote_async_ops.to_terminal_inferior = remote_async_terminal_inferior;
6438 remote_async_ops.to_terminal_ours = remote_async_terminal_ours;
6439 remote_async_ops.to_kill = remote_async_kill;
6440 remote_async_ops.to_load = generic_load;
6441 remote_async_ops.to_mourn_inferior = remote_async_mourn;
6442 remote_async_ops.to_thread_alive = remote_thread_alive;
6443 remote_async_ops.to_find_new_threads = remote_threads_info;
6444 remote_async_ops.to_pid_to_str = remote_pid_to_str;
6445 remote_async_ops.to_extra_thread_info = remote_threads_extra_info;
6446 remote_async_ops.to_stop = remote_stop;
6447 remote_async_ops.to_xfer_partial = remote_xfer_partial;
6448 remote_async_ops.to_rcmd = remote_rcmd;
6449 remote_async_ops.to_stratum = process_stratum;
6450 remote_async_ops.to_has_all_memory = 1;
6451 remote_async_ops.to_has_memory = 1;
6452 remote_async_ops.to_has_stack = 1;
6453 remote_async_ops.to_has_registers = 1;
6454 remote_async_ops.to_has_execution = 1;
6455 remote_async_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
6456 remote_async_ops.to_can_async_p = remote_can_async_p;
6457 remote_async_ops.to_is_async_p = remote_is_async_p;
6458 remote_async_ops.to_async = remote_async;
6459 remote_async_ops.to_async_mask_value = 1;
6460 remote_async_ops.to_magic = OPS_MAGIC;
6461 remote_async_ops.to_memory_map = remote_memory_map;
6462 remote_async_ops.to_flash_erase = remote_flash_erase;
6463 remote_async_ops.to_flash_done = remote_flash_done;
6464 remote_async_ops.to_read_description = remote_read_description;
6467 /* Set up the async extended remote vector by making a copy of the standard
6468 remote vector and adding to it. */
6471 init_extended_async_remote_ops (void)
6473 extended_async_remote_ops = remote_async_ops;
6475 extended_async_remote_ops.to_shortname = "extended-async";
6476 extended_async_remote_ops.to_longname =
6477 "Extended remote serial target in async gdb-specific protocol";
6478 extended_async_remote_ops.to_doc =
6479 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6480 Specify the serial device it is connected to (e.g. /dev/ttya).",
6481 extended_async_remote_ops.to_open = extended_remote_async_open;
6482 extended_async_remote_ops.to_create_inferior = extended_remote_async_create_inferior;
6483 extended_async_remote_ops.to_mourn_inferior = extended_remote_mourn;
6487 set_remote_cmd (char *args, int from_tty)
6489 help_list (remote_set_cmdlist, "set remote ", -1, gdb_stdout);
6493 show_remote_cmd (char *args, int from_tty)
6495 /* We can't just use cmd_show_list here, because we want to skip
6496 the redundant "show remote Z-packet" and the legacy aliases. */
6497 struct cleanup *showlist_chain;
6498 struct cmd_list_element *list = remote_show_cmdlist;
6500 showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
6501 for (; list != NULL; list = list->next)
6502 if (strcmp (list->name, "Z-packet") == 0)
6504 else if (list->type == not_set_cmd)
6505 /* Alias commands are exactly like the original, except they
6506 don't have the normal type. */
6510 struct cleanup *option_chain
6511 = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
6512 ui_out_field_string (uiout, "name", list->name);
6513 ui_out_text (uiout, ": ");
6514 if (list->type == show_cmd)
6515 do_setshow_command ((char *) NULL, from_tty, list);
6517 cmd_func (list, NULL, from_tty);
6518 /* Close the tuple. */
6519 do_cleanups (option_chain);
6522 /* Close the tuple. */
6523 do_cleanups (showlist_chain);
6527 /* Function to be called whenever a new objfile (shlib) is detected. */
6529 remote_new_objfile (struct objfile *objfile)
6531 if (remote_desc != 0) /* Have a remote connection. */
6532 remote_check_symbols (objfile);
6536 _initialize_remote (void)
6538 struct remote_state *rs;
6540 /* architecture specific data */
6541 remote_gdbarch_data_handle =
6542 gdbarch_data_register_post_init (init_remote_state);
6543 remote_g_packet_data_handle =
6544 gdbarch_data_register_pre_init (remote_g_packet_data_init);
6546 /* Initialize the per-target state. At the moment there is only one
6547 of these, not one per target. Only one target is active at a
6548 time. The default buffer size is unimportant; it will be expanded
6549 whenever a larger buffer is needed. */
6550 rs = get_remote_state_raw ();
6552 rs->buf = xmalloc (rs->buf_size);
6555 add_target (&remote_ops);
6557 init_extended_remote_ops ();
6558 add_target (&extended_remote_ops);
6560 init_remote_async_ops ();
6561 add_target (&remote_async_ops);
6563 init_extended_async_remote_ops ();
6564 add_target (&extended_async_remote_ops);
6566 /* Hook into new objfile notification. */
6567 observer_attach_new_objfile (remote_new_objfile);
6570 init_remote_threadtests ();
6573 /* set/show remote ... */
6575 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
6576 Remote protocol specific variables\n\
6577 Configure various remote-protocol specific variables such as\n\
6578 the packets being used"),
6579 &remote_set_cmdlist, "set remote ",
6580 0 /* allow-unknown */, &setlist);
6581 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
6582 Remote protocol specific variables\n\
6583 Configure various remote-protocol specific variables such as\n\
6584 the packets being used"),
6585 &remote_show_cmdlist, "show remote ",
6586 0 /* allow-unknown */, &showlist);
6588 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
6589 Compare section data on target to the exec file.\n\
6590 Argument is a single section name (default: all loaded sections)."),
6593 add_cmd ("packet", class_maintenance, packet_command, _("\
6594 Send an arbitrary packet to a remote target.\n\
6595 maintenance packet TEXT\n\
6596 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6597 this command sends the string TEXT to the inferior, and displays the\n\
6598 response packet. GDB supplies the initial `$' character, and the\n\
6599 terminating `#' character and checksum."),
6602 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
6603 Set whether to send break if interrupted."), _("\
6604 Show whether to send break if interrupted."), _("\
6605 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6606 NULL, NULL, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6607 &setlist, &showlist);
6609 /* Install commands for configuring memory read/write packets. */
6611 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
6612 Set the maximum number of bytes per memory write packet (deprecated)."),
6614 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
6615 Show the maximum number of bytes per memory write packet (deprecated)."),
6617 add_cmd ("memory-write-packet-size", no_class,
6618 set_memory_write_packet_size, _("\
6619 Set the maximum number of bytes per memory-write packet.\n\
6620 Specify the number of bytes in a packet or 0 (zero) for the\n\
6621 default packet size. The actual limit is further reduced\n\
6622 dependent on the target. Specify ``fixed'' to disable the\n\
6623 further restriction and ``limit'' to enable that restriction."),
6624 &remote_set_cmdlist);
6625 add_cmd ("memory-read-packet-size", no_class,
6626 set_memory_read_packet_size, _("\
6627 Set the maximum number of bytes per memory-read packet.\n\
6628 Specify the number of bytes in a packet or 0 (zero) for the\n\
6629 default packet size. The actual limit is further reduced\n\
6630 dependent on the target. Specify ``fixed'' to disable the\n\
6631 further restriction and ``limit'' to enable that restriction."),
6632 &remote_set_cmdlist);
6633 add_cmd ("memory-write-packet-size", no_class,
6634 show_memory_write_packet_size,
6635 _("Show the maximum number of bytes per memory-write packet."),
6636 &remote_show_cmdlist);
6637 add_cmd ("memory-read-packet-size", no_class,
6638 show_memory_read_packet_size,
6639 _("Show the maximum number of bytes per memory-read packet."),
6640 &remote_show_cmdlist);
6642 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class,
6643 &remote_hw_watchpoint_limit, _("\
6644 Set the maximum number of target hardware watchpoints."), _("\
6645 Show the maximum number of target hardware watchpoints."), _("\
6646 Specify a negative limit for unlimited."),
6647 NULL, NULL, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6648 &remote_set_cmdlist, &remote_show_cmdlist);
6649 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
6650 &remote_hw_breakpoint_limit, _("\
6651 Set the maximum number of target hardware breakpoints."), _("\
6652 Show the maximum number of target hardware breakpoints."), _("\
6653 Specify a negative limit for unlimited."),
6654 NULL, NULL, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6655 &remote_set_cmdlist, &remote_show_cmdlist);
6657 add_setshow_integer_cmd ("remoteaddresssize", class_obscure,
6658 &remote_address_size, _("\
6659 Set the maximum size of the address (in bits) in a memory packet."), _("\
6660 Show the maximum size of the address (in bits) in a memory packet."), NULL,
6662 NULL, /* FIXME: i18n: */
6663 &setlist, &showlist);
6665 add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
6666 "X", "binary-download", 1);
6668 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
6669 "vCont", "verbose-resume", 0);
6671 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
6672 "QPassSignals", "pass-signals", 0);
6674 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
6675 "qSymbol", "symbol-lookup", 0);
6677 add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
6678 "P", "set-register", 1);
6680 add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
6681 "p", "fetch-register", 1);
6683 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
6684 "Z0", "software-breakpoint", 0);
6686 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
6687 "Z1", "hardware-breakpoint", 0);
6689 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
6690 "Z2", "write-watchpoint", 0);
6692 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
6693 "Z3", "read-watchpoint", 0);
6695 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
6696 "Z4", "access-watchpoint", 0);
6698 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
6699 "qXfer:auxv:read", "read-aux-vector", 0);
6701 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features],
6702 "qXfer:features:read", "target-features", 0);
6704 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
6705 "qXfer:libraries:read", "library-info", 0);
6707 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
6708 "qXfer:memory-map:read", "memory-map", 0);
6710 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
6711 "qXfer:spu:read", "read-spu-object", 0);
6713 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
6714 "qXfer:spu:write", "write-spu-object", 0);
6716 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
6717 "qGetTLSAddr", "get-thread-local-storage-address",
6720 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
6721 "qSupported", "supported-packets", 0);
6723 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6724 Z sub-packet has its own set and show commands, but users may
6725 have sets to this variable in their .gdbinit files (or in their
6727 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
6728 &remote_Z_packet_detect, _("\
6729 Set use of remote protocol `Z' packets"), _("\
6730 Show use of remote protocol `Z' packets "), _("\
6731 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6733 set_remote_protocol_Z_packet_cmd,
6734 show_remote_protocol_Z_packet_cmd, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6735 &remote_set_cmdlist, &remote_show_cmdlist);
6737 /* Eventually initialize fileio. See fileio.c */
6738 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);