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, 2008
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"
61 #include "gdb/fileio.h"
63 #include "memory-map.h"
65 /* The size to align memory write packets, when practical. The protocol
66 does not guarantee any alignment, and gdb will generate short
67 writes and unaligned writes, but even as a best-effort attempt this
68 can improve bulk transfers. For instance, if a write is misaligned
69 relative to the target's data bus, the stub may need to make an extra
70 round trip fetching data from the target. This doesn't make a
71 huge difference, but it's easy to do, so we try to be helpful.
73 The alignment chosen is arbitrary; usually data bus width is
74 important here, not the possibly larger cache line size. */
75 enum { REMOTE_ALIGN_WRITES = 16 };
77 /* Prototypes for local functions. */
78 static void cleanup_sigint_signal_handler (void *dummy);
79 static void initialize_sigint_signal_handler (void);
80 static int getpkt_sane (char **buf, long *sizeof_buf, int forever);
82 static void handle_remote_sigint (int);
83 static void handle_remote_sigint_twice (int);
84 static void async_remote_interrupt (gdb_client_data);
85 void async_remote_interrupt_twice (gdb_client_data);
87 static void remote_files_info (struct target_ops *ignore);
89 static void remote_prepare_to_store (struct regcache *regcache);
91 static void remote_fetch_registers (struct regcache *regcache, int regno);
93 static void remote_resume (ptid_t ptid, int step,
94 enum target_signal siggnal);
95 static void remote_async_resume (ptid_t ptid, int step,
96 enum target_signal siggnal);
97 static void remote_open (char *name, int from_tty);
98 static void remote_async_open (char *name, int from_tty);
100 static void extended_remote_open (char *name, int from_tty);
101 static void extended_remote_async_open (char *name, int from_tty);
103 static void remote_open_1 (char *, int, struct target_ops *, int extended_p,
106 static void remote_close (int quitting);
108 static void remote_store_registers (struct regcache *regcache, int regno);
110 static void remote_mourn (void);
111 static void remote_async_mourn (void);
113 static void extended_remote_restart (void);
115 static void extended_remote_mourn (void);
117 static void remote_mourn_1 (struct target_ops *);
119 static void remote_send (char **buf, long *sizeof_buf_p);
121 static int readchar (int timeout);
123 static ptid_t remote_wait (ptid_t ptid,
124 struct target_waitstatus *status);
125 static ptid_t remote_async_wait (ptid_t ptid,
126 struct target_waitstatus *status);
128 static void remote_kill (void);
129 static void remote_async_kill (void);
131 static int tohex (int nib);
133 static void remote_detach (char *args, int from_tty);
135 static void remote_interrupt (int signo);
137 static void remote_interrupt_twice (int signo);
139 static void interrupt_query (void);
141 static void set_thread (int, int);
143 static int remote_thread_alive (ptid_t);
145 static void get_offsets (void);
147 static void skip_frame (void);
149 static long read_frame (char **buf_p, long *sizeof_buf);
151 static int hexnumlen (ULONGEST num);
153 static void init_remote_ops (void);
155 static void init_extended_remote_ops (void);
157 static void remote_stop (void);
159 static int ishex (int ch, int *val);
161 static int stubhex (int ch);
163 static int hexnumstr (char *, ULONGEST);
165 static int hexnumnstr (char *, ULONGEST, int);
167 static CORE_ADDR remote_address_masked (CORE_ADDR);
169 static void print_packet (char *);
171 static unsigned long crc32 (unsigned char *, int, unsigned int);
173 static void compare_sections_command (char *, int);
175 static void packet_command (char *, int);
177 static int stub_unpack_int (char *buff, int fieldlength);
179 static ptid_t remote_current_thread (ptid_t oldptid);
181 static void remote_find_new_threads (void);
183 static void record_currthread (int currthread);
185 static int fromhex (int a);
187 static int hex2bin (const char *hex, gdb_byte *bin, int count);
189 static int bin2hex (const gdb_byte *bin, char *hex, int count);
191 static int putpkt_binary (char *buf, int cnt);
193 static void check_binary_download (CORE_ADDR addr);
195 struct packet_config;
197 static void show_packet_config_cmd (struct packet_config *config);
199 static void update_packet_config (struct packet_config *config);
201 static void set_remote_protocol_packet_cmd (char *args, int from_tty,
202 struct cmd_list_element *c);
204 static void show_remote_protocol_packet_cmd (struct ui_file *file,
206 struct cmd_list_element *c,
209 void _initialize_remote (void);
213 static struct cmd_list_element *remote_cmdlist;
215 /* For "set remote" and "show remote". */
217 static struct cmd_list_element *remote_set_cmdlist;
218 static struct cmd_list_element *remote_show_cmdlist;
220 /* Description of the remote protocol state for the currently
221 connected target. This is per-target state, and independent of the
222 selected architecture. */
226 /* A buffer to use for incoming packets, and its current size. The
227 buffer is grown dynamically for larger incoming packets.
228 Outgoing packets may also be constructed in this buffer.
229 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
230 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
235 /* If we negotiated packet size explicitly (and thus can bypass
236 heuristics for the largest packet size that will not overflow
237 a buffer in the stub), this will be set to that packet size.
238 Otherwise zero, meaning to use the guessed size. */
239 long explicit_packet_size;
241 /* remote_wait is normally called when the target is running and
242 waits for a stop reply packet. But sometimes we need to call it
243 when the target is already stopped. We can send a "?" packet
244 and have remote_wait read the response. Or, if we already have
245 the response, we can stash it in BUF and tell remote_wait to
246 skip calling getpkt. This flag is set when BUF contains a
247 stop reply packet and the target is not waiting. */
248 int cached_wait_status;
251 /* This data could be associated with a target, but we do not always
252 have access to the current target when we need it, so for now it is
253 static. This will be fine for as long as only one target is in use
255 static struct remote_state remote_state;
257 static struct remote_state *
258 get_remote_state_raw (void)
260 return &remote_state;
263 /* Description of the remote protocol for a given architecture. */
267 long offset; /* Offset into G packet. */
268 long regnum; /* GDB's internal register number. */
269 LONGEST pnum; /* Remote protocol register number. */
270 int in_g_packet; /* Always part of G packet. */
271 /* long size in bytes; == register_size (current_gdbarch, regnum);
273 /* char *name; == gdbarch_register_name (current_gdbarch, regnum);
277 struct remote_arch_state
279 /* Description of the remote protocol registers. */
280 long sizeof_g_packet;
282 /* Description of the remote protocol registers indexed by REGNUM
283 (making an array gdbarch_num_regs in size). */
284 struct packet_reg *regs;
286 /* This is the size (in chars) of the first response to the ``g''
287 packet. It is used as a heuristic when determining the maximum
288 size of memory-read and memory-write packets. A target will
289 typically only reserve a buffer large enough to hold the ``g''
290 packet. The size does not include packet overhead (headers and
292 long actual_register_packet_size;
294 /* This is the maximum size (in chars) of a non read/write packet.
295 It is also used as a cap on the size of read/write packets. */
296 long remote_packet_size;
300 /* Handle for retreving the remote protocol data from gdbarch. */
301 static struct gdbarch_data *remote_gdbarch_data_handle;
303 static struct remote_arch_state *
304 get_remote_arch_state (void)
306 return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
309 /* Fetch the global remote target state. */
311 static struct remote_state *
312 get_remote_state (void)
314 /* Make sure that the remote architecture state has been
315 initialized, because doing so might reallocate rs->buf. Any
316 function which calls getpkt also needs to be mindful of changes
317 to rs->buf, but this call limits the number of places which run
319 get_remote_arch_state ();
321 return get_remote_state_raw ();
325 compare_pnums (const void *lhs_, const void *rhs_)
327 const struct packet_reg * const *lhs = lhs_;
328 const struct packet_reg * const *rhs = rhs_;
330 if ((*lhs)->pnum < (*rhs)->pnum)
332 else if ((*lhs)->pnum == (*rhs)->pnum)
339 init_remote_state (struct gdbarch *gdbarch)
341 int regnum, num_remote_regs, offset;
342 struct remote_state *rs = get_remote_state_raw ();
343 struct remote_arch_state *rsa;
344 struct packet_reg **remote_regs;
346 rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
348 /* Use the architecture to build a regnum<->pnum table, which will be
349 1:1 unless a feature set specifies otherwise. */
350 rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,
351 gdbarch_num_regs (gdbarch),
353 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
355 struct packet_reg *r = &rsa->regs[regnum];
357 if (register_size (gdbarch, regnum) == 0)
358 /* Do not try to fetch zero-sized (placeholder) registers. */
361 r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
366 /* Define the g/G packet format as the contents of each register
367 with a remote protocol number, in order of ascending protocol
370 remote_regs = alloca (gdbarch_num_regs (gdbarch)
371 * sizeof (struct packet_reg *));
372 for (num_remote_regs = 0, regnum = 0;
373 regnum < gdbarch_num_regs (gdbarch);
375 if (rsa->regs[regnum].pnum != -1)
376 remote_regs[num_remote_regs++] = &rsa->regs[regnum];
378 qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
381 for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
383 remote_regs[regnum]->in_g_packet = 1;
384 remote_regs[regnum]->offset = offset;
385 offset += register_size (gdbarch, remote_regs[regnum]->regnum);
388 /* Record the maximum possible size of the g packet - it may turn out
390 rsa->sizeof_g_packet = offset;
392 /* Default maximum number of characters in a packet body. Many
393 remote stubs have a hardwired buffer size of 400 bytes
394 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
395 as the maximum packet-size to ensure that the packet and an extra
396 NUL character can always fit in the buffer. This stops GDB
397 trashing stubs that try to squeeze an extra NUL into what is
398 already a full buffer (As of 1999-12-04 that was most stubs). */
399 rsa->remote_packet_size = 400 - 1;
401 /* This one is filled in when a ``g'' packet is received. */
402 rsa->actual_register_packet_size = 0;
404 /* Should rsa->sizeof_g_packet needs more space than the
405 default, adjust the size accordingly. Remember that each byte is
406 encoded as two characters. 32 is the overhead for the packet
407 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
408 (``$NN:G...#NN'') is a better guess, the below has been padded a
410 if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
411 rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
413 /* Make sure that the packet buffer is plenty big enough for
414 this architecture. */
415 if (rs->buf_size < rsa->remote_packet_size)
417 rs->buf_size = 2 * rsa->remote_packet_size;
418 rs->buf = xrealloc (rs->buf, rs->buf_size);
424 /* Return the current allowed size of a remote packet. This is
425 inferred from the current architecture, and should be used to
426 limit the length of outgoing packets. */
428 get_remote_packet_size (void)
430 struct remote_state *rs = get_remote_state ();
431 struct remote_arch_state *rsa = get_remote_arch_state ();
433 if (rs->explicit_packet_size)
434 return rs->explicit_packet_size;
436 return rsa->remote_packet_size;
439 static struct packet_reg *
440 packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
442 if (regnum < 0 && regnum >= gdbarch_num_regs (current_gdbarch))
446 struct packet_reg *r = &rsa->regs[regnum];
447 gdb_assert (r->regnum == regnum);
452 static struct packet_reg *
453 packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
456 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
458 struct packet_reg *r = &rsa->regs[i];
465 /* FIXME: graces/2002-08-08: These variables should eventually be
466 bound to an instance of the target object (as in gdbarch-tdep()),
467 when such a thing exists. */
469 /* This is set to the data address of the access causing the target
470 to stop for a watchpoint. */
471 static CORE_ADDR remote_watch_data_address;
473 /* This is non-zero if target stopped for a watchpoint. */
474 static int remote_stopped_by_watchpoint_p;
476 static struct target_ops remote_ops;
478 static struct target_ops extended_remote_ops;
480 /* Temporary target ops. Just like the remote_ops and
481 extended_remote_ops, but with asynchronous support. */
482 static struct target_ops remote_async_ops;
484 static int remote_async_mask_value = 1;
486 static struct target_ops extended_async_remote_ops;
488 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
489 ``forever'' still use the normal timeout mechanism. This is
490 currently used by the ASYNC code to guarentee that target reads
491 during the initial connect always time-out. Once getpkt has been
492 modified to return a timeout indication and, in turn
493 remote_wait()/wait_for_inferior() have gained a timeout parameter
495 static int wait_forever_enabled_p = 1;
498 /* This variable chooses whether to send a ^C or a break when the user
499 requests program interruption. Although ^C is usually what remote
500 systems expect, and that is the default here, sometimes a break is
501 preferable instead. */
503 static int remote_break;
505 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
506 remote_open knows that we don't have a file open when the program
508 static struct serial *remote_desc = NULL;
510 /* This variable sets the number of bits in an address that are to be
511 sent in a memory ("M" or "m") packet. Normally, after stripping
512 leading zeros, the entire address would be sent. This variable
513 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
514 initial implementation of remote.c restricted the address sent in
515 memory packets to ``host::sizeof long'' bytes - (typically 32
516 bits). Consequently, for 64 bit targets, the upper 32 bits of an
517 address was never sent. Since fixing this bug may cause a break in
518 some remote targets this variable is principly provided to
519 facilitate backward compatibility. */
521 static int remote_address_size;
523 /* Tempoary to track who currently owns the terminal. See
524 target_async_terminal_* for more details. */
526 static int remote_async_terminal_ours_p;
528 /* The executable file to use for "run" on the remote side. */
530 static char *remote_exec_file = "";
533 /* User configurable variables for the number of characters in a
534 memory read/write packet. MIN (rsa->remote_packet_size,
535 rsa->sizeof_g_packet) is the default. Some targets need smaller
536 values (fifo overruns, et.al.) and some users need larger values
537 (speed up transfers). The variables ``preferred_*'' (the user
538 request), ``current_*'' (what was actually set) and ``forced_*''
539 (Positive - a soft limit, negative - a hard limit). */
541 struct memory_packet_config
548 /* Compute the current size of a read/write packet. Since this makes
549 use of ``actual_register_packet_size'' the computation is dynamic. */
552 get_memory_packet_size (struct memory_packet_config *config)
554 struct remote_state *rs = get_remote_state ();
555 struct remote_arch_state *rsa = get_remote_arch_state ();
557 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
558 law?) that some hosts don't cope very well with large alloca()
559 calls. Eventually the alloca() code will be replaced by calls to
560 xmalloc() and make_cleanups() allowing this restriction to either
561 be lifted or removed. */
562 #ifndef MAX_REMOTE_PACKET_SIZE
563 #define MAX_REMOTE_PACKET_SIZE 16384
565 /* NOTE: 20 ensures we can write at least one byte. */
566 #ifndef MIN_REMOTE_PACKET_SIZE
567 #define MIN_REMOTE_PACKET_SIZE 20
572 if (config->size <= 0)
573 what_they_get = MAX_REMOTE_PACKET_SIZE;
575 what_they_get = config->size;
579 what_they_get = get_remote_packet_size ();
580 /* Limit the packet to the size specified by the user. */
582 && what_they_get > config->size)
583 what_they_get = config->size;
585 /* Limit it to the size of the targets ``g'' response unless we have
586 permission from the stub to use a larger packet size. */
587 if (rs->explicit_packet_size == 0
588 && rsa->actual_register_packet_size > 0
589 && what_they_get > rsa->actual_register_packet_size)
590 what_they_get = rsa->actual_register_packet_size;
592 if (what_they_get > MAX_REMOTE_PACKET_SIZE)
593 what_they_get = MAX_REMOTE_PACKET_SIZE;
594 if (what_they_get < MIN_REMOTE_PACKET_SIZE)
595 what_they_get = MIN_REMOTE_PACKET_SIZE;
597 /* Make sure there is room in the global buffer for this packet
598 (including its trailing NUL byte). */
599 if (rs->buf_size < what_they_get + 1)
601 rs->buf_size = 2 * what_they_get;
602 rs->buf = xrealloc (rs->buf, 2 * what_they_get);
605 return what_they_get;
608 /* Update the size of a read/write packet. If they user wants
609 something really big then do a sanity check. */
612 set_memory_packet_size (char *args, struct memory_packet_config *config)
614 int fixed_p = config->fixed_p;
615 long size = config->size;
617 error (_("Argument required (integer, `fixed' or `limited')."));
618 else if (strcmp (args, "hard") == 0
619 || strcmp (args, "fixed") == 0)
621 else if (strcmp (args, "soft") == 0
622 || strcmp (args, "limit") == 0)
627 size = strtoul (args, &end, 0);
629 error (_("Invalid %s (bad syntax)."), config->name);
631 /* Instead of explicitly capping the size of a packet to
632 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
633 instead allowed to set the size to something arbitrarily
635 if (size > MAX_REMOTE_PACKET_SIZE)
636 error (_("Invalid %s (too large)."), config->name);
640 if (fixed_p && !config->fixed_p)
642 if (! query (_("The target may not be able to correctly handle a %s\n"
643 "of %ld bytes. Change the packet size? "),
645 error (_("Packet size not changed."));
647 /* Update the config. */
648 config->fixed_p = fixed_p;
653 show_memory_packet_size (struct memory_packet_config *config)
655 printf_filtered (_("The %s is %ld. "), config->name, config->size);
657 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
658 get_memory_packet_size (config));
660 printf_filtered (_("Packets are limited to %ld bytes.\n"),
661 get_memory_packet_size (config));
664 static struct memory_packet_config memory_write_packet_config =
666 "memory-write-packet-size",
670 set_memory_write_packet_size (char *args, int from_tty)
672 set_memory_packet_size (args, &memory_write_packet_config);
676 show_memory_write_packet_size (char *args, int from_tty)
678 show_memory_packet_size (&memory_write_packet_config);
682 get_memory_write_packet_size (void)
684 return get_memory_packet_size (&memory_write_packet_config);
687 static struct memory_packet_config memory_read_packet_config =
689 "memory-read-packet-size",
693 set_memory_read_packet_size (char *args, int from_tty)
695 set_memory_packet_size (args, &memory_read_packet_config);
699 show_memory_read_packet_size (char *args, int from_tty)
701 show_memory_packet_size (&memory_read_packet_config);
705 get_memory_read_packet_size (void)
707 long size = get_memory_packet_size (&memory_read_packet_config);
708 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
709 extra buffer size argument before the memory read size can be
710 increased beyond this. */
711 if (size > get_remote_packet_size ())
712 size = get_remote_packet_size ();
717 /* Generic configuration support for packets the stub optionally
718 supports. Allows the user to specify the use of the packet as well
719 as allowing GDB to auto-detect support in the remote stub. */
723 PACKET_SUPPORT_UNKNOWN = 0,
732 enum auto_boolean detect;
733 enum packet_support support;
736 /* Analyze a packet's return value and update the packet config
747 update_packet_config (struct packet_config *config)
749 switch (config->detect)
751 case AUTO_BOOLEAN_TRUE:
752 config->support = PACKET_ENABLE;
754 case AUTO_BOOLEAN_FALSE:
755 config->support = PACKET_DISABLE;
757 case AUTO_BOOLEAN_AUTO:
758 config->support = PACKET_SUPPORT_UNKNOWN;
764 show_packet_config_cmd (struct packet_config *config)
766 char *support = "internal-error";
767 switch (config->support)
773 support = "disabled";
775 case PACKET_SUPPORT_UNKNOWN:
779 switch (config->detect)
781 case AUTO_BOOLEAN_AUTO:
782 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
783 config->name, support);
785 case AUTO_BOOLEAN_TRUE:
786 case AUTO_BOOLEAN_FALSE:
787 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
788 config->name, support);
794 add_packet_config_cmd (struct packet_config *config, const char *name,
795 const char *title, int legacy)
802 config->title = title;
803 config->detect = AUTO_BOOLEAN_AUTO;
804 config->support = PACKET_SUPPORT_UNKNOWN;
805 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
807 show_doc = xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
809 /* set/show TITLE-packet {auto,on,off} */
810 cmd_name = xstrprintf ("%s-packet", title);
811 add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
812 &config->detect, set_doc, show_doc, NULL, /* help_doc */
813 set_remote_protocol_packet_cmd,
814 show_remote_protocol_packet_cmd,
815 &remote_set_cmdlist, &remote_show_cmdlist);
816 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
820 legacy_name = xstrprintf ("%s-packet", name);
821 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
822 &remote_set_cmdlist);
823 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
824 &remote_show_cmdlist);
828 static enum packet_result
829 packet_check_result (const char *buf)
833 /* The stub recognized the packet request. Check that the
834 operation succeeded. */
836 && isxdigit (buf[1]) && isxdigit (buf[2])
838 /* "Enn" - definitly an error. */
841 /* Always treat "E." as an error. This will be used for
842 more verbose error messages, such as E.memtypes. */
843 if (buf[0] == 'E' && buf[1] == '.')
846 /* The packet may or may not be OK. Just assume it is. */
850 /* The stub does not support the packet. */
851 return PACKET_UNKNOWN;
854 static enum packet_result
855 packet_ok (const char *buf, struct packet_config *config)
857 enum packet_result result;
859 result = packet_check_result (buf);
864 /* The stub recognized the packet request. */
865 switch (config->support)
867 case PACKET_SUPPORT_UNKNOWN:
869 fprintf_unfiltered (gdb_stdlog,
870 "Packet %s (%s) is supported\n",
871 config->name, config->title);
872 config->support = PACKET_ENABLE;
875 internal_error (__FILE__, __LINE__,
876 _("packet_ok: attempt to use a disabled packet"));
883 /* The stub does not support the packet. */
884 switch (config->support)
887 if (config->detect == AUTO_BOOLEAN_AUTO)
888 /* If the stub previously indicated that the packet was
889 supported then there is a protocol error.. */
890 error (_("Protocol error: %s (%s) conflicting enabled responses."),
891 config->name, config->title);
893 /* The user set it wrong. */
894 error (_("Enabled packet %s (%s) not recognized by stub"),
895 config->name, config->title);
897 case PACKET_SUPPORT_UNKNOWN:
899 fprintf_unfiltered (gdb_stdlog,
900 "Packet %s (%s) is NOT supported\n",
901 config->name, config->title);
902 config->support = PACKET_DISABLE;
930 PACKET_qXfer_features,
931 PACKET_qXfer_libraries,
932 PACKET_qXfer_memory_map,
933 PACKET_qXfer_spu_read,
934 PACKET_qXfer_spu_write,
938 PACKET_qSearch_memory,
944 static struct packet_config remote_protocol_packets[PACKET_MAX];
947 set_remote_protocol_packet_cmd (char *args, int from_tty,
948 struct cmd_list_element *c)
950 struct packet_config *packet;
952 for (packet = remote_protocol_packets;
953 packet < &remote_protocol_packets[PACKET_MAX];
956 if (&packet->detect == c->var)
958 update_packet_config (packet);
962 internal_error (__FILE__, __LINE__, "Could not find config for %s",
967 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
968 struct cmd_list_element *c,
971 struct packet_config *packet;
973 for (packet = remote_protocol_packets;
974 packet < &remote_protocol_packets[PACKET_MAX];
977 if (&packet->detect == c->var)
979 show_packet_config_cmd (packet);
983 internal_error (__FILE__, __LINE__, "Could not find config for %s",
987 /* Should we try one of the 'Z' requests? */
991 Z_PACKET_SOFTWARE_BP,
992 Z_PACKET_HARDWARE_BP,
999 /* For compatibility with older distributions. Provide a ``set remote
1000 Z-packet ...'' command that updates all the Z packet types. */
1002 static enum auto_boolean remote_Z_packet_detect;
1005 set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
1006 struct cmd_list_element *c)
1009 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1011 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
1012 update_packet_config (&remote_protocol_packets[PACKET_Z0 + i]);
1017 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
1018 struct cmd_list_element *c,
1022 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1024 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
1028 /* Should we try the 'ThreadInfo' query packet?
1030 This variable (NOT available to the user: auto-detect only!)
1031 determines whether GDB will use the new, simpler "ThreadInfo"
1032 query or the older, more complex syntax for thread queries.
1033 This is an auto-detect variable (set to true at each connect,
1034 and set to false when the target fails to recognize it). */
1036 static int use_threadinfo_query;
1037 static int use_threadextra_query;
1039 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1040 static struct async_signal_handler *sigint_remote_twice_token;
1041 static struct async_signal_handler *sigint_remote_token;
1046 /* These are the threads which we last sent to the remote system.
1047 -1 for all or -2 for not sent yet. */
1048 static int general_thread;
1049 static int continue_thread;
1051 /* Call this function as a result of
1052 1) A halt indication (T packet) containing a thread id
1053 2) A direct query of currthread
1054 3) Successful execution of set thread
1058 record_currthread (int currthread)
1060 general_thread = currthread;
1062 /* If this is a new thread, add it to GDB's thread list.
1063 If we leave it up to WFI to do this, bad things will happen. */
1064 if (!in_thread_list (pid_to_ptid (currthread)))
1065 add_thread (pid_to_ptid (currthread));
1068 static char *last_pass_packet;
1070 /* If 'QPassSignals' is supported, tell the remote stub what signals
1071 it can simply pass through to the inferior without reporting. */
1074 remote_pass_signals (void)
1076 if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE)
1078 char *pass_packet, *p;
1079 int numsigs = (int) TARGET_SIGNAL_LAST;
1082 gdb_assert (numsigs < 256);
1083 for (i = 0; i < numsigs; i++)
1085 if (signal_stop_state (i) == 0
1086 && signal_print_state (i) == 0
1087 && signal_pass_state (i) == 1)
1090 pass_packet = xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
1091 strcpy (pass_packet, "QPassSignals:");
1092 p = pass_packet + strlen (pass_packet);
1093 for (i = 0; i < numsigs; i++)
1095 if (signal_stop_state (i) == 0
1096 && signal_print_state (i) == 0
1097 && signal_pass_state (i) == 1)
1100 *p++ = tohex (i >> 4);
1101 *p++ = tohex (i & 15);
1110 if (!last_pass_packet || strcmp (last_pass_packet, pass_packet))
1112 struct remote_state *rs = get_remote_state ();
1113 char *buf = rs->buf;
1115 putpkt (pass_packet);
1116 getpkt (&rs->buf, &rs->buf_size, 0);
1117 packet_ok (buf, &remote_protocol_packets[PACKET_QPassSignals]);
1118 if (last_pass_packet)
1119 xfree (last_pass_packet);
1120 last_pass_packet = pass_packet;
1123 xfree (pass_packet);
1127 #define MAGIC_NULL_PID 42000
1130 set_thread (int th, int gen)
1132 struct remote_state *rs = get_remote_state ();
1133 char *buf = rs->buf;
1134 int state = gen ? general_thread : continue_thread;
1140 buf[1] = gen ? 'g' : 'c';
1141 if (th == MAGIC_NULL_PID)
1147 xsnprintf (&buf[2], get_remote_packet_size () - 2, "-%x", -th);
1149 xsnprintf (&buf[2], get_remote_packet_size () - 2, "%x", th);
1151 getpkt (&rs->buf, &rs->buf_size, 0);
1153 general_thread = th;
1155 continue_thread = th;
1158 /* Return nonzero if the thread TH is still alive on the remote system. */
1161 remote_thread_alive (ptid_t ptid)
1163 struct remote_state *rs = get_remote_state ();
1164 int tid = PIDGET (ptid);
1167 xsnprintf (rs->buf, get_remote_packet_size (), "T-%08x", -tid);
1169 xsnprintf (rs->buf, get_remote_packet_size (), "T%08x", tid);
1171 getpkt (&rs->buf, &rs->buf_size, 0);
1172 return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
1175 /* About these extended threadlist and threadinfo packets. They are
1176 variable length packets but, the fields within them are often fixed
1177 length. They are redundent enough to send over UDP as is the
1178 remote protocol in general. There is a matching unit test module
1181 #define OPAQUETHREADBYTES 8
1183 /* a 64 bit opaque identifier */
1184 typedef unsigned char threadref[OPAQUETHREADBYTES];
1186 /* WARNING: This threadref data structure comes from the remote O.S.,
1187 libstub protocol encoding, and remote.c. it is not particularly
1190 /* Right now, the internal structure is int. We want it to be bigger.
1194 typedef int gdb_threadref; /* Internal GDB thread reference. */
1196 /* gdb_ext_thread_info is an internal GDB data structure which is
1197 equivalent to the reply of the remote threadinfo packet. */
1199 struct gdb_ext_thread_info
1201 threadref threadid; /* External form of thread reference. */
1202 int active; /* Has state interesting to GDB?
1204 char display[256]; /* Brief state display, name,
1205 blocked/suspended. */
1206 char shortname[32]; /* To be used to name threads. */
1207 char more_display[256]; /* Long info, statistics, queue depth,
1211 /* The volume of remote transfers can be limited by submitting
1212 a mask containing bits specifying the desired information.
1213 Use a union of these values as the 'selection' parameter to
1214 get_thread_info. FIXME: Make these TAG names more thread specific.
1217 #define TAG_THREADID 1
1218 #define TAG_EXISTS 2
1219 #define TAG_DISPLAY 4
1220 #define TAG_THREADNAME 8
1221 #define TAG_MOREDISPLAY 16
1223 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1225 char *unpack_varlen_hex (char *buff, ULONGEST *result);
1227 static char *unpack_nibble (char *buf, int *val);
1229 static char *pack_nibble (char *buf, int nibble);
1231 static char *pack_hex_byte (char *pkt, int /* unsigned char */ byte);
1233 static char *unpack_byte (char *buf, int *value);
1235 static char *pack_int (char *buf, int value);
1237 static char *unpack_int (char *buf, int *value);
1239 static char *unpack_string (char *src, char *dest, int length);
1241 static char *pack_threadid (char *pkt, threadref *id);
1243 static char *unpack_threadid (char *inbuf, threadref *id);
1245 void int_to_threadref (threadref *id, int value);
1247 static int threadref_to_int (threadref *ref);
1249 static void copy_threadref (threadref *dest, threadref *src);
1251 static int threadmatch (threadref *dest, threadref *src);
1253 static char *pack_threadinfo_request (char *pkt, int mode,
1256 static int remote_unpack_thread_info_response (char *pkt,
1257 threadref *expectedref,
1258 struct gdb_ext_thread_info
1262 static int remote_get_threadinfo (threadref *threadid,
1263 int fieldset, /*TAG mask */
1264 struct gdb_ext_thread_info *info);
1266 static char *pack_threadlist_request (char *pkt, int startflag,
1268 threadref *nextthread);
1270 static int parse_threadlist_response (char *pkt,
1272 threadref *original_echo,
1273 threadref *resultlist,
1276 static int remote_get_threadlist (int startflag,
1277 threadref *nextthread,
1281 threadref *threadlist);
1283 typedef int (*rmt_thread_action) (threadref *ref, void *context);
1285 static int remote_threadlist_iterator (rmt_thread_action stepfunction,
1286 void *context, int looplimit);
1288 static int remote_newthread_step (threadref *ref, void *context);
1290 /* Encode 64 bits in 16 chars of hex. */
1292 static const char hexchars[] = "0123456789abcdef";
1295 ishex (int ch, int *val)
1297 if ((ch >= 'a') && (ch <= 'f'))
1299 *val = ch - 'a' + 10;
1302 if ((ch >= 'A') && (ch <= 'F'))
1304 *val = ch - 'A' + 10;
1307 if ((ch >= '0') && (ch <= '9'))
1318 if (ch >= 'a' && ch <= 'f')
1319 return ch - 'a' + 10;
1320 if (ch >= '0' && ch <= '9')
1322 if (ch >= 'A' && ch <= 'F')
1323 return ch - 'A' + 10;
1328 stub_unpack_int (char *buff, int fieldlength)
1335 nibble = stubhex (*buff++);
1339 retval = retval << 4;
1345 unpack_varlen_hex (char *buff, /* packet to parse */
1349 ULONGEST retval = 0;
1351 while (ishex (*buff, &nibble))
1354 retval = retval << 4;
1355 retval |= nibble & 0x0f;
1362 unpack_nibble (char *buf, int *val)
1364 *val = fromhex (*buf++);
1369 pack_nibble (char *buf, int nibble)
1371 *buf++ = hexchars[(nibble & 0x0f)];
1376 pack_hex_byte (char *pkt, int byte)
1378 *pkt++ = hexchars[(byte >> 4) & 0xf];
1379 *pkt++ = hexchars[(byte & 0xf)];
1384 unpack_byte (char *buf, int *value)
1386 *value = stub_unpack_int (buf, 2);
1391 pack_int (char *buf, int value)
1393 buf = pack_hex_byte (buf, (value >> 24) & 0xff);
1394 buf = pack_hex_byte (buf, (value >> 16) & 0xff);
1395 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
1396 buf = pack_hex_byte (buf, (value & 0xff));
1401 unpack_int (char *buf, int *value)
1403 *value = stub_unpack_int (buf, 8);
1407 #if 0 /* Currently unused, uncomment when needed. */
1408 static char *pack_string (char *pkt, char *string);
1411 pack_string (char *pkt, char *string)
1416 len = strlen (string);
1418 len = 200; /* Bigger than most GDB packets, junk??? */
1419 pkt = pack_hex_byte (pkt, len);
1423 if ((ch == '\0') || (ch == '#'))
1424 ch = '*'; /* Protect encapsulation. */
1429 #endif /* 0 (unused) */
1432 unpack_string (char *src, char *dest, int length)
1441 pack_threadid (char *pkt, threadref *id)
1444 unsigned char *altid;
1446 altid = (unsigned char *) id;
1447 limit = pkt + BUF_THREAD_ID_SIZE;
1449 pkt = pack_hex_byte (pkt, *altid++);
1455 unpack_threadid (char *inbuf, threadref *id)
1458 char *limit = inbuf + BUF_THREAD_ID_SIZE;
1461 altref = (char *) id;
1463 while (inbuf < limit)
1465 x = stubhex (*inbuf++);
1466 y = stubhex (*inbuf++);
1467 *altref++ = (x << 4) | y;
1472 /* Externally, threadrefs are 64 bits but internally, they are still
1473 ints. This is due to a mismatch of specifications. We would like
1474 to use 64bit thread references internally. This is an adapter
1478 int_to_threadref (threadref *id, int value)
1480 unsigned char *scan;
1482 scan = (unsigned char *) id;
1488 *scan++ = (value >> 24) & 0xff;
1489 *scan++ = (value >> 16) & 0xff;
1490 *scan++ = (value >> 8) & 0xff;
1491 *scan++ = (value & 0xff);
1495 threadref_to_int (threadref *ref)
1498 unsigned char *scan;
1504 value = (value << 8) | ((*scan++) & 0xff);
1509 copy_threadref (threadref *dest, threadref *src)
1512 unsigned char *csrc, *cdest;
1514 csrc = (unsigned char *) src;
1515 cdest = (unsigned char *) dest;
1522 threadmatch (threadref *dest, threadref *src)
1524 /* Things are broken right now, so just assume we got a match. */
1526 unsigned char *srcp, *destp;
1528 srcp = (char *) src;
1529 destp = (char *) dest;
1533 result &= (*srcp++ == *destp++) ? 1 : 0;
1540 threadid:1, # always request threadid
1547 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1550 pack_threadinfo_request (char *pkt, int mode, threadref *id)
1552 *pkt++ = 'q'; /* Info Query */
1553 *pkt++ = 'P'; /* process or thread info */
1554 pkt = pack_int (pkt, mode); /* mode */
1555 pkt = pack_threadid (pkt, id); /* threadid */
1556 *pkt = '\0'; /* terminate */
1560 /* These values tag the fields in a thread info response packet. */
1561 /* Tagging the fields allows us to request specific fields and to
1562 add more fields as time goes by. */
1564 #define TAG_THREADID 1 /* Echo the thread identifier. */
1565 #define TAG_EXISTS 2 /* Is this process defined enough to
1566 fetch registers and its stack? */
1567 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1568 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1569 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1573 remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
1574 struct gdb_ext_thread_info *info)
1576 struct remote_state *rs = get_remote_state ();
1580 char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */
1583 /* info->threadid = 0; FIXME: implement zero_threadref. */
1585 info->display[0] = '\0';
1586 info->shortname[0] = '\0';
1587 info->more_display[0] = '\0';
1589 /* Assume the characters indicating the packet type have been
1591 pkt = unpack_int (pkt, &mask); /* arg mask */
1592 pkt = unpack_threadid (pkt, &ref);
1595 warning (_("Incomplete response to threadinfo request."));
1596 if (!threadmatch (&ref, expectedref))
1597 { /* This is an answer to a different request. */
1598 warning (_("ERROR RMT Thread info mismatch."));
1601 copy_threadref (&info->threadid, &ref);
1603 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1605 /* Packets are terminated with nulls. */
1606 while ((pkt < limit) && mask && *pkt)
1608 pkt = unpack_int (pkt, &tag); /* tag */
1609 pkt = unpack_byte (pkt, &length); /* length */
1610 if (!(tag & mask)) /* Tags out of synch with mask. */
1612 warning (_("ERROR RMT: threadinfo tag mismatch."));
1616 if (tag == TAG_THREADID)
1620 warning (_("ERROR RMT: length of threadid is not 16."));
1624 pkt = unpack_threadid (pkt, &ref);
1625 mask = mask & ~TAG_THREADID;
1628 if (tag == TAG_EXISTS)
1630 info->active = stub_unpack_int (pkt, length);
1632 mask = mask & ~(TAG_EXISTS);
1635 warning (_("ERROR RMT: 'exists' length too long."));
1641 if (tag == TAG_THREADNAME)
1643 pkt = unpack_string (pkt, &info->shortname[0], length);
1644 mask = mask & ~TAG_THREADNAME;
1647 if (tag == TAG_DISPLAY)
1649 pkt = unpack_string (pkt, &info->display[0], length);
1650 mask = mask & ~TAG_DISPLAY;
1653 if (tag == TAG_MOREDISPLAY)
1655 pkt = unpack_string (pkt, &info->more_display[0], length);
1656 mask = mask & ~TAG_MOREDISPLAY;
1659 warning (_("ERROR RMT: unknown thread info tag."));
1660 break; /* Not a tag we know about. */
1666 remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */
1667 struct gdb_ext_thread_info *info)
1669 struct remote_state *rs = get_remote_state ();
1672 pack_threadinfo_request (rs->buf, fieldset, threadid);
1674 getpkt (&rs->buf, &rs->buf_size, 0);
1675 result = remote_unpack_thread_info_response (rs->buf + 2,
1680 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1683 pack_threadlist_request (char *pkt, int startflag, int threadcount,
1684 threadref *nextthread)
1686 *pkt++ = 'q'; /* info query packet */
1687 *pkt++ = 'L'; /* Process LIST or threadLIST request */
1688 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
1689 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
1690 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
1695 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1698 parse_threadlist_response (char *pkt, int result_limit,
1699 threadref *original_echo, threadref *resultlist,
1702 struct remote_state *rs = get_remote_state ();
1704 int count, resultcount, done;
1707 /* Assume the 'q' and 'M chars have been stripped. */
1708 limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
1709 /* done parse past here */
1710 pkt = unpack_byte (pkt, &count); /* count field */
1711 pkt = unpack_nibble (pkt, &done);
1712 /* The first threadid is the argument threadid. */
1713 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
1714 while ((count-- > 0) && (pkt < limit))
1716 pkt = unpack_threadid (pkt, resultlist++);
1717 if (resultcount++ >= result_limit)
1726 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
1727 int *done, int *result_count, threadref *threadlist)
1729 struct remote_state *rs = get_remote_state ();
1730 static threadref echo_nextthread;
1733 /* Trancate result limit to be smaller than the packet size. */
1734 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= get_remote_packet_size ())
1735 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
1737 pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
1739 getpkt (&rs->buf, &rs->buf_size, 0);
1741 if (*rs->buf == '\0')
1745 parse_threadlist_response (rs->buf + 2, result_limit, &echo_nextthread,
1748 if (!threadmatch (&echo_nextthread, nextthread))
1750 /* FIXME: This is a good reason to drop the packet. */
1751 /* Possably, there is a duplicate response. */
1753 retransmit immediatly - race conditions
1754 retransmit after timeout - yes
1756 wait for packet, then exit
1758 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1759 return 0; /* I choose simply exiting. */
1761 if (*result_count <= 0)
1765 warning (_("RMT ERROR : failed to get remote thread list."));
1768 return result; /* break; */
1770 if (*result_count > result_limit)
1773 warning (_("RMT ERROR: threadlist response longer than requested."));
1779 /* This is the interface between remote and threads, remotes upper
1782 /* remote_find_new_threads retrieves the thread list and for each
1783 thread in the list, looks up the thread in GDB's internal list,
1784 ading the thread if it does not already exist. This involves
1785 getting partial thread lists from the remote target so, polling the
1786 quit_flag is required. */
1789 /* About this many threadisds fit in a packet. */
1791 #define MAXTHREADLISTRESULTS 32
1794 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
1797 int done, i, result_count;
1801 static threadref nextthread;
1802 static threadref resultthreadlist[MAXTHREADLISTRESULTS];
1807 if (loopcount++ > looplimit)
1810 warning (_("Remote fetch threadlist -infinite loop-."));
1813 if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
1814 &done, &result_count, resultthreadlist))
1819 /* Clear for later iterations. */
1821 /* Setup to resume next batch of thread references, set nextthread. */
1822 if (result_count >= 1)
1823 copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
1825 while (result_count--)
1826 if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
1833 remote_newthread_step (threadref *ref, void *context)
1837 ptid = pid_to_ptid (threadref_to_int (ref));
1839 if (!in_thread_list (ptid))
1841 return 1; /* continue iterator */
1844 #define CRAZY_MAX_THREADS 1000
1847 remote_current_thread (ptid_t oldpid)
1849 struct remote_state *rs = get_remote_state ();
1852 getpkt (&rs->buf, &rs->buf_size, 0);
1853 if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
1854 /* Use strtoul here, so we'll correctly parse values whose highest
1855 bit is set. The protocol carries them as a simple series of
1856 hex digits; in the absence of a sign, strtol will see such
1857 values as positive numbers out of range for signed 'long', and
1858 return LONG_MAX to indicate an overflow. */
1859 return pid_to_ptid (strtoul (&rs->buf[2], NULL, 16));
1864 /* Find new threads for info threads command.
1865 * Original version, using John Metzler's thread protocol.
1869 remote_find_new_threads (void)
1871 remote_threadlist_iterator (remote_newthread_step, 0,
1873 if (PIDGET (inferior_ptid) == MAGIC_NULL_PID) /* ack ack ack */
1874 inferior_ptid = remote_current_thread (inferior_ptid);
1878 * Find all threads for info threads command.
1879 * Uses new thread protocol contributed by Cisco.
1880 * Falls back and attempts to use the older method (above)
1881 * if the target doesn't respond to the new method.
1885 remote_threads_info (void)
1887 struct remote_state *rs = get_remote_state ();
1891 if (remote_desc == 0) /* paranoia */
1892 error (_("Command can only be used when connected to the remote target."));
1894 if (use_threadinfo_query)
1896 putpkt ("qfThreadInfo");
1897 getpkt (&rs->buf, &rs->buf_size, 0);
1899 if (bufp[0] != '\0') /* q packet recognized */
1901 while (*bufp++ == 'm') /* reply contains one or more TID */
1905 /* Use strtoul here, so we'll correctly parse values
1906 whose highest bit is set. The protocol carries
1907 them as a simple series of hex digits; in the
1908 absence of a sign, strtol will see such values as
1909 positive numbers out of range for signed 'long',
1910 and return LONG_MAX to indicate an overflow. */
1911 tid = strtoul (bufp, &bufp, 16);
1912 if (tid != 0 && !in_thread_list (pid_to_ptid (tid)))
1913 add_thread (pid_to_ptid (tid));
1915 while (*bufp++ == ','); /* comma-separated list */
1916 putpkt ("qsThreadInfo");
1917 getpkt (&rs->buf, &rs->buf_size, 0);
1924 /* Else fall back to old method based on jmetzler protocol. */
1925 use_threadinfo_query = 0;
1926 remote_find_new_threads ();
1931 * Collect a descriptive string about the given thread.
1932 * The target may say anything it wants to about the thread
1933 * (typically info about its blocked / runnable state, name, etc.).
1934 * This string will appear in the info threads display.
1936 * Optional: targets are not required to implement this function.
1940 remote_threads_extra_info (struct thread_info *tp)
1942 struct remote_state *rs = get_remote_state ();
1946 struct gdb_ext_thread_info threadinfo;
1947 static char display_buf[100]; /* arbitrary... */
1948 int n = 0; /* position in display_buf */
1950 if (remote_desc == 0) /* paranoia */
1951 internal_error (__FILE__, __LINE__,
1952 _("remote_threads_extra_info"));
1954 if (use_threadextra_query)
1956 xsnprintf (rs->buf, get_remote_packet_size (), "qThreadExtraInfo,%x",
1959 getpkt (&rs->buf, &rs->buf_size, 0);
1960 if (rs->buf[0] != 0)
1962 n = min (strlen (rs->buf) / 2, sizeof (display_buf));
1963 result = hex2bin (rs->buf, (gdb_byte *) display_buf, n);
1964 display_buf [result] = '\0';
1969 /* If the above query fails, fall back to the old method. */
1970 use_threadextra_query = 0;
1971 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
1972 | TAG_MOREDISPLAY | TAG_DISPLAY;
1973 int_to_threadref (&id, PIDGET (tp->ptid));
1974 if (remote_get_threadinfo (&id, set, &threadinfo))
1975 if (threadinfo.active)
1977 if (*threadinfo.shortname)
1978 n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
1979 " Name: %s,", threadinfo.shortname);
1980 if (*threadinfo.display)
1981 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
1982 " State: %s,", threadinfo.display);
1983 if (*threadinfo.more_display)
1984 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
1985 " Priority: %s", threadinfo.more_display);
1989 /* For purely cosmetic reasons, clear up trailing commas. */
1990 if (',' == display_buf[n-1])
1991 display_buf[n-1] = ' ';
1999 /* Restart the remote side; this is an extended protocol operation. */
2002 extended_remote_restart (void)
2004 struct remote_state *rs = get_remote_state ();
2006 /* Send the restart command; for reasons I don't understand the
2007 remote side really expects a number after the "R". */
2008 xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
2011 remote_fileio_reset ();
2014 /* Clean up connection to a remote debugger. */
2017 remote_close (int quitting)
2020 serial_close (remote_desc);
2024 /* Query the remote side for the text, data and bss offsets. */
2029 struct remote_state *rs = get_remote_state ();
2032 int lose, num_segments = 0, do_sections, do_segments;
2033 CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
2034 struct section_offsets *offs;
2035 struct symfile_segment_data *data;
2037 if (symfile_objfile == NULL)
2040 putpkt ("qOffsets");
2041 getpkt (&rs->buf, &rs->buf_size, 0);
2044 if (buf[0] == '\000')
2045 return; /* Return silently. Stub doesn't support
2049 warning (_("Remote failure reply: %s"), buf);
2053 /* Pick up each field in turn. This used to be done with scanf, but
2054 scanf will make trouble if CORE_ADDR size doesn't match
2055 conversion directives correctly. The following code will work
2056 with any size of CORE_ADDR. */
2057 text_addr = data_addr = bss_addr = 0;
2061 if (strncmp (ptr, "Text=", 5) == 0)
2064 /* Don't use strtol, could lose on big values. */
2065 while (*ptr && *ptr != ';')
2066 text_addr = (text_addr << 4) + fromhex (*ptr++);
2068 if (strncmp (ptr, ";Data=", 6) == 0)
2071 while (*ptr && *ptr != ';')
2072 data_addr = (data_addr << 4) + fromhex (*ptr++);
2077 if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
2080 while (*ptr && *ptr != ';')
2081 bss_addr = (bss_addr << 4) + fromhex (*ptr++);
2083 if (bss_addr != data_addr)
2084 warning (_("Target reported unsupported offsets: %s"), buf);
2089 else if (strncmp (ptr, "TextSeg=", 8) == 0)
2092 /* Don't use strtol, could lose on big values. */
2093 while (*ptr && *ptr != ';')
2094 text_addr = (text_addr << 4) + fromhex (*ptr++);
2097 if (strncmp (ptr, ";DataSeg=", 9) == 0)
2100 while (*ptr && *ptr != ';')
2101 data_addr = (data_addr << 4) + fromhex (*ptr++);
2109 error (_("Malformed response to offset query, %s"), buf);
2110 else if (*ptr != '\0')
2111 warning (_("Target reported unsupported offsets: %s"), buf);
2113 offs = ((struct section_offsets *)
2114 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
2115 memcpy (offs, symfile_objfile->section_offsets,
2116 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
2118 data = get_symfile_segment_data (symfile_objfile->obfd);
2119 do_segments = (data != NULL);
2120 do_sections = num_segments == 0;
2122 if (num_segments > 0)
2124 segments[0] = text_addr;
2125 segments[1] = data_addr;
2127 /* If we have two segments, we can still try to relocate everything
2128 by assuming that the .text and .data offsets apply to the whole
2129 text and data segments. Convert the offsets given in the packet
2130 to base addresses for symfile_map_offsets_to_segments. */
2131 else if (data && data->num_segments == 2)
2133 segments[0] = data->segment_bases[0] + text_addr;
2134 segments[1] = data->segment_bases[1] + data_addr;
2137 /* There's no way to relocate by segment. */
2143 int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
2144 offs, num_segments, segments);
2146 if (ret == 0 && !do_sections)
2147 error (_("Can not handle qOffsets TextSeg response with this symbol file"));
2154 free_symfile_segment_data (data);
2158 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
2160 /* This is a temporary kludge to force data and bss to use the same offsets
2161 because that's what nlmconv does now. The real solution requires changes
2162 to the stub and remote.c that I don't have time to do right now. */
2164 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
2165 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
2168 objfile_relocate (symfile_objfile, offs);
2171 /* Stub for catch_exception. */
2173 struct start_remote_args
2177 /* The current target. */
2178 struct target_ops *target;
2180 /* Non-zero if this is an extended-remote target. */
2185 remote_start_remote (struct ui_out *uiout, void *opaque)
2187 struct remote_state *rs = get_remote_state ();
2188 struct start_remote_args *args = opaque;
2189 char *wait_status = NULL;
2191 immediate_quit++; /* Allow user to interrupt it. */
2193 /* Ack any packet which the remote side has already sent. */
2194 serial_write (remote_desc, "+", 1);
2196 /* Check whether the target is running now. */
2198 getpkt (&rs->buf, &rs->buf_size, 0);
2200 if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
2202 if (args->extended_p)
2204 /* We're connected, but not running. Drop out before we
2205 call start_remote. */
2206 target_mark_exited (args->target);
2210 error (_("The target is not running (try extended-remote?)"));
2214 if (args->extended_p)
2215 target_mark_running (args->target);
2217 /* Save the reply for later. */
2218 wait_status = alloca (strlen (rs->buf) + 1);
2219 strcpy (wait_status, rs->buf);
2222 /* Let the stub know that we want it to return the thread. */
2225 /* Without this, some commands which require an active target
2226 (such as kill) won't work. This variable serves (at least)
2227 double duty as both the pid of the target process (if it has
2228 such), and as a flag indicating that a target is active.
2229 These functions should be split out into seperate variables,
2230 especially since GDB will someday have a notion of debugging
2231 several processes. */
2232 inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
2234 /* Now, if we have thread information, update inferior_ptid. */
2235 inferior_ptid = remote_current_thread (inferior_ptid);
2237 get_offsets (); /* Get text, data & bss offsets. */
2239 /* Use the previously fetched status. */
2240 gdb_assert (wait_status != NULL);
2241 strcpy (rs->buf, wait_status);
2242 rs->cached_wait_status = 1;
2245 start_remote (args->from_tty); /* Initialize gdb process mechanisms. */
2248 /* Open a connection to a remote debugger.
2249 NAME is the filename used for communication. */
2252 remote_open (char *name, int from_tty)
2254 remote_open_1 (name, from_tty, &remote_ops, 0, 0);
2257 /* Just like remote_open, but with asynchronous support. */
2259 remote_async_open (char *name, int from_tty)
2261 remote_open_1 (name, from_tty, &remote_async_ops, 0, 1);
2264 /* Open a connection to a remote debugger using the extended
2265 remote gdb protocol. NAME is the filename used for communication. */
2268 extended_remote_open (char *name, int from_tty)
2270 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */,
2274 /* Just like extended_remote_open, but with asynchronous support. */
2276 extended_remote_async_open (char *name, int from_tty)
2278 remote_open_1 (name, from_tty, &extended_async_remote_ops,
2279 1 /*extended_p */, 1 /* async_p */);
2282 /* Generic code for opening a connection to a remote target. */
2285 init_all_packet_configs (void)
2288 for (i = 0; i < PACKET_MAX; i++)
2289 update_packet_config (&remote_protocol_packets[i]);
2292 /* Symbol look-up. */
2295 remote_check_symbols (struct objfile *objfile)
2297 struct remote_state *rs = get_remote_state ();
2298 char *msg, *reply, *tmp;
2299 struct minimal_symbol *sym;
2302 if (remote_protocol_packets[PACKET_qSymbol].support == PACKET_DISABLE)
2305 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2306 because we need both at the same time. */
2307 msg = alloca (get_remote_packet_size ());
2309 /* Invite target to request symbol lookups. */
2311 putpkt ("qSymbol::");
2312 getpkt (&rs->buf, &rs->buf_size, 0);
2313 packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
2316 while (strncmp (reply, "qSymbol:", 8) == 0)
2319 end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
2321 sym = lookup_minimal_symbol (msg, NULL, NULL);
2323 xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
2326 CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym);
2328 /* If this is a function address, return the start of code
2329 instead of any data function descriptor. */
2330 sym_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
2334 xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
2335 paddr_nz (sym_addr), &reply[8]);
2339 getpkt (&rs->buf, &rs->buf_size, 0);
2344 static struct serial *
2345 remote_serial_open (char *name)
2347 static int udp_warning = 0;
2349 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2350 of in ser-tcp.c, because it is the remote protocol assuming that the
2351 serial connection is reliable and not the serial connection promising
2353 if (!udp_warning && strncmp (name, "udp:", 4) == 0)
2356 The remote protocol may be unreliable over UDP.\n\
2357 Some events may be lost, rendering further debugging impossible."));
2361 return serial_open (name);
2364 /* This type describes each known response to the qSupported
2366 struct protocol_feature
2368 /* The name of this protocol feature. */
2371 /* The default for this protocol feature. */
2372 enum packet_support default_support;
2374 /* The function to call when this feature is reported, or after
2375 qSupported processing if the feature is not supported.
2376 The first argument points to this structure. The second
2377 argument indicates whether the packet requested support be
2378 enabled, disabled, or probed (or the default, if this function
2379 is being called at the end of processing and this feature was
2380 not reported). The third argument may be NULL; if not NULL, it
2381 is a NUL-terminated string taken from the packet following
2382 this feature's name and an equals sign. */
2383 void (*func) (const struct protocol_feature *, enum packet_support,
2386 /* The corresponding packet for this feature. Only used if
2387 FUNC is remote_supported_packet. */
2392 remote_supported_packet (const struct protocol_feature *feature,
2393 enum packet_support support,
2394 const char *argument)
2398 warning (_("Remote qSupported response supplied an unexpected value for"
2399 " \"%s\"."), feature->name);
2403 if (remote_protocol_packets[feature->packet].support
2404 == PACKET_SUPPORT_UNKNOWN)
2405 remote_protocol_packets[feature->packet].support = support;
2409 remote_packet_size (const struct protocol_feature *feature,
2410 enum packet_support support, const char *value)
2412 struct remote_state *rs = get_remote_state ();
2417 if (support != PACKET_ENABLE)
2420 if (value == NULL || *value == '\0')
2422 warning (_("Remote target reported \"%s\" without a size."),
2428 packet_size = strtol (value, &value_end, 16);
2429 if (errno != 0 || *value_end != '\0' || packet_size < 0)
2431 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2432 feature->name, value);
2436 if (packet_size > MAX_REMOTE_PACKET_SIZE)
2438 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2439 packet_size, MAX_REMOTE_PACKET_SIZE);
2440 packet_size = MAX_REMOTE_PACKET_SIZE;
2443 /* Record the new maximum packet size. */
2444 rs->explicit_packet_size = packet_size;
2447 static struct protocol_feature remote_protocol_features[] = {
2448 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
2449 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
2450 PACKET_qXfer_auxv },
2451 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
2452 PACKET_qXfer_features },
2453 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
2454 PACKET_qXfer_libraries },
2455 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
2456 PACKET_qXfer_memory_map },
2457 { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
2458 PACKET_qXfer_spu_read },
2459 { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
2460 PACKET_qXfer_spu_write },
2461 { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
2462 PACKET_QPassSignals },
2466 remote_query_supported (void)
2468 struct remote_state *rs = get_remote_state ();
2471 unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
2473 /* The packet support flags are handled differently for this packet
2474 than for most others. We treat an error, a disabled packet, and
2475 an empty response identically: any features which must be reported
2476 to be used will be automatically disabled. An empty buffer
2477 accomplishes this, since that is also the representation for a list
2478 containing no features. */
2481 if (remote_protocol_packets[PACKET_qSupported].support != PACKET_DISABLE)
2483 putpkt ("qSupported");
2484 getpkt (&rs->buf, &rs->buf_size, 0);
2486 /* If an error occured, warn, but do not return - just reset the
2487 buffer to empty and go on to disable features. */
2488 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
2491 warning (_("Remote failure reply: %s"), rs->buf);
2496 memset (seen, 0, sizeof (seen));
2501 enum packet_support is_supported;
2502 char *p, *end, *name_end, *value;
2504 /* First separate out this item from the rest of the packet. If
2505 there's another item after this, we overwrite the separator
2506 (terminated strings are much easier to work with). */
2508 end = strchr (p, ';');
2511 end = p + strlen (p);
2521 warning (_("empty item in \"qSupported\" response"));
2526 name_end = strchr (p, '=');
2529 /* This is a name=value entry. */
2530 is_supported = PACKET_ENABLE;
2531 value = name_end + 1;
2540 is_supported = PACKET_ENABLE;
2544 is_supported = PACKET_DISABLE;
2548 is_supported = PACKET_SUPPORT_UNKNOWN;
2552 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p);
2558 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
2559 if (strcmp (remote_protocol_features[i].name, p) == 0)
2561 const struct protocol_feature *feature;
2564 feature = &remote_protocol_features[i];
2565 feature->func (feature, is_supported, value);
2570 /* If we increased the packet size, make sure to increase the global
2571 buffer size also. We delay this until after parsing the entire
2572 qSupported packet, because this is the same buffer we were
2574 if (rs->buf_size < rs->explicit_packet_size)
2576 rs->buf_size = rs->explicit_packet_size;
2577 rs->buf = xrealloc (rs->buf, rs->buf_size);
2580 /* Handle the defaults for unmentioned features. */
2581 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
2584 const struct protocol_feature *feature;
2586 feature = &remote_protocol_features[i];
2587 feature->func (feature, feature->default_support, NULL);
2593 remote_open_1 (char *name, int from_tty, struct target_ops *target,
2594 int extended_p, int async_p)
2596 struct remote_state *rs = get_remote_state ();
2598 error (_("To open a remote debug connection, you need to specify what\n"
2599 "serial device is attached to the remote system\n"
2600 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2602 /* See FIXME above. */
2604 wait_forever_enabled_p = 1;
2606 /* If we're connected to a running target, target_preopen will kill it.
2607 But if we're connected to a target system with no running process,
2608 then we will still be connected when it returns. Ask this question
2609 first, before target_preopen has a chance to kill anything. */
2610 if (remote_desc != NULL && !target_has_execution)
2613 || query (_("Already connected to a remote target. Disconnect? ")))
2616 error (_("Still connected."));
2619 target_preopen (from_tty);
2621 unpush_target (target);
2623 /* This time without a query. If we were connected to an
2624 extended-remote target and target_preopen killed the running
2625 process, we may still be connected. If we are starting "target
2626 remote" now, the extended-remote target will not have been
2627 removed by unpush_target. */
2628 if (remote_desc != NULL && !target_has_execution)
2631 /* Make sure we send the passed signals list the next time we resume. */
2632 xfree (last_pass_packet);
2633 last_pass_packet = NULL;
2635 remote_fileio_reset ();
2636 reopen_exec_file ();
2639 remote_desc = remote_serial_open (name);
2641 perror_with_name (name);
2643 if (baud_rate != -1)
2645 if (serial_setbaudrate (remote_desc, baud_rate))
2647 /* The requested speed could not be set. Error out to
2648 top level after closing remote_desc. Take care to
2649 set remote_desc to NULL to avoid closing remote_desc
2651 serial_close (remote_desc);
2653 perror_with_name (name);
2657 serial_raw (remote_desc);
2659 /* If there is something sitting in the buffer we might take it as a
2660 response to a command, which would be bad. */
2661 serial_flush_input (remote_desc);
2665 puts_filtered ("Remote debugging using ");
2666 puts_filtered (name);
2667 puts_filtered ("\n");
2669 push_target (target); /* Switch to using remote target now. */
2671 /* Assume that the target is running, unless we learn otherwise. */
2672 target_mark_running (target);
2674 /* Reset the target state; these things will be queried either by
2675 remote_query_supported or as they are needed. */
2676 init_all_packet_configs ();
2677 rs->explicit_packet_size = 0;
2679 general_thread = -2;
2680 continue_thread = -2;
2682 /* Probe for ability to use "ThreadInfo" query, as required. */
2683 use_threadinfo_query = 1;
2684 use_threadextra_query = 1;
2686 /* The first packet we send to the target is the optional "supported
2687 packets" request. If the target can answer this, it will tell us
2688 which later probes to skip. */
2689 remote_query_supported ();
2691 /* Next, if the target can specify a description, read it. We do
2692 this before anything involving memory or registers. */
2693 target_find_description ();
2697 /* With this target we start out by owning the terminal. */
2698 remote_async_terminal_ours_p = 1;
2700 /* FIXME: cagney/1999-09-23: During the initial connection it is
2701 assumed that the target is already ready and able to respond to
2702 requests. Unfortunately remote_start_remote() eventually calls
2703 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2704 around this. Eventually a mechanism that allows
2705 wait_for_inferior() to expect/get timeouts will be
2707 wait_forever_enabled_p = 0;
2710 /* First delete any symbols previously loaded from shared libraries. */
2711 no_shared_libraries (NULL, 0);
2713 /* Start the remote connection. If error() or QUIT, discard this
2714 target (we'd otherwise be in an inconsistent state) and then
2715 propogate the error on up the exception chain. This ensures that
2716 the caller doesn't stumble along blindly assuming that the
2717 function succeeded. The CLI doesn't have this problem but other
2718 UI's, such as MI do.
2720 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2721 this function should return an error indication letting the
2722 caller restore the previous state. Unfortunately the command
2723 ``target remote'' is directly wired to this function making that
2724 impossible. On a positive note, the CLI side of this problem has
2725 been fixed - the function set_cmd_context() makes it possible for
2726 all the ``target ....'' commands to share a common callback
2727 function. See cli-dump.c. */
2729 struct gdb_exception ex;
2730 struct start_remote_args args;
2732 args.from_tty = from_tty;
2733 args.target = target;
2734 args.extended_p = extended_p;
2736 ex = catch_exception (uiout, remote_start_remote, &args, RETURN_MASK_ALL);
2741 wait_forever_enabled_p = 1;
2742 throw_exception (ex);
2747 wait_forever_enabled_p = 1;
2751 /* Tell the remote that we are using the extended protocol. */
2753 getpkt (&rs->buf, &rs->buf_size, 0);
2756 /* If we connected to a live target, do some additional setup. */
2757 if (target_has_execution)
2759 if (exec_bfd) /* No use without an exec file. */
2760 remote_check_symbols (symfile_objfile);
2764 /* This takes a program previously attached to and detaches it. After
2765 this is done, GDB can be used to debug some other program. We
2766 better not have left any breakpoints in the target program or it'll
2767 die when it hits one. */
2770 remote_detach_1 (char *args, int from_tty, int extended)
2772 struct remote_state *rs = get_remote_state ();
2775 error (_("Argument given to \"detach\" when remotely debugging."));
2777 if (!target_has_execution)
2778 error (_("No process to detach from."));
2780 /* Tell the remote target to detach. */
2781 strcpy (rs->buf, "D");
2783 getpkt (&rs->buf, &rs->buf_size, 0);
2785 if (rs->buf[0] == 'E')
2786 error (_("Can't detach process."));
2788 /* Unregister the file descriptor from the event loop. */
2789 if (target_is_async_p ())
2790 serial_async (remote_desc, NULL, 0);
2792 target_mourn_inferior ();
2796 puts_filtered ("Detached from remote process.\n");
2798 puts_filtered ("Ending remote debugging.\n");
2803 remote_detach (char *args, int from_tty)
2805 remote_detach_1 (args, from_tty, 0);
2809 extended_remote_detach (char *args, int from_tty)
2811 remote_detach_1 (args, from_tty, 1);
2814 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2817 remote_disconnect (struct target_ops *target, char *args, int from_tty)
2820 error (_("Argument given to \"disconnect\" when remotely debugging."));
2822 /* Unregister the file descriptor from the event loop. */
2823 if (target_is_async_p ())
2824 serial_async (remote_desc, NULL, 0);
2826 /* Make sure we unpush even the extended remote targets; mourn
2827 won't do it. So call remote_mourn_1 directly instead of
2828 target_mourn_inferior. */
2829 remote_mourn_1 (target);
2832 puts_filtered ("Ending remote debugging.\n");
2835 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
2836 be chatty about it. */
2839 extended_remote_attach_1 (struct target_ops *target, char *args, int from_tty)
2841 struct remote_state *rs = get_remote_state ();
2844 char *wait_status = NULL;
2847 error_no_arg (_("process-id to attach"));
2850 pid = strtol (args, &dummy, 0);
2851 /* Some targets don't set errno on errors, grrr! */
2852 if (pid == 0 && args == dummy)
2853 error (_("Illegal process-id: %s."), args);
2855 if (remote_protocol_packets[PACKET_vAttach].support == PACKET_DISABLE)
2856 error (_("This target does not support attaching to a process"));
2858 sprintf (rs->buf, "vAttach;%x", pid);
2860 getpkt (&rs->buf, &rs->buf_size, 0);
2862 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vAttach]) == PACKET_OK)
2865 printf_unfiltered (_("Attached to %s\n"),
2866 target_pid_to_str (pid_to_ptid (pid)));
2868 /* Save the reply for later. */
2869 wait_status = alloca (strlen (rs->buf) + 1);
2870 strcpy (wait_status, rs->buf);
2872 else if (remote_protocol_packets[PACKET_vAttach].support == PACKET_DISABLE)
2873 error (_("This target does not support attaching to a process"));
2875 error (_("Attaching to %s failed"),
2876 target_pid_to_str (pid_to_ptid (pid)));
2878 target_mark_running (target);
2879 inferior_ptid = pid_to_ptid (pid);
2882 /* Next, if the target can specify a description, read it. We do
2883 this before anything involving memory or registers. */
2884 target_find_description ();
2886 /* Use the previously fetched status. */
2887 gdb_assert (wait_status != NULL);
2888 strcpy (rs->buf, wait_status);
2889 rs->cached_wait_status = 1;
2893 extended_remote_attach (char *args, int from_tty)
2895 extended_remote_attach_1 (&extended_remote_ops, args, from_tty);
2899 extended_async_remote_attach (char *args, int from_tty)
2901 extended_remote_attach_1 (&extended_async_remote_ops, args, from_tty);
2904 /* Convert hex digit A to a number. */
2909 if (a >= '0' && a <= '9')
2911 else if (a >= 'a' && a <= 'f')
2912 return a - 'a' + 10;
2913 else if (a >= 'A' && a <= 'F')
2914 return a - 'A' + 10;
2916 error (_("Reply contains invalid hex digit %d"), a);
2920 hex2bin (const char *hex, gdb_byte *bin, int count)
2924 for (i = 0; i < count; i++)
2926 if (hex[0] == 0 || hex[1] == 0)
2928 /* Hex string is short, or of uneven length.
2929 Return the count that has been converted so far. */
2932 *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
2938 /* Convert number NIB to a hex digit. */
2946 return 'a' + nib - 10;
2950 bin2hex (const gdb_byte *bin, char *hex, int count)
2953 /* May use a length, or a nul-terminated string as input. */
2955 count = strlen ((char *) bin);
2957 for (i = 0; i < count; i++)
2959 *hex++ = tohex ((*bin >> 4) & 0xf);
2960 *hex++ = tohex (*bin++ & 0xf);
2966 /* Check for the availability of vCont. This function should also check
2970 remote_vcont_probe (struct remote_state *rs)
2974 strcpy (rs->buf, "vCont?");
2976 getpkt (&rs->buf, &rs->buf_size, 0);
2979 /* Make sure that the features we assume are supported. */
2980 if (strncmp (buf, "vCont", 5) == 0)
2983 int support_s, support_S, support_c, support_C;
2989 while (p && *p == ';')
2992 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
2994 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
2996 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
2998 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
3001 p = strchr (p, ';');
3004 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
3005 BUF will make packet_ok disable the packet. */
3006 if (!support_s || !support_S || !support_c || !support_C)
3010 packet_ok (buf, &remote_protocol_packets[PACKET_vCont]);
3013 /* Resume the remote inferior by using a "vCont" packet. The thread
3014 to be resumed is PTID; STEP and SIGGNAL indicate whether the
3015 resumed thread should be single-stepped and/or signalled. If PTID's
3016 PID is -1, then all threads are resumed; the thread to be stepped and/or
3017 signalled is given in the global INFERIOR_PTID. This function returns
3018 non-zero iff it resumes the inferior.
3020 This function issues a strict subset of all possible vCont commands at the
3024 remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal)
3026 struct remote_state *rs = get_remote_state ();
3027 int pid = PIDGET (ptid);
3029 struct cleanup *old_cleanup;
3031 if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
3032 remote_vcont_probe (rs);
3034 if (remote_protocol_packets[PACKET_vCont].support == PACKET_DISABLE)
3037 /* If we could generate a wider range of packets, we'd have to worry
3038 about overflowing BUF. Should there be a generic
3039 "multi-part-packet" packet? */
3041 if (PIDGET (inferior_ptid) == MAGIC_NULL_PID)
3043 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
3044 don't have any PID numbers the inferior will understand. Make sure
3045 to only send forms that do not specify a PID. */
3046 if (step && siggnal != TARGET_SIGNAL_0)
3047 outbuf = xstrprintf ("vCont;S%02x", siggnal);
3049 outbuf = xstrprintf ("vCont;s");
3050 else if (siggnal != TARGET_SIGNAL_0)
3051 outbuf = xstrprintf ("vCont;C%02x", siggnal);
3053 outbuf = xstrprintf ("vCont;c");
3057 /* Resume all threads, with preference for INFERIOR_PTID. */
3058 if (step && siggnal != TARGET_SIGNAL_0)
3059 outbuf = xstrprintf ("vCont;S%02x:%x;c", siggnal,
3060 PIDGET (inferior_ptid));
3062 outbuf = xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid));
3063 else if (siggnal != TARGET_SIGNAL_0)
3064 outbuf = xstrprintf ("vCont;C%02x:%x;c", siggnal,
3065 PIDGET (inferior_ptid));
3067 outbuf = xstrprintf ("vCont;c");
3071 /* Scheduler locking; resume only PTID. */
3072 if (step && siggnal != TARGET_SIGNAL_0)
3073 outbuf = xstrprintf ("vCont;S%02x:%x", siggnal, pid);
3075 outbuf = xstrprintf ("vCont;s:%x", pid);
3076 else if (siggnal != TARGET_SIGNAL_0)
3077 outbuf = xstrprintf ("vCont;C%02x:%x", siggnal, pid);
3079 outbuf = xstrprintf ("vCont;c:%x", pid);
3082 gdb_assert (outbuf && strlen (outbuf) < get_remote_packet_size ());
3083 old_cleanup = make_cleanup (xfree, outbuf);
3087 do_cleanups (old_cleanup);
3092 /* Tell the remote machine to resume. */
3094 static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
3096 static int last_sent_step;
3099 remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
3101 struct remote_state *rs = get_remote_state ();
3103 int pid = PIDGET (ptid);
3105 last_sent_signal = siggnal;
3106 last_sent_step = step;
3108 /* Update the inferior on signals to silently pass, if they've changed. */
3109 remote_pass_signals ();
3111 /* The vCont packet doesn't need to specify threads via Hc. */
3112 if (remote_vcont_resume (ptid, step, siggnal))
3115 /* All other supported resume packets do use Hc, so call set_thread. */
3117 set_thread (0, 0); /* Run any thread. */
3119 set_thread (pid, 0); /* Run this thread. */
3122 if (siggnal != TARGET_SIGNAL_0)
3124 buf[0] = step ? 'S' : 'C';
3125 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
3126 buf[2] = tohex (((int) siggnal) & 0xf);
3130 strcpy (buf, step ? "s" : "c");
3135 /* Same as remote_resume, but with async support. */
3137 remote_async_resume (ptid_t ptid, int step, enum target_signal siggnal)
3139 remote_resume (ptid, step, siggnal);
3141 /* We are about to start executing the inferior, let's register it
3142 with the event loop. NOTE: this is the one place where all the
3143 execution commands end up. We could alternatively do this in each
3144 of the execution commands in infcmd.c. */
3145 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
3146 into infcmd.c in order to allow inferior function calls to work
3147 NOT asynchronously. */
3148 if (target_can_async_p ())
3149 target_async (inferior_event_handler, 0);
3150 /* Tell the world that the target is now executing. */
3151 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
3152 this? Instead, should the client of target just assume (for
3153 async targets) that the target is going to start executing? Is
3154 this information already found in the continuation block? */
3155 if (target_is_async_p ())
3156 target_executing = 1;
3160 /* Set up the signal handler for SIGINT, while the target is
3161 executing, ovewriting the 'regular' SIGINT signal handler. */
3163 initialize_sigint_signal_handler (void)
3165 signal (SIGINT, handle_remote_sigint);
3168 /* Signal handler for SIGINT, while the target is executing. */
3170 handle_remote_sigint (int sig)
3172 signal (sig, handle_remote_sigint_twice);
3173 mark_async_signal_handler_wrapper (sigint_remote_token);
3176 /* Signal handler for SIGINT, installed after SIGINT has already been
3177 sent once. It will take effect the second time that the user sends
3180 handle_remote_sigint_twice (int sig)
3182 signal (sig, handle_remote_sigint);
3183 mark_async_signal_handler_wrapper (sigint_remote_twice_token);
3186 /* Perform the real interruption of the target execution, in response
3189 async_remote_interrupt (gdb_client_data arg)
3192 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
3197 /* Perform interrupt, if the first attempt did not succeed. Just give
3198 up on the target alltogether. */
3200 async_remote_interrupt_twice (gdb_client_data arg)
3203 fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
3208 /* Reinstall the usual SIGINT handlers, after the target has
3211 cleanup_sigint_signal_handler (void *dummy)
3213 signal (SIGINT, handle_sigint);
3216 /* Send ^C to target to halt it. Target will respond, and send us a
3218 static void (*ofunc) (int);
3220 /* The command line interface's stop routine. This function is installed
3221 as a signal handler for SIGINT. The first time a user requests a
3222 stop, we call remote_stop to send a break or ^C. If there is no
3223 response from the target (it didn't stop when the user requested it),
3224 we ask the user if he'd like to detach from the target. */
3226 remote_interrupt (int signo)
3228 /* If this doesn't work, try more severe steps. */
3229 signal (signo, remote_interrupt_twice);
3231 gdb_call_async_signal_handler (sigint_remote_token, 1);
3234 /* The user typed ^C twice. */
3237 remote_interrupt_twice (int signo)
3239 signal (signo, ofunc);
3240 gdb_call_async_signal_handler (sigint_remote_twice_token, 1);
3241 signal (signo, remote_interrupt);
3244 /* This is the generic stop called via the target vector. When a target
3245 interrupt is requested, either by the command line or the GUI, we
3246 will eventually end up here. */
3250 /* Send a break or a ^C, depending on user preference. */
3252 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
3255 serial_send_break (remote_desc);
3257 serial_write (remote_desc, "\003", 1);
3260 /* Ask the user what to do when an interrupt is received. */
3263 interrupt_query (void)
3265 target_terminal_ours ();
3267 if (query ("Interrupted while waiting for the program.\n\
3268 Give up (and stop debugging it)? "))
3270 target_mourn_inferior ();
3271 signal (SIGINT, handle_sigint);
3272 deprecated_throw_reason (RETURN_QUIT);
3275 target_terminal_inferior ();
3278 /* Enable/disable target terminal ownership. Most targets can use
3279 terminal groups to control terminal ownership. Remote targets are
3280 different in that explicit transfer of ownership to/from GDB/target
3284 remote_async_terminal_inferior (void)
3286 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3287 sync_execution here. This function should only be called when
3288 GDB is resuming the inferior in the forground. A background
3289 resume (``run&'') should leave GDB in control of the terminal and
3290 consequently should not call this code. */
3291 if (!sync_execution)
3293 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3294 calls target_terminal_*() idenpotent. The event-loop GDB talking
3295 to an asynchronous target with a synchronous command calls this
3296 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3297 stops trying to transfer the terminal to the target when it
3298 shouldn't this guard can go away. */
3299 if (!remote_async_terminal_ours_p)
3301 delete_file_handler (input_fd);
3302 remote_async_terminal_ours_p = 0;
3303 initialize_sigint_signal_handler ();
3304 /* NOTE: At this point we could also register our selves as the
3305 recipient of all input. Any characters typed could then be
3306 passed on down to the target. */
3310 remote_async_terminal_ours (void)
3312 /* See FIXME in remote_async_terminal_inferior. */
3313 if (!sync_execution)
3315 /* See FIXME in remote_async_terminal_inferior. */
3316 if (remote_async_terminal_ours_p)
3318 cleanup_sigint_signal_handler (NULL);
3319 add_file_handler (input_fd, stdin_event_handler, 0);
3320 remote_async_terminal_ours_p = 1;
3323 /* If nonzero, ignore the next kill. */
3328 remote_console_output (char *msg)
3332 for (p = msg; p[0] && p[1]; p += 2)
3335 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
3338 fputs_unfiltered (tb, gdb_stdtarg);
3340 gdb_flush (gdb_stdtarg);
3343 /* Wait until the remote machine stops, then return,
3344 storing status in STATUS just as `wait' would.
3345 Returns "pid", which in the case of a multi-threaded
3346 remote OS, is the thread-id. */
3349 remote_wait (ptid_t ptid, struct target_waitstatus *status)
3351 struct remote_state *rs = get_remote_state ();
3352 struct remote_arch_state *rsa = get_remote_arch_state ();
3353 ULONGEST thread_num = -1;
3355 int solibs_changed = 0;
3357 status->kind = TARGET_WAITKIND_EXITED;
3358 status->value.integer = 0;
3364 if (rs->cached_wait_status)
3365 /* Use the cached wait status, but only once. */
3366 rs->cached_wait_status = 0;
3369 ofunc = signal (SIGINT, remote_interrupt);
3370 /* If the user hit C-c before this packet, or between packets,
3371 pretend that it was hit right here. */
3375 remote_interrupt (SIGINT);
3377 getpkt (&rs->buf, &rs->buf_size, 1);
3378 signal (SIGINT, ofunc);
3383 remote_stopped_by_watchpoint_p = 0;
3387 case 'E': /* Error of some sort. */
3388 /* We're out of sync with the target now. Did it continue or not?
3389 Not is more likely, so report a stop. */
3390 warning (_("Remote failure reply: %s"), buf);
3391 status->kind = TARGET_WAITKIND_STOPPED;
3392 status->value.sig = TARGET_SIGNAL_0;
3394 case 'F': /* File-I/O request. */
3395 remote_fileio_request (buf);
3397 case 'T': /* Status with PC, SP, FP, ... */
3399 gdb_byte regs[MAX_REGISTER_SIZE];
3401 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3402 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3404 n... = register number
3405 r... = register contents
3407 p = &buf[3]; /* after Txx */
3416 /* If the packet contains a register number save it in
3417 pnum and set p1 to point to the character following
3418 it. Otherwise p1 points to p. */
3420 /* If this packet is an awatch packet, don't parse the
3421 'a' as a register number. */
3423 if (strncmp (p, "awatch", strlen("awatch")) != 0)
3425 /* Read the ``P'' register number. */
3426 pnum = strtol (p, &p_temp, 16);
3432 if (p1 == p) /* No register number present here. */
3434 p1 = strchr (p, ':');
3436 error (_("Malformed packet(a) (missing colon): %s\n\
3439 if (strncmp (p, "thread", p1 - p) == 0)
3441 p_temp = unpack_varlen_hex (++p1, &thread_num);
3442 record_currthread (thread_num);
3445 else if ((strncmp (p, "watch", p1 - p) == 0)
3446 || (strncmp (p, "rwatch", p1 - p) == 0)
3447 || (strncmp (p, "awatch", p1 - p) == 0))
3449 remote_stopped_by_watchpoint_p = 1;
3450 p = unpack_varlen_hex (++p1, &addr);
3451 remote_watch_data_address = (CORE_ADDR)addr;
3453 else if (strncmp (p, "library", p1 - p) == 0)
3457 while (*p_temp && *p_temp != ';')
3465 /* Silently skip unknown optional info. */
3466 p_temp = strchr (p1 + 1, ';');
3473 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
3477 error (_("Malformed packet(b) (missing colon): %s\n\
3482 error (_("Remote sent bad register number %s: %s\n\
3484 phex_nz (pnum, 0), p, buf);
3486 fieldsize = hex2bin (p, regs,
3487 register_size (current_gdbarch,
3490 if (fieldsize < register_size (current_gdbarch,
3492 warning (_("Remote reply is too short: %s"), buf);
3493 regcache_raw_supply (get_current_regcache (),
3498 error (_("Remote register badly formatted: %s\nhere: %s"),
3503 case 'S': /* Old style status, just signal only. */
3505 status->kind = TARGET_WAITKIND_LOADED;
3508 status->kind = TARGET_WAITKIND_STOPPED;
3509 status->value.sig = (enum target_signal)
3510 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3515 thread_num = strtol ((const char *) &buf[4], NULL, 16);
3516 record_currthread (thread_num);
3519 case 'W': /* Target exited. */
3521 /* The remote process exited. */
3522 status->kind = TARGET_WAITKIND_EXITED;
3523 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3527 status->kind = TARGET_WAITKIND_SIGNALLED;
3528 status->value.sig = (enum target_signal)
3529 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3533 case 'O': /* Console output. */
3534 remote_console_output (buf + 1);
3537 if (last_sent_signal != TARGET_SIGNAL_0)
3539 /* Zero length reply means that we tried 'S' or 'C' and
3540 the remote system doesn't support it. */
3541 target_terminal_ours_for_output ();
3543 ("Can't send signals to this remote system. %s not sent.\n",
3544 target_signal_to_name (last_sent_signal));
3545 last_sent_signal = TARGET_SIGNAL_0;
3546 target_terminal_inferior ();
3548 strcpy ((char *) buf, last_sent_step ? "s" : "c");
3549 putpkt ((char *) buf);
3552 /* else fallthrough */
3554 warning (_("Invalid remote reply: %s"), buf);
3559 if (thread_num != -1)
3561 return pid_to_ptid (thread_num);
3563 return inferior_ptid;
3566 /* Async version of remote_wait. */
3568 remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
3570 struct remote_state *rs = get_remote_state ();
3571 struct remote_arch_state *rsa = get_remote_arch_state ();
3572 ULONGEST thread_num = -1;
3574 int solibs_changed = 0;
3576 status->kind = TARGET_WAITKIND_EXITED;
3577 status->value.integer = 0;
3579 remote_stopped_by_watchpoint_p = 0;
3585 if (rs->cached_wait_status)
3586 /* Use the cached wait status, but only once. */
3587 rs->cached_wait_status = 0;
3590 if (!target_is_async_p ())
3592 ofunc = signal (SIGINT, remote_interrupt);
3593 /* If the user hit C-c before this packet, or between packets,
3594 pretend that it was hit right here. */
3598 remote_interrupt (SIGINT);
3601 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3602 _never_ wait for ever -> test on target_is_async_p().
3603 However, before we do that we need to ensure that the caller
3604 knows how to take the target into/out of async mode. */
3605 getpkt (&rs->buf, &rs->buf_size, wait_forever_enabled_p);
3606 if (!target_is_async_p ())
3607 signal (SIGINT, ofunc);
3614 case 'E': /* Error of some sort. */
3615 /* We're out of sync with the target now. Did it continue or not?
3616 Not is more likely, so report a stop. */
3617 warning (_("Remote failure reply: %s"), buf);
3618 status->kind = TARGET_WAITKIND_STOPPED;
3619 status->value.sig = TARGET_SIGNAL_0;
3621 case 'F': /* File-I/O request. */
3622 remote_fileio_request (buf);
3624 case 'T': /* Status with PC, SP, FP, ... */
3626 gdb_byte regs[MAX_REGISTER_SIZE];
3628 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3629 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3631 n... = register number
3632 r... = register contents
3634 p = &buf[3]; /* after Txx */
3643 /* If the packet contains a register number, save it
3644 in pnum and set p1 to point to the character
3645 following it. Otherwise p1 points to p. */
3647 /* If this packet is an awatch packet, don't parse the 'a'
3648 as a register number. */
3650 if (strncmp (p, "awatch", strlen("awatch")) != 0)
3652 /* Read the register number. */
3653 pnum = strtol (p, &p_temp, 16);
3659 if (p1 == p) /* No register number present here. */
3661 p1 = strchr (p, ':');
3663 error (_("Malformed packet(a) (missing colon): %s\n\
3666 if (strncmp (p, "thread", p1 - p) == 0)
3668 p_temp = unpack_varlen_hex (++p1, &thread_num);
3669 record_currthread (thread_num);
3672 else if ((strncmp (p, "watch", p1 - p) == 0)
3673 || (strncmp (p, "rwatch", p1 - p) == 0)
3674 || (strncmp (p, "awatch", p1 - p) == 0))
3676 remote_stopped_by_watchpoint_p = 1;
3677 p = unpack_varlen_hex (++p1, &addr);
3678 remote_watch_data_address = (CORE_ADDR)addr;
3680 else if (strncmp (p, "library", p1 - p) == 0)
3684 while (*p_temp && *p_temp != ';')
3692 /* Silently skip unknown optional info. */
3693 p_temp = strchr (p1 + 1, ';');
3701 struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
3704 error (_("Malformed packet(b) (missing colon): %s\n\
3709 error (_("Remote sent bad register number %ld: %s\n\
3713 fieldsize = hex2bin (p, regs,
3714 register_size (current_gdbarch,
3717 if (fieldsize < register_size (current_gdbarch,
3719 warning (_("Remote reply is too short: %s"), buf);
3720 regcache_raw_supply (get_current_regcache (),
3725 error (_("Remote register badly formatted: %s\nhere: %s"),
3730 case 'S': /* Old style status, just signal only. */
3732 status->kind = TARGET_WAITKIND_LOADED;
3735 status->kind = TARGET_WAITKIND_STOPPED;
3736 status->value.sig = (enum target_signal)
3737 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3742 thread_num = strtol ((const char *) &buf[4], NULL, 16);
3743 record_currthread (thread_num);
3746 case 'W': /* Target exited. */
3748 /* The remote process exited. */
3749 status->kind = TARGET_WAITKIND_EXITED;
3750 status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3754 status->kind = TARGET_WAITKIND_SIGNALLED;
3755 status->value.sig = (enum target_signal)
3756 (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3760 case 'O': /* Console output. */
3761 remote_console_output (buf + 1);
3762 /* Return immediately to the event loop. The event loop will
3763 still be waiting on the inferior afterwards. */
3764 status->kind = TARGET_WAITKIND_IGNORE;
3767 if (last_sent_signal != TARGET_SIGNAL_0)
3769 /* Zero length reply means that we tried 'S' or 'C' and
3770 the remote system doesn't support it. */
3771 target_terminal_ours_for_output ();
3773 ("Can't send signals to this remote system. %s not sent.\n",
3774 target_signal_to_name (last_sent_signal));
3775 last_sent_signal = TARGET_SIGNAL_0;
3776 target_terminal_inferior ();
3778 strcpy ((char *) buf, last_sent_step ? "s" : "c");
3779 putpkt ((char *) buf);
3782 /* else fallthrough */
3784 warning (_("Invalid remote reply: %s"), buf);
3789 if (thread_num != -1)
3791 return pid_to_ptid (thread_num);
3793 return inferior_ptid;
3796 /* Fetch a single register using a 'p' packet. */
3799 fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
3801 struct remote_state *rs = get_remote_state ();
3803 char regp[MAX_REGISTER_SIZE];
3806 if (remote_protocol_packets[PACKET_p].support == PACKET_DISABLE)
3809 if (reg->pnum == -1)
3814 p += hexnumstr (p, reg->pnum);
3816 remote_send (&rs->buf, &rs->buf_size);
3820 switch (packet_ok (buf, &remote_protocol_packets[PACKET_p]))
3824 case PACKET_UNKNOWN:
3827 error (_("Could not fetch register \"%s\""),
3828 gdbarch_register_name (get_regcache_arch (regcache), reg->regnum));
3831 /* If this register is unfetchable, tell the regcache. */
3834 regcache_raw_supply (regcache, reg->regnum, NULL);
3838 /* Otherwise, parse and supply the value. */
3844 error (_("fetch_register_using_p: early buf termination"));
3846 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
3849 regcache_raw_supply (regcache, reg->regnum, regp);
3853 /* Fetch the registers included in the target's 'g' packet. */
3856 send_g_packet (void)
3858 struct remote_state *rs = get_remote_state ();
3863 sprintf (rs->buf, "g");
3864 remote_send (&rs->buf, &rs->buf_size);
3866 /* We can get out of synch in various cases. If the first character
3867 in the buffer is not a hex character, assume that has happened
3868 and try to fetch another packet to read. */
3869 while ((rs->buf[0] < '0' || rs->buf[0] > '9')
3870 && (rs->buf[0] < 'A' || rs->buf[0] > 'F')
3871 && (rs->buf[0] < 'a' || rs->buf[0] > 'f')
3872 && rs->buf[0] != 'x') /* New: unavailable register value. */
3875 fprintf_unfiltered (gdb_stdlog,
3876 "Bad register packet; fetching a new packet\n");
3877 getpkt (&rs->buf, &rs->buf_size, 0);
3880 buf_len = strlen (rs->buf);
3882 /* Sanity check the received packet. */
3883 if (buf_len % 2 != 0)
3884 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf);
3890 process_g_packet (struct regcache *regcache)
3892 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3893 struct remote_state *rs = get_remote_state ();
3894 struct remote_arch_state *rsa = get_remote_arch_state ();
3899 buf_len = strlen (rs->buf);
3901 /* Further sanity checks, with knowledge of the architecture. */
3902 if (buf_len > 2 * rsa->sizeof_g_packet)
3903 error (_("Remote 'g' packet reply is too long: %s"), rs->buf);
3905 /* Save the size of the packet sent to us by the target. It is used
3906 as a heuristic when determining the max size of packets that the
3907 target can safely receive. */
3908 if (rsa->actual_register_packet_size == 0)
3909 rsa->actual_register_packet_size = buf_len;
3911 /* If this is smaller than we guessed the 'g' packet would be,
3912 update our records. A 'g' reply that doesn't include a register's
3913 value implies either that the register is not available, or that
3914 the 'p' packet must be used. */
3915 if (buf_len < 2 * rsa->sizeof_g_packet)
3917 rsa->sizeof_g_packet = buf_len / 2;
3919 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
3921 if (rsa->regs[i].pnum == -1)
3924 if (rsa->regs[i].offset >= rsa->sizeof_g_packet)
3925 rsa->regs[i].in_g_packet = 0;
3927 rsa->regs[i].in_g_packet = 1;
3931 regs = alloca (rsa->sizeof_g_packet);
3933 /* Unimplemented registers read as all bits zero. */
3934 memset (regs, 0, rsa->sizeof_g_packet);
3936 /* Reply describes registers byte by byte, each byte encoded as two
3937 hex characters. Suck them all up, then supply them to the
3938 register cacheing/storage mechanism. */
3941 for (i = 0; i < rsa->sizeof_g_packet; i++)
3943 if (p[0] == 0 || p[1] == 0)
3944 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3945 internal_error (__FILE__, __LINE__,
3946 "unexpected end of 'g' packet reply");
3948 if (p[0] == 'x' && p[1] == 'x')
3949 regs[i] = 0; /* 'x' */
3951 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
3957 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
3959 struct packet_reg *r = &rsa->regs[i];
3962 if (r->offset * 2 >= strlen (rs->buf))
3963 /* This shouldn't happen - we adjusted in_g_packet above. */
3964 internal_error (__FILE__, __LINE__,
3965 "unexpected end of 'g' packet reply");
3966 else if (rs->buf[r->offset * 2] == 'x')
3968 gdb_assert (r->offset * 2 < strlen (rs->buf));
3969 /* The register isn't available, mark it as such (at
3970 the same time setting the value to zero). */
3971 regcache_raw_supply (regcache, r->regnum, NULL);
3974 regcache_raw_supply (regcache, r->regnum,
3982 fetch_registers_using_g (struct regcache *regcache)
3985 process_g_packet (regcache);
3989 remote_fetch_registers (struct regcache *regcache, int regnum)
3991 struct remote_state *rs = get_remote_state ();
3992 struct remote_arch_state *rsa = get_remote_arch_state ();
3995 set_thread (PIDGET (inferior_ptid), 1);
3999 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
4000 gdb_assert (reg != NULL);
4002 /* If this register might be in the 'g' packet, try that first -
4003 we are likely to read more than one register. If this is the
4004 first 'g' packet, we might be overly optimistic about its
4005 contents, so fall back to 'p'. */
4006 if (reg->in_g_packet)
4008 fetch_registers_using_g (regcache);
4009 if (reg->in_g_packet)
4013 if (fetch_register_using_p (regcache, reg))
4016 /* This register is not available. */
4017 regcache_raw_supply (regcache, reg->regnum, NULL);
4022 fetch_registers_using_g (regcache);
4024 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
4025 if (!rsa->regs[i].in_g_packet)
4026 if (!fetch_register_using_p (regcache, &rsa->regs[i]))
4028 /* This register is not available. */
4029 regcache_raw_supply (regcache, i, NULL);
4033 /* Prepare to store registers. Since we may send them all (using a
4034 'G' request), we have to read out the ones we don't want to change
4038 remote_prepare_to_store (struct regcache *regcache)
4040 struct remote_arch_state *rsa = get_remote_arch_state ();
4042 gdb_byte buf[MAX_REGISTER_SIZE];
4044 /* Make sure the entire registers array is valid. */
4045 switch (remote_protocol_packets[PACKET_P].support)
4047 case PACKET_DISABLE:
4048 case PACKET_SUPPORT_UNKNOWN:
4049 /* Make sure all the necessary registers are cached. */
4050 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
4051 if (rsa->regs[i].in_g_packet)
4052 regcache_raw_read (regcache, rsa->regs[i].regnum, buf);
4059 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
4060 packet was not recognized. */
4063 store_register_using_P (const struct regcache *regcache, struct packet_reg *reg)
4065 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4066 struct remote_state *rs = get_remote_state ();
4067 struct remote_arch_state *rsa = get_remote_arch_state ();
4068 /* Try storing a single register. */
4069 char *buf = rs->buf;
4070 gdb_byte regp[MAX_REGISTER_SIZE];
4073 if (remote_protocol_packets[PACKET_P].support == PACKET_DISABLE)
4076 if (reg->pnum == -1)
4079 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
4080 p = buf + strlen (buf);
4081 regcache_raw_collect (regcache, reg->regnum, regp);
4082 bin2hex (regp, p, register_size (gdbarch, reg->regnum));
4083 remote_send (&rs->buf, &rs->buf_size);
4085 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
4090 error (_("Could not write register \"%s\""),
4091 gdbarch_register_name (gdbarch, reg->regnum));
4092 case PACKET_UNKNOWN:
4095 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
4099 /* Store register REGNUM, or all registers if REGNUM == -1, from the
4100 contents of the register cache buffer. FIXME: ignores errors. */
4103 store_registers_using_G (const struct regcache *regcache)
4105 struct remote_state *rs = get_remote_state ();
4106 struct remote_arch_state *rsa = get_remote_arch_state ();
4110 /* Extract all the registers in the regcache copying them into a
4114 regs = alloca (rsa->sizeof_g_packet);
4115 memset (regs, 0, rsa->sizeof_g_packet);
4116 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
4118 struct packet_reg *r = &rsa->regs[i];
4120 regcache_raw_collect (regcache, r->regnum, regs + r->offset);
4124 /* Command describes registers byte by byte,
4125 each byte encoded as two hex characters. */
4128 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
4130 bin2hex (regs, p, rsa->sizeof_g_packet);
4131 remote_send (&rs->buf, &rs->buf_size);
4134 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
4135 of the register cache buffer. FIXME: ignores errors. */
4138 remote_store_registers (struct regcache *regcache, int regnum)
4140 struct remote_state *rs = get_remote_state ();
4141 struct remote_arch_state *rsa = get_remote_arch_state ();
4144 set_thread (PIDGET (inferior_ptid), 1);
4148 struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
4149 gdb_assert (reg != NULL);
4151 /* Always prefer to store registers using the 'P' packet if
4152 possible; we often change only a small number of registers.
4153 Sometimes we change a larger number; we'd need help from a
4154 higher layer to know to use 'G'. */
4155 if (store_register_using_P (regcache, reg))
4158 /* For now, don't complain if we have no way to write the
4159 register. GDB loses track of unavailable registers too
4160 easily. Some day, this may be an error. We don't have
4161 any way to read the register, either... */
4162 if (!reg->in_g_packet)
4165 store_registers_using_G (regcache);
4169 store_registers_using_G (regcache);
4171 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
4172 if (!rsa->regs[i].in_g_packet)
4173 if (!store_register_using_P (regcache, &rsa->regs[i]))
4174 /* See above for why we do not issue an error here. */
4179 /* Return the number of hex digits in num. */
4182 hexnumlen (ULONGEST num)
4186 for (i = 0; num != 0; i++)
4192 /* Set BUF to the minimum number of hex digits representing NUM. */
4195 hexnumstr (char *buf, ULONGEST num)
4197 int len = hexnumlen (num);
4198 return hexnumnstr (buf, num, len);
4202 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
4205 hexnumnstr (char *buf, ULONGEST num, int width)
4211 for (i = width - 1; i >= 0; i--)
4213 buf[i] = "0123456789abcdef"[(num & 0xf)];
4220 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
4223 remote_address_masked (CORE_ADDR addr)
4225 int address_size = remote_address_size;
4226 /* If "remoteaddresssize" was not set, default to target address size. */
4228 address_size = gdbarch_addr_bit (current_gdbarch);
4230 if (address_size > 0
4231 && address_size < (sizeof (ULONGEST) * 8))
4233 /* Only create a mask when that mask can safely be constructed
4234 in a ULONGEST variable. */
4236 mask = (mask << address_size) - 1;
4242 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
4243 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
4244 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
4245 (which may be more than *OUT_LEN due to escape characters). The
4246 total number of bytes in the output buffer will be at most
4250 remote_escape_output (const gdb_byte *buffer, int len,
4251 gdb_byte *out_buf, int *out_len,
4254 int input_index, output_index;
4257 for (input_index = 0; input_index < len; input_index++)
4259 gdb_byte b = buffer[input_index];
4261 if (b == '$' || b == '#' || b == '}')
4263 /* These must be escaped. */
4264 if (output_index + 2 > out_maxlen)
4266 out_buf[output_index++] = '}';
4267 out_buf[output_index++] = b ^ 0x20;
4271 if (output_index + 1 > out_maxlen)
4273 out_buf[output_index++] = b;
4277 *out_len = input_index;
4278 return output_index;
4281 /* Convert BUFFER, escaped data LEN bytes long, into binary data
4282 in OUT_BUF. Return the number of bytes written to OUT_BUF.
4283 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
4285 This function reverses remote_escape_output. It allows more
4286 escaped characters than that function does, in particular because
4287 '*' must be escaped to avoid the run-length encoding processing
4288 in reading packets. */
4291 remote_unescape_input (const gdb_byte *buffer, int len,
4292 gdb_byte *out_buf, int out_maxlen)
4294 int input_index, output_index;
4299 for (input_index = 0; input_index < len; input_index++)
4301 gdb_byte b = buffer[input_index];
4303 if (output_index + 1 > out_maxlen)
4305 warning (_("Received too much data from remote target;"
4306 " ignoring overflow."));
4307 return output_index;
4312 out_buf[output_index++] = b ^ 0x20;
4318 out_buf[output_index++] = b;
4322 error (_("Unmatched escape character in target response."));
4324 return output_index;
4327 /* Determine whether the remote target supports binary downloading.
4328 This is accomplished by sending a no-op memory write of zero length
4329 to the target at the specified address. It does not suffice to send
4330 the whole packet, since many stubs strip the eighth bit and
4331 subsequently compute a wrong checksum, which causes real havoc with
4334 NOTE: This can still lose if the serial line is not eight-bit
4335 clean. In cases like this, the user should clear "remote
4339 check_binary_download (CORE_ADDR addr)
4341 struct remote_state *rs = get_remote_state ();
4343 switch (remote_protocol_packets[PACKET_X].support)
4345 case PACKET_DISABLE:
4349 case PACKET_SUPPORT_UNKNOWN:
4355 p += hexnumstr (p, (ULONGEST) addr);
4357 p += hexnumstr (p, (ULONGEST) 0);
4361 putpkt_binary (rs->buf, (int) (p - rs->buf));
4362 getpkt (&rs->buf, &rs->buf_size, 0);
4364 if (rs->buf[0] == '\0')
4367 fprintf_unfiltered (gdb_stdlog,
4368 "binary downloading NOT suppported by target\n");
4369 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
4374 fprintf_unfiltered (gdb_stdlog,
4375 "binary downloading suppported by target\n");
4376 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
4383 /* Write memory data directly to the remote machine.
4384 This does not inform the data cache; the data cache uses this.
4385 HEADER is the starting part of the packet.
4386 MEMADDR is the address in the remote memory space.
4387 MYADDR is the address of the buffer in our space.
4388 LEN is the number of bytes.
4389 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4390 should send data as binary ('X'), or hex-encoded ('M').
4392 The function creates packet of the form
4393 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4395 where encoding of <DATA> is termined by PACKET_FORMAT.
4397 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4400 Returns the number of bytes transferred, or 0 (setting errno) for
4401 error. Only transfer a single packet. */
4404 remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
4405 const gdb_byte *myaddr, int len,
4406 char packet_format, int use_length)
4408 struct remote_state *rs = get_remote_state ();
4418 if (packet_format != 'X' && packet_format != 'M')
4419 internal_error (__FILE__, __LINE__,
4420 "remote_write_bytes_aux: bad packet format");
4425 payload_size = get_memory_write_packet_size ();
4427 /* The packet buffer will be large enough for the payload;
4428 get_memory_packet_size ensures this. */
4431 /* Compute the size of the actual payload by subtracting out the
4432 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4434 payload_size -= strlen ("$,:#NN");
4436 /* The comma won't be used. */
4438 header_length = strlen (header);
4439 payload_size -= header_length;
4440 payload_size -= hexnumlen (memaddr);
4442 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4444 strcat (rs->buf, header);
4445 p = rs->buf + strlen (header);
4447 /* Compute a best guess of the number of bytes actually transfered. */
4448 if (packet_format == 'X')
4450 /* Best guess at number of bytes that will fit. */
4451 todo = min (len, payload_size);
4453 payload_size -= hexnumlen (todo);
4454 todo = min (todo, payload_size);
4458 /* Num bytes that will fit. */
4459 todo = min (len, payload_size / 2);
4461 payload_size -= hexnumlen (todo);
4462 todo = min (todo, payload_size / 2);
4466 internal_error (__FILE__, __LINE__,
4467 _("minumum packet size too small to write data"));
4469 /* If we already need another packet, then try to align the end
4470 of this packet to a useful boundary. */
4471 if (todo > 2 * REMOTE_ALIGN_WRITES && todo < len)
4472 todo = ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
4474 /* Append "<memaddr>". */
4475 memaddr = remote_address_masked (memaddr);
4476 p += hexnumstr (p, (ULONGEST) memaddr);
4483 /* Append <len>. Retain the location/size of <len>. It may need to
4484 be adjusted once the packet body has been created. */
4486 plenlen = hexnumstr (p, (ULONGEST) todo);
4494 /* Append the packet body. */
4495 if (packet_format == 'X')
4497 /* Binary mode. Send target system values byte by byte, in
4498 increasing byte addresses. Only escape certain critical
4500 payload_length = remote_escape_output (myaddr, todo, p, &nr_bytes,
4503 /* If not all TODO bytes fit, then we'll need another packet. Make
4504 a second try to keep the end of the packet aligned. Don't do
4505 this if the packet is tiny. */
4506 if (nr_bytes < todo && nr_bytes > 2 * REMOTE_ALIGN_WRITES)
4510 new_nr_bytes = (((memaddr + nr_bytes) & ~(REMOTE_ALIGN_WRITES - 1))
4512 if (new_nr_bytes != nr_bytes)
4513 payload_length = remote_escape_output (myaddr, new_nr_bytes,
4518 p += payload_length;
4519 if (use_length && nr_bytes < todo)
4521 /* Escape chars have filled up the buffer prematurely,
4522 and we have actually sent fewer bytes than planned.
4523 Fix-up the length field of the packet. Use the same
4524 number of characters as before. */
4525 plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
4526 *plen = ':'; /* overwrite \0 from hexnumnstr() */
4531 /* Normal mode: Send target system values byte by byte, in
4532 increasing byte addresses. Each byte is encoded as a two hex
4534 nr_bytes = bin2hex (myaddr, p, todo);
4538 putpkt_binary (rs->buf, (int) (p - rs->buf));
4539 getpkt (&rs->buf, &rs->buf_size, 0);
4541 if (rs->buf[0] == 'E')
4543 /* There is no correspondance between what the remote protocol
4544 uses for errors and errno codes. We would like a cleaner way
4545 of representing errors (big enough to include errno codes,
4546 bfd_error codes, and others). But for now just return EIO. */
4551 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4552 fewer bytes than we'd planned. */
4556 /* Write memory data directly to the remote machine.
4557 This does not inform the data cache; the data cache uses this.
4558 MEMADDR is the address in the remote memory space.
4559 MYADDR is the address of the buffer in our space.
4560 LEN is the number of bytes.
4562 Returns number of bytes transferred, or 0 (setting errno) for
4563 error. Only transfer a single packet. */
4566 remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
4568 char *packet_format = 0;
4570 /* Check whether the target supports binary download. */
4571 check_binary_download (memaddr);
4573 switch (remote_protocol_packets[PACKET_X].support)
4576 packet_format = "X";
4578 case PACKET_DISABLE:
4579 packet_format = "M";
4581 case PACKET_SUPPORT_UNKNOWN:
4582 internal_error (__FILE__, __LINE__,
4583 _("remote_write_bytes: bad internal state"));
4585 internal_error (__FILE__, __LINE__, _("bad switch"));
4588 return remote_write_bytes_aux (packet_format,
4589 memaddr, myaddr, len, packet_format[0], 1);
4592 /* Read memory data directly from the remote machine.
4593 This does not use the data cache; the data cache uses this.
4594 MEMADDR is the address in the remote memory space.
4595 MYADDR is the address of the buffer in our space.
4596 LEN is the number of bytes.
4598 Returns number of bytes transferred, or 0 for error. */
4600 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4601 remote targets) shouldn't attempt to read the entire buffer.
4602 Instead it should read a single packet worth of data and then
4603 return the byte size of that packet to the caller. The caller (its
4604 caller and its callers caller ;-) already contains code for
4605 handling partial reads. */
4608 remote_read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
4610 struct remote_state *rs = get_remote_state ();
4611 int max_buf_size; /* Max size of packet output buffer. */
4617 max_buf_size = get_memory_read_packet_size ();
4618 /* The packet buffer will be large enough for the payload;
4619 get_memory_packet_size ensures this. */
4628 todo = min (len, max_buf_size / 2); /* num bytes that will fit */
4630 /* construct "m"<memaddr>","<len>" */
4631 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4632 memaddr = remote_address_masked (memaddr);
4635 p += hexnumstr (p, (ULONGEST) memaddr);
4637 p += hexnumstr (p, (ULONGEST) todo);
4641 getpkt (&rs->buf, &rs->buf_size, 0);
4643 if (rs->buf[0] == 'E'
4644 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
4645 && rs->buf[3] == '\0')
4647 /* There is no correspondance between what the remote
4648 protocol uses for errors and errno codes. We would like
4649 a cleaner way of representing errors (big enough to
4650 include errno codes, bfd_error codes, and others). But
4651 for now just return EIO. */
4656 /* Reply describes memory byte by byte,
4657 each byte encoded as two hex characters. */
4660 if ((i = hex2bin (p, myaddr, todo)) < todo)
4662 /* Reply is short. This means that we were able to read
4663 only part of what we wanted to. */
4664 return i + (origlen - len);
4673 /* Read or write LEN bytes from inferior memory at MEMADDR,
4674 transferring to or from debugger address BUFFER. Write to inferior
4675 if SHOULD_WRITE is nonzero. Returns length of data written or
4676 read; 0 for error. TARGET is unused. */
4679 remote_xfer_memory (CORE_ADDR mem_addr, gdb_byte *buffer, int mem_len,
4680 int should_write, struct mem_attrib *attrib,
4681 struct target_ops *target)
4686 res = remote_write_bytes (mem_addr, buffer, mem_len);
4688 res = remote_read_bytes (mem_addr, buffer, mem_len);
4693 /* Sends a packet with content determined by the printf format string
4694 FORMAT and the remaining arguments, then gets the reply. Returns
4695 whether the packet was a success, a failure, or unknown. */
4698 remote_send_printf (const char *format, ...)
4700 struct remote_state *rs = get_remote_state ();
4701 int max_size = get_remote_packet_size ();
4704 va_start (ap, format);
4707 if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
4708 internal_error (__FILE__, __LINE__, "Too long remote packet.");
4710 if (putpkt (rs->buf) < 0)
4711 error (_("Communication problem with target."));
4714 getpkt (&rs->buf, &rs->buf_size, 0);
4716 return packet_check_result (rs->buf);
4720 restore_remote_timeout (void *p)
4722 int value = *(int *)p;
4723 remote_timeout = value;
4726 /* Flash writing can take quite some time. We'll set
4727 effectively infinite timeout for flash operations.
4728 In future, we'll need to decide on a better approach. */
4729 static const int remote_flash_timeout = 1000;
4732 remote_flash_erase (struct target_ops *ops,
4733 ULONGEST address, LONGEST length)
4735 int saved_remote_timeout = remote_timeout;
4736 enum packet_result ret;
4738 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
4739 &saved_remote_timeout);
4740 remote_timeout = remote_flash_timeout;
4742 ret = remote_send_printf ("vFlashErase:%s,%s",
4747 case PACKET_UNKNOWN:
4748 error (_("Remote target does not support flash erase"));
4750 error (_("Error erasing flash with vFlashErase packet"));
4755 do_cleanups (back_to);
4759 remote_flash_write (struct target_ops *ops,
4760 ULONGEST address, LONGEST length,
4761 const gdb_byte *data)
4763 int saved_remote_timeout = remote_timeout;
4765 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
4766 &saved_remote_timeout);
4768 remote_timeout = remote_flash_timeout;
4769 ret = remote_write_bytes_aux ("vFlashWrite:", address, data, length, 'X', 0);
4770 do_cleanups (back_to);
4776 remote_flash_done (struct target_ops *ops)
4778 int saved_remote_timeout = remote_timeout;
4780 struct cleanup *back_to = make_cleanup (restore_remote_timeout,
4781 &saved_remote_timeout);
4783 remote_timeout = remote_flash_timeout;
4784 ret = remote_send_printf ("vFlashDone");
4785 do_cleanups (back_to);
4789 case PACKET_UNKNOWN:
4790 error (_("Remote target does not support vFlashDone"));
4792 error (_("Error finishing flash operation"));
4799 remote_files_info (struct target_ops *ignore)
4801 puts_filtered ("Debugging a target over a serial line.\n");
4804 /* Stuff for dealing with the packets which are part of this protocol.
4805 See comment at top of file for details. */
4807 /* Read a single character from the remote end. */
4810 readchar (int timeout)
4814 ch = serial_readchar (remote_desc, timeout);
4819 switch ((enum serial_rc) ch)
4822 target_mourn_inferior ();
4823 error (_("Remote connection closed"));
4826 perror_with_name (_("Remote communication error"));
4828 case SERIAL_TIMEOUT:
4834 /* Send the command in *BUF to the remote machine, and read the reply
4835 into *BUF. Report an error if we get an error reply. Resize
4836 *BUF using xrealloc if necessary to hold the result, and update
4840 remote_send (char **buf,
4844 getpkt (buf, sizeof_buf, 0);
4846 if ((*buf)[0] == 'E')
4847 error (_("Remote failure reply: %s"), *buf);
4850 /* Display a null-terminated packet on stdout, for debugging, using C
4854 print_packet (char *buf)
4856 puts_filtered ("\"");
4857 fputstr_filtered (buf, '"', gdb_stdout);
4858 puts_filtered ("\"");
4864 return putpkt_binary (buf, strlen (buf));
4867 /* Send a packet to the remote machine, with error checking. The data
4868 of the packet is in BUF. The string in BUF can be at most
4869 get_remote_packet_size () - 5 to account for the $, # and checksum,
4870 and for a possible /0 if we are debugging (remote_debug) and want
4871 to print the sent packet as a string. */
4874 putpkt_binary (char *buf, int cnt)
4876 struct remote_state *rs = get_remote_state ();
4878 unsigned char csum = 0;
4879 char *buf2 = alloca (cnt + 6);
4885 /* We're sending out a new packet. Make sure we don't look at a
4886 stale cached response. */
4887 rs->cached_wait_status = 0;
4889 /* Copy the packet into buffer BUF2, encapsulating it
4890 and giving it a checksum. */
4895 for (i = 0; i < cnt; i++)
4901 *p++ = tohex ((csum >> 4) & 0xf);
4902 *p++ = tohex (csum & 0xf);
4904 /* Send it over and over until we get a positive ack. */
4908 int started_error_output = 0;
4913 fprintf_unfiltered (gdb_stdlog, "Sending packet: ");
4914 fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog);
4915 fprintf_unfiltered (gdb_stdlog, "...");
4916 gdb_flush (gdb_stdlog);
4918 if (serial_write (remote_desc, buf2, p - buf2))
4919 perror_with_name (_("putpkt: write failed"));
4921 /* Read until either a timeout occurs (-2) or '+' is read. */
4924 ch = readchar (remote_timeout);
4932 case SERIAL_TIMEOUT:
4934 if (started_error_output)
4936 putchar_unfiltered ('\n');
4937 started_error_output = 0;
4946 fprintf_unfiltered (gdb_stdlog, "Ack\n");
4950 fprintf_unfiltered (gdb_stdlog, "Nak\n");
4951 case SERIAL_TIMEOUT:
4955 break; /* Retransmit buffer. */
4959 fprintf_unfiltered (gdb_stdlog,
4960 "Packet instead of Ack, ignoring it\n");
4961 /* It's probably an old response sent because an ACK
4962 was lost. Gobble up the packet and ack it so it
4963 doesn't get retransmitted when we resend this
4966 serial_write (remote_desc, "+", 1);
4967 continue; /* Now, go look for +. */
4972 if (!started_error_output)
4974 started_error_output = 1;
4975 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
4977 fputc_unfiltered (ch & 0177, gdb_stdlog);
4981 break; /* Here to retransmit. */
4985 /* This is wrong. If doing a long backtrace, the user should be
4986 able to get out next time we call QUIT, without anything as
4987 violent as interrupt_query. If we want to provide a way out of
4988 here without getting to the next QUIT, it should be based on
4989 hitting ^C twice as in remote_wait. */
4999 /* Come here after finding the start of a frame when we expected an
5000 ack. Do our best to discard the rest of this packet. */
5009 c = readchar (remote_timeout);
5012 case SERIAL_TIMEOUT:
5013 /* Nothing we can do. */
5016 /* Discard the two bytes of checksum and stop. */
5017 c = readchar (remote_timeout);
5019 c = readchar (remote_timeout);
5022 case '*': /* Run length encoding. */
5023 /* Discard the repeat count. */
5024 c = readchar (remote_timeout);
5029 /* A regular character. */
5035 /* Come here after finding the start of the frame. Collect the rest
5036 into *BUF, verifying the checksum, length, and handling run-length
5037 compression. NUL terminate the buffer. If there is not enough room,
5038 expand *BUF using xrealloc.
5040 Returns -1 on error, number of characters in buffer (ignoring the
5041 trailing NULL) on success. (could be extended to return one of the
5042 SERIAL status indications). */
5045 read_frame (char **buf_p,
5058 c = readchar (remote_timeout);
5061 case SERIAL_TIMEOUT:
5063 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
5067 fputs_filtered ("Saw new packet start in middle of old one\n",
5069 return -1; /* Start a new packet, count retries. */
5072 unsigned char pktcsum;
5078 check_0 = readchar (remote_timeout);
5080 check_1 = readchar (remote_timeout);
5082 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
5085 fputs_filtered ("Timeout in checksum, retrying\n",
5089 else if (check_0 < 0 || check_1 < 0)
5092 fputs_filtered ("Communication error in checksum\n",
5097 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
5098 if (csum == pktcsum)
5103 fprintf_filtered (gdb_stdlog,
5104 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
5106 fputstrn_filtered (buf, bc, 0, gdb_stdlog);
5107 fputs_filtered ("\n", gdb_stdlog);
5109 /* Number of characters in buffer ignoring trailing
5113 case '*': /* Run length encoding. */
5118 c = readchar (remote_timeout);
5120 repeat = c - ' ' + 3; /* Compute repeat count. */
5122 /* The character before ``*'' is repeated. */
5124 if (repeat > 0 && repeat <= 255 && bc > 0)
5126 if (bc + repeat - 1 >= *sizeof_buf - 1)
5128 /* Make some more room in the buffer. */
5129 *sizeof_buf += repeat;
5130 *buf_p = xrealloc (*buf_p, *sizeof_buf);
5134 memset (&buf[bc], buf[bc - 1], repeat);
5140 printf_filtered (_("Invalid run length encoding: %s\n"), buf);
5144 if (bc >= *sizeof_buf - 1)
5146 /* Make some more room in the buffer. */
5148 *buf_p = xrealloc (*buf_p, *sizeof_buf);
5159 /* Read a packet from the remote machine, with error checking, and
5160 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
5161 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
5162 rather than timing out; this is used (in synchronous mode) to wait
5163 for a target that is is executing user code to stop. */
5164 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
5165 don't have to change all the calls to getpkt to deal with the
5166 return value, because at the moment I don't know what the right
5167 thing to do it for those. */
5175 timed_out = getpkt_sane (buf, sizeof_buf, forever);
5179 /* Read a packet from the remote machine, with error checking, and
5180 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
5181 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
5182 rather than timing out; this is used (in synchronous mode) to wait
5183 for a target that is is executing user code to stop. If FOREVER ==
5184 0, this function is allowed to time out gracefully and return an
5185 indication of this to the caller. Otherwise return the number
5188 getpkt_sane (char **buf, long *sizeof_buf, int forever)
5190 struct remote_state *rs = get_remote_state ();
5196 /* We're reading a new response. Make sure we don't look at a
5197 previously cached response. */
5198 rs->cached_wait_status = 0;
5200 strcpy (*buf, "timeout");
5204 timeout = watchdog > 0 ? watchdog : -1;
5208 timeout = remote_timeout;
5212 for (tries = 1; tries <= MAX_TRIES; tries++)
5214 /* This can loop forever if the remote side sends us characters
5215 continuously, but if it pauses, we'll get a zero from
5216 readchar because of timeout. Then we'll count that as a
5219 /* Note that we will only wait forever prior to the start of a
5220 packet. After that, we expect characters to arrive at a
5221 brisk pace. They should show up within remote_timeout
5226 c = readchar (timeout);
5228 if (c == SERIAL_TIMEOUT)
5230 if (forever) /* Watchdog went off? Kill the target. */
5233 target_mourn_inferior ();
5234 error (_("Watchdog timeout has expired. Target detached."));
5237 fputs_filtered ("Timed out.\n", gdb_stdlog);
5243 /* We've found the start of a packet, now collect the data. */
5245 val = read_frame (buf, sizeof_buf);
5251 fprintf_unfiltered (gdb_stdlog, "Packet received: ");
5252 fputstrn_unfiltered (*buf, val, 0, gdb_stdlog);
5253 fprintf_unfiltered (gdb_stdlog, "\n");
5255 serial_write (remote_desc, "+", 1);
5259 /* Try the whole thing again. */
5261 serial_write (remote_desc, "-", 1);
5264 /* We have tried hard enough, and just can't receive the packet.
5267 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
5268 serial_write (remote_desc, "+", 1);
5275 /* For some mysterious reason, wait_for_inferior calls kill instead of
5276 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5280 target_mourn_inferior ();
5284 /* Use catch_errors so the user can quit from gdb even when we aren't on
5285 speaking terms with the remote system. */
5286 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
5288 /* Don't wait for it to die. I'm not really sure it matters whether
5289 we do or not. For the existing stubs, kill is a noop. */
5290 target_mourn_inferior ();
5293 /* Async version of remote_kill. */
5295 remote_async_kill (void)
5297 /* Unregister the file descriptor from the event loop. */
5298 if (target_is_async_p ())
5299 serial_async (remote_desc, NULL, 0);
5301 /* For some mysterious reason, wait_for_inferior calls kill instead of
5302 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5306 target_mourn_inferior ();
5310 /* Use catch_errors so the user can quit from gdb even when we
5311 aren't on speaking terms with the remote system. */
5312 catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
5314 /* Don't wait for it to die. I'm not really sure it matters whether
5315 we do or not. For the existing stubs, kill is a noop. */
5316 target_mourn_inferior ();
5322 remote_mourn_1 (&remote_ops);
5326 remote_async_mourn (void)
5328 remote_mourn_1 (&remote_async_ops);
5331 /* Worker function for remote_mourn. */
5333 remote_mourn_1 (struct target_ops *target)
5335 unpush_target (target);
5336 generic_mourn_inferior ();
5340 extended_remote_mourn_1 (struct target_ops *target)
5342 struct remote_state *rs = get_remote_state ();
5344 /* Unlike "target remote", we do not want to unpush the target; then
5345 the next time the user says "run", we won't be connected. */
5347 /* Call common code to mark the inferior as not running. */
5348 generic_mourn_inferior ();
5350 /* Check whether the target is running now - some remote stubs
5351 automatically restart after kill. */
5353 getpkt (&rs->buf, &rs->buf_size, 0);
5355 if (rs->buf[0] == 'S' || rs->buf[0] == 'T')
5357 /* Assume that the target has been restarted. Set inferior_ptid
5358 so that bits of core GDB realizes there's something here, e.g.,
5359 so that the user can say "kill" again. */
5360 inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
5364 /* Mark this (still pushed) target as not executable until we
5366 target_mark_exited (target);
5371 extended_remote_mourn (void)
5373 extended_remote_mourn_1 (&extended_remote_ops);
5377 extended_async_remote_mourn (void)
5379 extended_remote_mourn_1 (&extended_async_remote_ops);
5383 extended_remote_run (char *args)
5385 struct remote_state *rs = get_remote_state ();
5389 /* If the user has disabled vRun support, or we have detected that
5390 support is not available, do not try it. */
5391 if (remote_protocol_packets[PACKET_vRun].support == PACKET_DISABLE)
5394 strcpy (rs->buf, "vRun;");
5395 len = strlen (rs->buf);
5397 if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ())
5398 error (_("Remote file name too long for run packet"));
5399 len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf + len, 0);
5403 struct cleanup *back_to;
5407 argv = buildargv (args);
5408 back_to = make_cleanup ((void (*) (void *)) freeargv, argv);
5409 for (i = 0; argv[i] != NULL; i++)
5411 if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ())
5412 error (_("Argument list too long for run packet"));
5413 rs->buf[len++] = ';';
5414 len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf + len, 0);
5416 do_cleanups (back_to);
5419 rs->buf[len++] = '\0';
5422 getpkt (&rs->buf, &rs->buf_size, 0);
5424 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]) == PACKET_OK)
5426 /* We have a wait response; we don't need it, though. All is well. */
5429 else if (remote_protocol_packets[PACKET_vRun].support == PACKET_DISABLE)
5430 /* It wasn't disabled before, but it is now. */
5434 if (remote_exec_file[0] == '\0')
5435 error (_("Running the default executable on the remote target failed; "
5436 "try \"set remote exec-file\"?"));
5438 error (_("Running \"%s\" on the remote target failed"),
5443 /* In the extended protocol we want to be able to do things like
5444 "run" and have them basically work as expected. So we need
5445 a special create_inferior function. We support changing the
5446 executable file and the command line arguments, but not the
5450 extended_remote_create_inferior_1 (char *exec_file, char *args,
5451 char **env, int from_tty,
5454 /* If running asynchronously, register the target file descriptor
5455 with the event loop. */
5456 if (async_p && target_can_async_p ())
5457 target_async (inferior_event_handler, 0);
5459 /* Now restart the remote server. */
5460 if (extended_remote_run (args) == -1)
5462 /* vRun was not supported. Fail if we need it to do what the
5464 if (remote_exec_file[0])
5465 error (_("Remote target does not support \"set remote exec-file\""));
5467 error (_("Remote target does not support \"set args\" or run <ARGS>"));
5469 /* Fall back to "R". */
5470 extended_remote_restart ();
5473 /* Clean up from the last time we ran, before we mark the target
5474 running again. This will mark breakpoints uninserted, and
5475 get_offsets may insert breakpoints. */
5476 init_thread_list ();
5477 init_wait_for_inferior ();
5479 /* Now mark the inferior as running before we do anything else. */
5481 inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
5483 target_mark_running (&extended_async_remote_ops);
5485 target_mark_running (&extended_remote_ops);
5487 /* Get updated offsets, if the stub uses qOffsets. */
5492 extended_remote_create_inferior (char *exec_file, char *args,
5493 char **env, int from_tty)
5495 extended_remote_create_inferior_1 (exec_file, args, env, from_tty, 0);
5499 extended_remote_async_create_inferior (char *exec_file, char *args,
5500 char **env, int from_tty)
5502 extended_remote_create_inferior_1 (exec_file, args, env, from_tty, 1);
5506 /* Insert a breakpoint. On targets that have software breakpoint
5507 support, we ask the remote target to do the work; on targets
5508 which don't, we insert a traditional memory breakpoint. */
5511 remote_insert_breakpoint (struct bp_target_info *bp_tgt)
5513 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5514 If it succeeds, then set the support to PACKET_ENABLE. If it
5515 fails, and the user has explicitly requested the Z support then
5516 report an error, otherwise, mark it disabled and go on. */
5518 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
5521 struct remote_state *rs;
5524 gdbarch_breakpoint_from_pc
5525 (current_gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
5527 rs = get_remote_state ();
5533 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
5534 p += hexnumstr (p, addr);
5535 sprintf (p, ",%d", bp_tgt->placed_size);
5538 getpkt (&rs->buf, &rs->buf_size, 0);
5540 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
5546 case PACKET_UNKNOWN:
5551 return memory_insert_breakpoint (bp_tgt);
5555 remote_remove_breakpoint (struct bp_target_info *bp_tgt)
5557 CORE_ADDR addr = bp_tgt->placed_address;
5558 struct remote_state *rs = get_remote_state ();
5561 if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
5569 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
5570 p += hexnumstr (p, addr);
5571 sprintf (p, ",%d", bp_tgt->placed_size);
5574 getpkt (&rs->buf, &rs->buf_size, 0);
5576 return (rs->buf[0] == 'E');
5579 return memory_remove_breakpoint (bp_tgt);
5583 watchpoint_to_Z_packet (int type)
5588 return Z_PACKET_WRITE_WP;
5591 return Z_PACKET_READ_WP;
5594 return Z_PACKET_ACCESS_WP;
5597 internal_error (__FILE__, __LINE__,
5598 _("hw_bp_to_z: bad watchpoint type %d"), type);
5603 remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
5605 struct remote_state *rs = get_remote_state ();
5607 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
5609 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
5612 sprintf (rs->buf, "Z%x,", packet);
5613 p = strchr (rs->buf, '\0');
5614 addr = remote_address_masked (addr);
5615 p += hexnumstr (p, (ULONGEST) addr);
5616 sprintf (p, ",%x", len);
5619 getpkt (&rs->buf, &rs->buf_size, 0);
5621 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
5624 case PACKET_UNKNOWN:
5629 internal_error (__FILE__, __LINE__,
5630 _("remote_insert_watchpoint: reached end of function"));
5635 remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
5637 struct remote_state *rs = get_remote_state ();
5639 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
5641 if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
5644 sprintf (rs->buf, "z%x,", packet);
5645 p = strchr (rs->buf, '\0');
5646 addr = remote_address_masked (addr);
5647 p += hexnumstr (p, (ULONGEST) addr);
5648 sprintf (p, ",%x", len);
5650 getpkt (&rs->buf, &rs->buf_size, 0);
5652 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
5655 case PACKET_UNKNOWN:
5660 internal_error (__FILE__, __LINE__,
5661 _("remote_remove_watchpoint: reached end of function"));
5665 int remote_hw_watchpoint_limit = -1;
5666 int remote_hw_breakpoint_limit = -1;
5669 remote_check_watch_resources (int type, int cnt, int ot)
5671 if (type == bp_hardware_breakpoint)
5673 if (remote_hw_breakpoint_limit == 0)
5675 else if (remote_hw_breakpoint_limit < 0)
5677 else if (cnt <= remote_hw_breakpoint_limit)
5682 if (remote_hw_watchpoint_limit == 0)
5684 else if (remote_hw_watchpoint_limit < 0)
5688 else if (cnt <= remote_hw_watchpoint_limit)
5695 remote_stopped_by_watchpoint (void)
5697 return remote_stopped_by_watchpoint_p;
5701 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
5704 if (remote_stopped_by_watchpoint ())
5706 *addr_p = remote_watch_data_address;
5715 remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
5718 struct remote_state *rs;
5721 /* The length field should be set to the size of a breakpoint
5722 instruction, even though we aren't inserting one ourselves. */
5724 gdbarch_breakpoint_from_pc
5725 (current_gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
5727 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
5730 rs = get_remote_state ();
5737 addr = remote_address_masked (bp_tgt->placed_address);
5738 p += hexnumstr (p, (ULONGEST) addr);
5739 sprintf (p, ",%x", bp_tgt->placed_size);
5742 getpkt (&rs->buf, &rs->buf_size, 0);
5744 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
5747 case PACKET_UNKNOWN:
5752 internal_error (__FILE__, __LINE__,
5753 _("remote_insert_hw_breakpoint: reached end of function"));
5758 remote_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
5761 struct remote_state *rs = get_remote_state ();
5764 if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
5771 addr = remote_address_masked (bp_tgt->placed_address);
5772 p += hexnumstr (p, (ULONGEST) addr);
5773 sprintf (p, ",%x", bp_tgt->placed_size);
5776 getpkt (&rs->buf, &rs->buf_size, 0);
5778 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
5781 case PACKET_UNKNOWN:
5786 internal_error (__FILE__, __LINE__,
5787 _("remote_remove_hw_breakpoint: reached end of function"));
5790 /* Some targets are only capable of doing downloads, and afterwards
5791 they switch to the remote serial protocol. This function provides
5792 a clean way to get from the download target to the remote target.
5793 It's basically just a wrapper so that we don't have to expose any
5794 of the internal workings of remote.c.
5796 Prior to calling this routine, you should shutdown the current
5797 target code, else you will get the "A program is being debugged
5798 already..." message. Usually a call to pop_target() suffices. */
5801 push_remote_target (char *name, int from_tty)
5803 printf_filtered (_("Switching to remote protocol\n"));
5804 remote_open (name, from_tty);
5807 /* Table used by the crc32 function to calcuate the checksum. */
5809 static unsigned long crc32_table[256] =
5812 static unsigned long
5813 crc32 (unsigned char *buf, int len, unsigned int crc)
5815 if (!crc32_table[1])
5817 /* Initialize the CRC table and the decoding table. */
5821 for (i = 0; i < 256; i++)
5823 for (c = i << 24, j = 8; j > 0; --j)
5824 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
5831 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
5837 /* compare-sections command
5839 With no arguments, compares each loadable section in the exec bfd
5840 with the same memory range on the target, and reports mismatches.
5841 Useful for verifying the image on the target against the exec file.
5842 Depends on the target understanding the new "qCRC:" request. */
5844 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5845 target method (target verify memory) and generic version of the
5846 actual command. This will allow other high-level code (especially
5847 generic_load()) to make use of this target functionality. */
5850 compare_sections_command (char *args, int from_tty)
5852 struct remote_state *rs = get_remote_state ();
5854 unsigned long host_crc, target_crc;
5855 extern bfd *exec_bfd;
5856 struct cleanup *old_chain;
5859 const char *sectname;
5866 error (_("command cannot be used without an exec file"));
5867 if (!current_target.to_shortname ||
5868 strcmp (current_target.to_shortname, "remote") != 0)
5869 error (_("command can only be used with remote target"));
5871 for (s = exec_bfd->sections; s; s = s->next)
5873 if (!(s->flags & SEC_LOAD))
5874 continue; /* skip non-loadable section */
5876 size = bfd_get_section_size (s);
5878 continue; /* skip zero-length section */
5880 sectname = bfd_get_section_name (exec_bfd, s);
5881 if (args && strcmp (args, sectname) != 0)
5882 continue; /* not the section selected by user */
5884 matched = 1; /* do this section */
5886 /* FIXME: assumes lma can fit into long. */
5887 xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
5888 (long) lma, (long) size);
5891 /* Be clever; compute the host_crc before waiting for target
5893 sectdata = xmalloc (size);
5894 old_chain = make_cleanup (xfree, sectdata);
5895 bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
5896 host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
5898 getpkt (&rs->buf, &rs->buf_size, 0);
5899 if (rs->buf[0] == 'E')
5900 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5901 sectname, paddr (lma), paddr (lma + size));
5902 if (rs->buf[0] != 'C')
5903 error (_("remote target does not support this operation"));
5905 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
5906 target_crc = target_crc * 16 + fromhex (*tmp);
5908 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5909 sectname, paddr (lma), paddr (lma + size));
5910 if (host_crc == target_crc)
5911 printf_filtered ("matched.\n");
5914 printf_filtered ("MIS-MATCHED!\n");
5918 do_cleanups (old_chain);
5921 warning (_("One or more sections of the remote executable does not match\n\
5922 the loaded file\n"));
5923 if (args && !matched)
5924 printf_filtered (_("No loaded section named '%s'.\n"), args);
5927 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5928 into remote target. The number of bytes written to the remote
5929 target is returned, or -1 for error. */
5932 remote_write_qxfer (struct target_ops *ops, const char *object_name,
5933 const char *annex, const gdb_byte *writebuf,
5934 ULONGEST offset, LONGEST len,
5935 struct packet_config *packet)
5940 struct remote_state *rs = get_remote_state ();
5941 int max_size = get_memory_write_packet_size ();
5943 if (packet->support == PACKET_DISABLE)
5946 /* Insert header. */
5947 i = snprintf (rs->buf, max_size,
5948 "qXfer:%s:write:%s:%s:",
5949 object_name, annex ? annex : "",
5950 phex_nz (offset, sizeof offset));
5951 max_size -= (i + 1);
5953 /* Escape as much data as fits into rs->buf. */
5954 buf_len = remote_escape_output
5955 (writebuf, len, (rs->buf + i), &max_size, max_size);
5957 if (putpkt_binary (rs->buf, i + buf_len) < 0
5958 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
5959 || packet_ok (rs->buf, packet) != PACKET_OK)
5962 unpack_varlen_hex (rs->buf, &n);
5966 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5967 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5968 number of bytes read is returned, or 0 for EOF, or -1 for error.
5969 The number of bytes read may be less than LEN without indicating an
5970 EOF. PACKET is checked and updated to indicate whether the remote
5971 target supports this object. */
5974 remote_read_qxfer (struct target_ops *ops, const char *object_name,
5976 gdb_byte *readbuf, ULONGEST offset, LONGEST len,
5977 struct packet_config *packet)
5979 static char *finished_object;
5980 static char *finished_annex;
5981 static ULONGEST finished_offset;
5983 struct remote_state *rs = get_remote_state ();
5984 unsigned int total = 0;
5985 LONGEST i, n, packet_len;
5987 if (packet->support == PACKET_DISABLE)
5990 /* Check whether we've cached an end-of-object packet that matches
5992 if (finished_object)
5994 if (strcmp (object_name, finished_object) == 0
5995 && strcmp (annex ? annex : "", finished_annex) == 0
5996 && offset == finished_offset)
5999 /* Otherwise, we're now reading something different. Discard
6001 xfree (finished_object);
6002 xfree (finished_annex);
6003 finished_object = NULL;
6004 finished_annex = NULL;
6007 /* Request only enough to fit in a single packet. The actual data
6008 may not, since we don't know how much of it will need to be escaped;
6009 the target is free to respond with slightly less data. We subtract
6010 five to account for the response type and the protocol frame. */
6011 n = min (get_remote_packet_size () - 5, len);
6012 snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
6013 object_name, annex ? annex : "",
6014 phex_nz (offset, sizeof offset),
6015 phex_nz (n, sizeof n));
6016 i = putpkt (rs->buf);
6021 packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
6022 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
6025 if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
6026 error (_("Unknown remote qXfer reply: %s"), rs->buf);
6028 /* 'm' means there is (or at least might be) more data after this
6029 batch. That does not make sense unless there's at least one byte
6030 of data in this reply. */
6031 if (rs->buf[0] == 'm' && packet_len == 1)
6032 error (_("Remote qXfer reply contained no data."));
6034 /* Got some data. */
6035 i = remote_unescape_input (rs->buf + 1, packet_len - 1, readbuf, n);
6037 /* 'l' is an EOF marker, possibly including a final block of data,
6038 or possibly empty. If we have the final block of a non-empty
6039 object, record this fact to bypass a subsequent partial read. */
6040 if (rs->buf[0] == 'l' && offset + i > 0)
6042 finished_object = xstrdup (object_name);
6043 finished_annex = xstrdup (annex ? annex : "");
6044 finished_offset = offset + i;
6051 remote_xfer_partial (struct target_ops *ops, enum target_object object,
6052 const char *annex, gdb_byte *readbuf,
6053 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
6055 struct remote_state *rs = get_remote_state ();
6060 /* Handle memory using the standard memory routines. */
6061 if (object == TARGET_OBJECT_MEMORY)
6066 /* If the remote target is connected but not running, we should
6067 pass this request down to a lower stratum (e.g. the executable
6069 if (!target_has_execution)
6072 if (writebuf != NULL)
6073 xfered = remote_write_bytes (offset, writebuf, len);
6075 xfered = remote_read_bytes (offset, readbuf, len);
6079 else if (xfered == 0 && errno == 0)
6085 /* Handle SPU memory using qxfer packets. */
6086 if (object == TARGET_OBJECT_SPU)
6089 return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len,
6090 &remote_protocol_packets
6091 [PACKET_qXfer_spu_read]);
6093 return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len,
6094 &remote_protocol_packets
6095 [PACKET_qXfer_spu_write]);
6098 /* Only handle flash writes. */
6099 if (writebuf != NULL)
6105 case TARGET_OBJECT_FLASH:
6106 xfered = remote_flash_write (ops, offset, len, writebuf);
6110 else if (xfered == 0 && errno == 0)
6120 /* Map pre-existing objects onto letters. DO NOT do this for new
6121 objects!!! Instead specify new query packets. */
6124 case TARGET_OBJECT_AVR:
6128 case TARGET_OBJECT_AUXV:
6129 gdb_assert (annex == NULL);
6130 return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
6131 &remote_protocol_packets[PACKET_qXfer_auxv]);
6133 case TARGET_OBJECT_AVAILABLE_FEATURES:
6134 return remote_read_qxfer
6135 (ops, "features", annex, readbuf, offset, len,
6136 &remote_protocol_packets[PACKET_qXfer_features]);
6138 case TARGET_OBJECT_LIBRARIES:
6139 return remote_read_qxfer
6140 (ops, "libraries", annex, readbuf, offset, len,
6141 &remote_protocol_packets[PACKET_qXfer_libraries]);
6143 case TARGET_OBJECT_MEMORY_MAP:
6144 gdb_assert (annex == NULL);
6145 return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,
6146 &remote_protocol_packets[PACKET_qXfer_memory_map]);
6152 /* Note: a zero OFFSET and LEN can be used to query the minimum
6154 if (offset == 0 && len == 0)
6155 return (get_remote_packet_size ());
6156 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
6157 large enough let the caller deal with it. */
6158 if (len < get_remote_packet_size ())
6160 len = get_remote_packet_size ();
6162 /* Except for querying the minimum buffer size, target must be open. */
6164 error (_("remote query is only available after target open"));
6166 gdb_assert (annex != NULL);
6167 gdb_assert (readbuf != NULL);
6173 /* We used one buffer char for the remote protocol q command and
6174 another for the query type. As the remote protocol encapsulation
6175 uses 4 chars plus one extra in case we are debugging
6176 (remote_debug), we have PBUFZIZ - 7 left to pack the query
6179 while (annex[i] && (i < (get_remote_packet_size () - 8)))
6181 /* Bad caller may have sent forbidden characters. */
6182 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
6187 gdb_assert (annex[i] == '\0');
6189 i = putpkt (rs->buf);
6193 getpkt (&rs->buf, &rs->buf_size, 0);
6194 strcpy ((char *) readbuf, rs->buf);
6196 return strlen ((char *) readbuf);
6200 remote_search_memory (struct target_ops* ops,
6201 CORE_ADDR start_addr, ULONGEST search_space_len,
6202 const gdb_byte *pattern, ULONGEST pattern_len,
6203 CORE_ADDR *found_addrp)
6205 struct remote_state *rs = get_remote_state ();
6206 int max_size = get_memory_write_packet_size ();
6207 struct packet_config *packet =
6208 &remote_protocol_packets[PACKET_qSearch_memory];
6209 /* number of packet bytes used to encode the pattern,
6210 this could be more than PATTERN_LEN due to escape characters */
6211 int escaped_pattern_len;
6212 /* amount of pattern that was encodable in the packet */
6213 int used_pattern_len;
6216 ULONGEST found_addr;
6218 /* Don't go to the target if we don't have to.
6219 This is done before checking packet->support to avoid the possibility that
6220 a success for this edge case means the facility works in general. */
6221 if (pattern_len > search_space_len)
6223 if (pattern_len == 0)
6225 *found_addrp = start_addr;
6229 /* If we already know the packet isn't supported, fall back to the simple
6230 way of searching memory. */
6232 if (packet->support == PACKET_DISABLE)
6234 /* Target doesn't provided special support, fall back and use the
6235 standard support (copy memory and do the search here). */
6236 return simple_search_memory (ops, start_addr, search_space_len,
6237 pattern, pattern_len, found_addrp);
6240 /* Insert header. */
6241 i = snprintf (rs->buf, max_size,
6242 "qSearch:memory:%s;%s;",
6243 paddr_nz (start_addr),
6244 phex_nz (search_space_len, sizeof (search_space_len)));
6245 max_size -= (i + 1);
6247 /* Escape as much data as fits into rs->buf. */
6248 escaped_pattern_len =
6249 remote_escape_output (pattern, pattern_len, (rs->buf + i),
6250 &used_pattern_len, max_size);
6252 /* Bail if the pattern is too large. */
6253 if (used_pattern_len != pattern_len)
6254 error ("Pattern is too large to transmit to remote target.");
6256 if (putpkt_binary (rs->buf, i + escaped_pattern_len) < 0
6257 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
6258 || packet_ok (rs->buf, packet) != PACKET_OK)
6260 /* The request may not have worked because the command is not
6261 supported. If so, fall back to the simple way. */
6262 if (packet->support == PACKET_DISABLE)
6264 return simple_search_memory (ops, start_addr, search_space_len,
6265 pattern, pattern_len, found_addrp);
6270 if (rs->buf[0] == '0')
6272 else if (rs->buf[0] == '1')
6275 if (rs->buf[1] != ',')
6276 error (_("Unknown qSearch:memory reply: %s"), rs->buf);
6277 unpack_varlen_hex (rs->buf + 2, &found_addr);
6278 *found_addrp = found_addr;
6281 error (_("Unknown qSearch:memory reply: %s"), rs->buf);
6287 remote_rcmd (char *command,
6288 struct ui_file *outbuf)
6290 struct remote_state *rs = get_remote_state ();
6294 error (_("remote rcmd is only available after target open"));
6296 /* Send a NULL command across as an empty command. */
6297 if (command == NULL)
6300 /* The query prefix. */
6301 strcpy (rs->buf, "qRcmd,");
6302 p = strchr (rs->buf, '\0');
6304 if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
6305 error (_("\"monitor\" command ``%s'' is too long."), command);
6307 /* Encode the actual command. */
6308 bin2hex ((gdb_byte *) command, p, 0);
6310 if (putpkt (rs->buf) < 0)
6311 error (_("Communication problem with target."));
6313 /* get/display the response */
6318 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
6320 getpkt (&rs->buf, &rs->buf_size, 0);
6323 error (_("Target does not support this command."));
6324 if (buf[0] == 'O' && buf[1] != 'K')
6326 remote_console_output (buf + 1); /* 'O' message from stub. */
6329 if (strcmp (buf, "OK") == 0)
6331 if (strlen (buf) == 3 && buf[0] == 'E'
6332 && isdigit (buf[1]) && isdigit (buf[2]))
6334 error (_("Protocol error with Rcmd"));
6336 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
6338 char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
6339 fputc_unfiltered (c, outbuf);
6345 static VEC(mem_region_s) *
6346 remote_memory_map (struct target_ops *ops)
6348 VEC(mem_region_s) *result = NULL;
6349 char *text = target_read_stralloc (¤t_target,
6350 TARGET_OBJECT_MEMORY_MAP, NULL);
6354 struct cleanup *back_to = make_cleanup (xfree, text);
6355 result = parse_memory_map (text);
6356 do_cleanups (back_to);
6363 packet_command (char *args, int from_tty)
6365 struct remote_state *rs = get_remote_state ();
6368 error (_("command can only be used with remote target"));
6371 error (_("remote-packet command requires packet text as argument"));
6373 puts_filtered ("sending: ");
6374 print_packet (args);
6375 puts_filtered ("\n");
6378 getpkt (&rs->buf, &rs->buf_size, 0);
6379 puts_filtered ("received: ");
6380 print_packet (rs->buf);
6381 puts_filtered ("\n");
6385 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
6387 static void display_thread_info (struct gdb_ext_thread_info *info);
6389 static void threadset_test_cmd (char *cmd, int tty);
6391 static void threadalive_test (char *cmd, int tty);
6393 static void threadlist_test_cmd (char *cmd, int tty);
6395 int get_and_display_threadinfo (threadref *ref);
6397 static void threadinfo_test_cmd (char *cmd, int tty);
6399 static int thread_display_step (threadref *ref, void *context);
6401 static void threadlist_update_test_cmd (char *cmd, int tty);
6403 static void init_remote_threadtests (void);
6405 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
6408 threadset_test_cmd (char *cmd, int tty)
6410 int sample_thread = SAMPLE_THREAD;
6412 printf_filtered (_("Remote threadset test\n"));
6413 set_thread (sample_thread, 1);
6418 threadalive_test (char *cmd, int tty)
6420 int sample_thread = SAMPLE_THREAD;
6422 if (remote_thread_alive (pid_to_ptid (sample_thread)))
6423 printf_filtered ("PASS: Thread alive test\n");
6425 printf_filtered ("FAIL: Thread alive test\n");
6428 void output_threadid (char *title, threadref *ref);
6431 output_threadid (char *title, threadref *ref)
6435 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */
6437 printf_filtered ("%s %s\n", title, (&hexid[0]));
6441 threadlist_test_cmd (char *cmd, int tty)
6444 threadref nextthread;
6445 int done, result_count;
6446 threadref threadlist[3];
6448 printf_filtered ("Remote Threadlist test\n");
6449 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
6450 &result_count, &threadlist[0]))
6451 printf_filtered ("FAIL: threadlist test\n");
6454 threadref *scan = threadlist;
6455 threadref *limit = scan + result_count;
6457 while (scan < limit)
6458 output_threadid (" thread ", scan++);
6463 display_thread_info (struct gdb_ext_thread_info *info)
6465 output_threadid ("Threadid: ", &info->threadid);
6466 printf_filtered ("Name: %s\n ", info->shortname);
6467 printf_filtered ("State: %s\n", info->display);
6468 printf_filtered ("other: %s\n\n", info->more_display);
6472 get_and_display_threadinfo (threadref *ref)
6476 struct gdb_ext_thread_info threadinfo;
6478 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
6479 | TAG_MOREDISPLAY | TAG_DISPLAY;
6480 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
6481 display_thread_info (&threadinfo);
6486 threadinfo_test_cmd (char *cmd, int tty)
6488 int athread = SAMPLE_THREAD;
6492 int_to_threadref (&thread, athread);
6493 printf_filtered ("Remote Threadinfo test\n");
6494 if (!get_and_display_threadinfo (&thread))
6495 printf_filtered ("FAIL cannot get thread info\n");
6499 thread_display_step (threadref *ref, void *context)
6501 /* output_threadid(" threadstep ",ref); *//* simple test */
6502 return get_and_display_threadinfo (ref);
6506 threadlist_update_test_cmd (char *cmd, int tty)
6508 printf_filtered ("Remote Threadlist update test\n");
6509 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
6513 init_remote_threadtests (void)
6515 add_com ("tlist", class_obscure, threadlist_test_cmd, _("\
6516 Fetch and print the remote list of thread identifiers, one pkt only"));
6517 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
6518 _("Fetch and display info about one thread"));
6519 add_com ("tset", class_obscure, threadset_test_cmd,
6520 _("Test setting to a different thread"));
6521 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
6522 _("Iterate through updating all remote thread info"));
6523 add_com ("talive", class_obscure, threadalive_test,
6524 _(" Remote thread alive test "));
6529 /* Convert a thread ID to a string. Returns the string in a static
6533 remote_pid_to_str (ptid_t ptid)
6535 static char buf[32];
6537 xsnprintf (buf, sizeof buf, "Thread %d", ptid_get_pid (ptid));
6541 /* Get the address of the thread local variable in OBJFILE which is
6542 stored at OFFSET within the thread local storage for thread PTID. */
6545 remote_get_thread_local_address (ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
6547 if (remote_protocol_packets[PACKET_qGetTLSAddr].support != PACKET_DISABLE)
6549 struct remote_state *rs = get_remote_state ();
6551 enum packet_result result;
6553 strcpy (p, "qGetTLSAddr:");
6555 p += hexnumstr (p, PIDGET (ptid));
6557 p += hexnumstr (p, offset);
6559 p += hexnumstr (p, lm);
6563 getpkt (&rs->buf, &rs->buf_size, 0);
6564 result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTLSAddr]);
6565 if (result == PACKET_OK)
6569 unpack_varlen_hex (rs->buf, &result);
6572 else if (result == PACKET_UNKNOWN)
6573 throw_error (TLS_GENERIC_ERROR,
6574 _("Remote target doesn't support qGetTLSAddr packet"));
6576 throw_error (TLS_GENERIC_ERROR,
6577 _("Remote target failed to process qGetTLSAddr request"));
6580 throw_error (TLS_GENERIC_ERROR,
6581 _("TLS not supported or disabled on this target"));
6586 /* Support for inferring a target description based on the current
6587 architecture and the size of a 'g' packet. While the 'g' packet
6588 can have any size (since optional registers can be left off the
6589 end), some sizes are easily recognizable given knowledge of the
6590 approximate architecture. */
6592 struct remote_g_packet_guess
6595 const struct target_desc *tdesc;
6597 typedef struct remote_g_packet_guess remote_g_packet_guess_s;
6598 DEF_VEC_O(remote_g_packet_guess_s);
6600 struct remote_g_packet_data
6602 VEC(remote_g_packet_guess_s) *guesses;
6605 static struct gdbarch_data *remote_g_packet_data_handle;
6608 remote_g_packet_data_init (struct obstack *obstack)
6610 return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data);
6614 register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes,
6615 const struct target_desc *tdesc)
6617 struct remote_g_packet_data *data
6618 = gdbarch_data (gdbarch, remote_g_packet_data_handle);
6619 struct remote_g_packet_guess new_guess, *guess;
6622 gdb_assert (tdesc != NULL);
6625 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
6627 if (guess->bytes == bytes)
6628 internal_error (__FILE__, __LINE__,
6629 "Duplicate g packet description added for size %d",
6632 new_guess.bytes = bytes;
6633 new_guess.tdesc = tdesc;
6634 VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess);
6637 static const struct target_desc *
6638 remote_read_description (struct target_ops *target)
6640 struct remote_g_packet_data *data
6641 = gdbarch_data (current_gdbarch, remote_g_packet_data_handle);
6643 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
6645 struct remote_g_packet_guess *guess;
6647 int bytes = send_g_packet ();
6650 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
6652 if (guess->bytes == bytes)
6653 return guess->tdesc;
6655 /* We discard the g packet. A minor optimization would be to
6656 hold on to it, and fill the register cache once we have selected
6657 an architecture, but it's too tricky to do safely. */
6663 /* Remote file transfer support. This is host-initiated I/O, not
6664 target-initiated; for target-initiated, see remote-fileio.c. */
6666 /* If *LEFT is at least the length of STRING, copy STRING to
6667 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6668 decrease *LEFT. Otherwise raise an error. */
6671 remote_buffer_add_string (char **buffer, int *left, char *string)
6673 int len = strlen (string);
6676 error (_("Packet too long for target."));
6678 memcpy (*buffer, string, len);
6682 /* NUL-terminate the buffer as a convenience, if there is
6688 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
6689 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6690 decrease *LEFT. Otherwise raise an error. */
6693 remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes,
6696 if (2 * len > *left)
6697 error (_("Packet too long for target."));
6699 bin2hex (bytes, *buffer, len);
6703 /* NUL-terminate the buffer as a convenience, if there is
6709 /* If *LEFT is large enough, convert VALUE to hex and add it to
6710 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6711 decrease *LEFT. Otherwise raise an error. */
6714 remote_buffer_add_int (char **buffer, int *left, ULONGEST value)
6716 int len = hexnumlen (value);
6719 error (_("Packet too long for target."));
6721 hexnumstr (*buffer, value);
6725 /* NUL-terminate the buffer as a convenience, if there is
6731 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
6732 value, *REMOTE_ERRNO to the remote error number or zero if none
6733 was included, and *ATTACHMENT to point to the start of the annex
6734 if any. The length of the packet isn't needed here; there may
6735 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
6737 Return 0 if the packet could be parsed, -1 if it could not. If
6738 -1 is returned, the other variables may not be initialized. */
6741 remote_hostio_parse_result (char *buffer, int *retcode,
6742 int *remote_errno, char **attachment)
6749 if (buffer[0] != 'F')
6753 *retcode = strtol (&buffer[1], &p, 16);
6754 if (errno != 0 || p == &buffer[1])
6757 /* Check for ",errno". */
6761 *remote_errno = strtol (p + 1, &p2, 16);
6762 if (errno != 0 || p + 1 == p2)
6767 /* Check for ";attachment". If there is no attachment, the
6768 packet should end here. */
6771 *attachment = p + 1;
6774 else if (*p == '\0')
6780 /* Send a prepared I/O packet to the target and read its response.
6781 The prepared packet is in the global RS->BUF before this function
6782 is called, and the answer is there when we return.
6784 COMMAND_BYTES is the length of the request to send, which may include
6785 binary data. WHICH_PACKET is the packet configuration to check
6786 before attempting a packet. If an error occurs, *REMOTE_ERRNO
6787 is set to the error number and -1 is returned. Otherwise the value
6788 returned by the function is returned.
6790 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
6791 attachment is expected; an error will be reported if there's a
6792 mismatch. If one is found, *ATTACHMENT will be set to point into
6793 the packet buffer and *ATTACHMENT_LEN will be set to the
6794 attachment's length. */
6797 remote_hostio_send_command (int command_bytes, int which_packet,
6798 int *remote_errno, char **attachment,
6799 int *attachment_len)
6801 struct remote_state *rs = get_remote_state ();
6802 int ret, bytes_read;
6803 char *attachment_tmp;
6805 if (remote_protocol_packets[which_packet].support == PACKET_DISABLE)
6807 *remote_errno = FILEIO_ENOSYS;
6811 putpkt_binary (rs->buf, command_bytes);
6812 bytes_read = getpkt_sane (&rs->buf, &rs->buf_size, 0);
6814 /* If it timed out, something is wrong. Don't try to parse the
6818 *remote_errno = FILEIO_EINVAL;
6822 switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet]))
6825 *remote_errno = FILEIO_EINVAL;
6827 case PACKET_UNKNOWN:
6828 *remote_errno = FILEIO_ENOSYS;
6834 if (remote_hostio_parse_result (rs->buf, &ret, remote_errno,
6837 *remote_errno = FILEIO_EINVAL;
6841 /* Make sure we saw an attachment if and only if we expected one. */
6842 if ((attachment_tmp == NULL && attachment != NULL)
6843 || (attachment_tmp != NULL && attachment == NULL))
6845 *remote_errno = FILEIO_EINVAL;
6849 /* If an attachment was found, it must point into the packet buffer;
6850 work out how many bytes there were. */
6851 if (attachment_tmp != NULL)
6853 *attachment = attachment_tmp;
6854 *attachment_len = bytes_read - (*attachment - rs->buf);
6860 /* Open FILENAME on the remote target, using FLAGS and MODE. Return a
6861 remote file descriptor, or -1 if an error occurs (and set
6865 remote_hostio_open (const char *filename, int flags, int mode,
6868 struct remote_state *rs = get_remote_state ();
6870 int left = get_remote_packet_size () - 1;
6872 remote_buffer_add_string (&p, &left, "vFile:open:");
6874 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
6876 remote_buffer_add_string (&p, &left, ",");
6878 remote_buffer_add_int (&p, &left, flags);
6879 remote_buffer_add_string (&p, &left, ",");
6881 remote_buffer_add_int (&p, &left, mode);
6883 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_open,
6884 remote_errno, NULL, NULL);
6887 /* Write up to LEN bytes from WRITE_BUF to FD on the remote target.
6888 Return the number of bytes written, or -1 if an error occurs (and
6889 set *REMOTE_ERRNO). */
6892 remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
6893 ULONGEST offset, int *remote_errno)
6895 struct remote_state *rs = get_remote_state ();
6897 int left = get_remote_packet_size ();
6900 remote_buffer_add_string (&p, &left, "vFile:pwrite:");
6902 remote_buffer_add_int (&p, &left, fd);
6903 remote_buffer_add_string (&p, &left, ",");
6905 remote_buffer_add_int (&p, &left, offset);
6906 remote_buffer_add_string (&p, &left, ",");
6908 p += remote_escape_output (write_buf, len, p, &out_len,
6909 get_remote_packet_size () - (p - rs->buf));
6911 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_pwrite,
6912 remote_errno, NULL, NULL);
6915 /* Read up to LEN bytes FD on the remote target into READ_BUF
6916 Return the number of bytes read, or -1 if an error occurs (and
6917 set *REMOTE_ERRNO). */
6920 remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
6921 ULONGEST offset, int *remote_errno)
6923 struct remote_state *rs = get_remote_state ();
6926 int left = get_remote_packet_size ();
6927 int ret, attachment_len;
6930 remote_buffer_add_string (&p, &left, "vFile:pread:");
6932 remote_buffer_add_int (&p, &left, fd);
6933 remote_buffer_add_string (&p, &left, ",");
6935 remote_buffer_add_int (&p, &left, len);
6936 remote_buffer_add_string (&p, &left, ",");
6938 remote_buffer_add_int (&p, &left, offset);
6940 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_pread,
6941 remote_errno, &attachment,
6947 read_len = remote_unescape_input (attachment, attachment_len,
6949 if (read_len != ret)
6950 error (_("Read returned %d, but %d bytes."), ret, (int) read_len);
6955 /* Close FD on the remote target. Return 0, or -1 if an error occurs
6956 (and set *REMOTE_ERRNO). */
6959 remote_hostio_close (int fd, int *remote_errno)
6961 struct remote_state *rs = get_remote_state ();
6963 int left = get_remote_packet_size () - 1;
6965 remote_buffer_add_string (&p, &left, "vFile:close:");
6967 remote_buffer_add_int (&p, &left, fd);
6969 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_close,
6970 remote_errno, NULL, NULL);
6973 /* Unlink FILENAME on the remote target. Return 0, or -1 if an error
6974 occurs (and set *REMOTE_ERRNO). */
6977 remote_hostio_unlink (const char *filename, int *remote_errno)
6979 struct remote_state *rs = get_remote_state ();
6981 int left = get_remote_packet_size () - 1;
6983 remote_buffer_add_string (&p, &left, "vFile:unlink:");
6985 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
6988 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_unlink,
6989 remote_errno, NULL, NULL);
6993 remote_fileio_errno_to_host (int errnum)
7017 case FILEIO_ENOTDIR:
7037 case FILEIO_ENAMETOOLONG:
7038 return ENAMETOOLONG;
7044 remote_hostio_error (int errnum)
7046 int host_error = remote_fileio_errno_to_host (errnum);
7048 if (host_error == -1)
7049 error (_("Unknown remote I/O error %d"), errnum);
7051 error (_("Remote I/O error: %s"), safe_strerror (host_error));
7055 fclose_cleanup (void *file)
7061 remote_hostio_close_cleanup (void *opaque)
7063 int fd = *(int *) opaque;
7066 remote_hostio_close (fd, &remote_errno);
7070 remote_file_put (const char *local_file, const char *remote_file, int from_tty)
7072 struct cleanup *back_to, *close_cleanup;
7073 int retcode, fd, remote_errno, bytes, io_size;
7076 int bytes_in_buffer;
7081 error (_("command can only be used with remote target"));
7083 file = fopen (local_file, "rb");
7085 perror_with_name (local_file);
7086 back_to = make_cleanup (fclose_cleanup, file);
7088 fd = remote_hostio_open (remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
7090 0700, &remote_errno);
7092 remote_hostio_error (remote_errno);
7094 /* Send up to this many bytes at once. They won't all fit in the
7095 remote packet limit, so we'll transfer slightly fewer. */
7096 io_size = get_remote_packet_size ();
7097 buffer = xmalloc (io_size);
7098 make_cleanup (xfree, buffer);
7100 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd);
7102 bytes_in_buffer = 0;
7105 while (bytes_in_buffer || !saw_eof)
7109 bytes = fread (buffer + bytes_in_buffer, 1, io_size - bytes_in_buffer,
7114 error (_("Error reading %s."), local_file);
7117 /* EOF. Unless there is something still in the
7118 buffer from the last iteration, we are done. */
7120 if (bytes_in_buffer == 0)
7128 bytes += bytes_in_buffer;
7129 bytes_in_buffer = 0;
7131 retcode = remote_hostio_pwrite (fd, buffer, bytes, offset, &remote_errno);
7134 remote_hostio_error (remote_errno);
7135 else if (retcode == 0)
7136 error (_("Remote write of %d bytes returned 0!"), bytes);
7137 else if (retcode < bytes)
7139 /* Short write. Save the rest of the read data for the next
7141 bytes_in_buffer = bytes - retcode;
7142 memmove (buffer, buffer + retcode, bytes_in_buffer);
7148 discard_cleanups (close_cleanup);
7149 if (remote_hostio_close (fd, &remote_errno))
7150 remote_hostio_error (remote_errno);
7153 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file);
7154 do_cleanups (back_to);
7158 remote_file_get (const char *remote_file, const char *local_file, int from_tty)
7160 struct cleanup *back_to, *close_cleanup;
7161 int retcode, fd, remote_errno, bytes, io_size;
7167 error (_("command can only be used with remote target"));
7169 fd = remote_hostio_open (remote_file, FILEIO_O_RDONLY, 0, &remote_errno);
7171 remote_hostio_error (remote_errno);
7173 file = fopen (local_file, "wb");
7175 perror_with_name (local_file);
7176 back_to = make_cleanup (fclose_cleanup, file);
7178 /* Send up to this many bytes at once. They won't all fit in the
7179 remote packet limit, so we'll transfer slightly fewer. */
7180 io_size = get_remote_packet_size ();
7181 buffer = xmalloc (io_size);
7182 make_cleanup (xfree, buffer);
7184 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd);
7189 bytes = remote_hostio_pread (fd, buffer, io_size, offset, &remote_errno);
7191 /* Success, but no bytes, means end-of-file. */
7194 remote_hostio_error (remote_errno);
7198 bytes = fwrite (buffer, 1, bytes, file);
7200 perror_with_name (local_file);
7203 discard_cleanups (close_cleanup);
7204 if (remote_hostio_close (fd, &remote_errno))
7205 remote_hostio_error (remote_errno);
7208 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file);
7209 do_cleanups (back_to);
7213 remote_file_delete (const char *remote_file, int from_tty)
7215 int retcode, remote_errno;
7218 error (_("command can only be used with remote target"));
7220 retcode = remote_hostio_unlink (remote_file, &remote_errno);
7222 remote_hostio_error (remote_errno);
7225 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file);
7229 remote_put_command (char *args, int from_tty)
7231 struct cleanup *back_to;
7234 argv = buildargv (args);
7237 back_to = make_cleanup_freeargv (argv);
7238 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
7239 error (_("Invalid parameters to remote put"));
7241 remote_file_put (argv[0], argv[1], from_tty);
7243 do_cleanups (back_to);
7247 remote_get_command (char *args, int from_tty)
7249 struct cleanup *back_to;
7252 argv = buildargv (args);
7255 back_to = make_cleanup_freeargv (argv);
7256 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
7257 error (_("Invalid parameters to remote get"));
7259 remote_file_get (argv[0], argv[1], from_tty);
7261 do_cleanups (back_to);
7265 remote_delete_command (char *args, int from_tty)
7267 struct cleanup *back_to;
7270 argv = buildargv (args);
7273 back_to = make_cleanup_freeargv (argv);
7274 if (argv[0] == NULL || argv[1] != NULL)
7275 error (_("Invalid parameters to remote delete"));
7277 remote_file_delete (argv[0], from_tty);
7279 do_cleanups (back_to);
7283 remote_command (char *args, int from_tty)
7285 help_list (remote_cmdlist, "remote ", -1, gdb_stdout);
7289 remote_return_zero (void)
7295 init_remote_ops (void)
7297 remote_ops.to_shortname = "remote";
7298 remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
7300 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
7301 Specify the serial device it is connected to\n\
7302 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
7303 remote_ops.to_open = remote_open;
7304 remote_ops.to_close = remote_close;
7305 remote_ops.to_detach = remote_detach;
7306 remote_ops.to_disconnect = remote_disconnect;
7307 remote_ops.to_resume = remote_resume;
7308 remote_ops.to_wait = remote_wait;
7309 remote_ops.to_fetch_registers = remote_fetch_registers;
7310 remote_ops.to_store_registers = remote_store_registers;
7311 remote_ops.to_prepare_to_store = remote_prepare_to_store;
7312 remote_ops.deprecated_xfer_memory = remote_xfer_memory;
7313 remote_ops.to_files_info = remote_files_info;
7314 remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
7315 remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
7316 remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
7317 remote_ops.to_stopped_data_address = remote_stopped_data_address;
7318 remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
7319 remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
7320 remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
7321 remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
7322 remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
7323 remote_ops.to_kill = remote_kill;
7324 remote_ops.to_load = generic_load;
7325 remote_ops.to_mourn_inferior = remote_mourn;
7326 remote_ops.to_thread_alive = remote_thread_alive;
7327 remote_ops.to_find_new_threads = remote_threads_info;
7328 remote_ops.to_pid_to_str = remote_pid_to_str;
7329 remote_ops.to_extra_thread_info = remote_threads_extra_info;
7330 remote_ops.to_stop = remote_stop;
7331 remote_ops.to_xfer_partial = remote_xfer_partial;
7332 remote_ops.to_rcmd = remote_rcmd;
7333 remote_ops.to_log_command = serial_log_command;
7334 remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
7335 remote_ops.to_stratum = process_stratum;
7336 remote_ops.to_has_all_memory = 1;
7337 remote_ops.to_has_memory = 1;
7338 remote_ops.to_has_stack = 1;
7339 remote_ops.to_has_registers = 1;
7340 remote_ops.to_has_execution = 1;
7341 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
7342 remote_ops.to_magic = OPS_MAGIC;
7343 remote_ops.to_memory_map = remote_memory_map;
7344 remote_ops.to_flash_erase = remote_flash_erase;
7345 remote_ops.to_flash_done = remote_flash_done;
7346 remote_ops.to_read_description = remote_read_description;
7347 remote_ops.to_search_memory = remote_search_memory;
7348 remote_ops.to_can_async_p = remote_return_zero;
7349 remote_ops.to_is_async_p = remote_return_zero;
7352 /* Set up the extended remote vector by making a copy of the standard
7353 remote vector and adding to it. */
7356 init_extended_remote_ops (void)
7358 extended_remote_ops = remote_ops;
7360 extended_remote_ops.to_shortname = "extended-remote";
7361 extended_remote_ops.to_longname =
7362 "Extended remote serial target in gdb-specific protocol";
7363 extended_remote_ops.to_doc =
7364 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
7365 Specify the serial device it is connected to (e.g. /dev/ttya).",
7366 extended_remote_ops.to_open = extended_remote_open;
7367 extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
7368 extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
7369 extended_remote_ops.to_detach = extended_remote_detach;
7370 extended_remote_ops.to_attach = extended_remote_attach;
7374 remote_can_async_p (void)
7376 /* We're async whenever the serial device is. */
7377 return remote_async_mask_value && serial_can_async_p (remote_desc);
7381 remote_is_async_p (void)
7383 /* We're async whenever the serial device is. */
7384 return remote_async_mask_value && serial_is_async_p (remote_desc);
7387 /* Pass the SERIAL event on and up to the client. One day this code
7388 will be able to delay notifying the client of an event until the
7389 point where an entire packet has been received. */
7391 static void (*async_client_callback) (enum inferior_event_type event_type,
7393 static void *async_client_context;
7394 static serial_event_ftype remote_async_serial_handler;
7397 remote_async_serial_handler (struct serial *scb, void *context)
7399 /* Don't propogate error information up to the client. Instead let
7400 the client find out about the error by querying the target. */
7401 async_client_callback (INF_REG_EVENT, async_client_context);
7405 remote_async (void (*callback) (enum inferior_event_type event_type,
7406 void *context), void *context)
7408 if (remote_async_mask_value == 0)
7409 internal_error (__FILE__, __LINE__,
7410 _("Calling remote_async when async is masked"));
7412 if (callback != NULL)
7414 serial_async (remote_desc, remote_async_serial_handler, NULL);
7415 async_client_callback = callback;
7416 async_client_context = context;
7419 serial_async (remote_desc, NULL, NULL);
7423 remote_async_mask (int new_mask)
7425 int curr_mask = remote_async_mask_value;
7426 remote_async_mask_value = new_mask;
7430 /* Target async and target extended-async.
7432 This are temporary targets, until it is all tested. Eventually
7433 async support will be incorporated int the usual 'remote'
7437 init_remote_async_ops (void)
7439 remote_async_ops.to_shortname = "async";
7440 remote_async_ops.to_longname =
7441 "Remote serial target in async version of the gdb-specific protocol";
7442 remote_async_ops.to_doc =
7443 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
7444 Specify the serial device it is connected to (e.g. /dev/ttya).";
7445 remote_async_ops.to_open = remote_async_open;
7446 remote_async_ops.to_close = remote_close;
7447 remote_async_ops.to_detach = remote_detach;
7448 remote_async_ops.to_disconnect = remote_disconnect;
7449 remote_async_ops.to_resume = remote_async_resume;
7450 remote_async_ops.to_wait = remote_async_wait;
7451 remote_async_ops.to_fetch_registers = remote_fetch_registers;
7452 remote_async_ops.to_store_registers = remote_store_registers;
7453 remote_async_ops.to_prepare_to_store = remote_prepare_to_store;
7454 remote_async_ops.deprecated_xfer_memory = remote_xfer_memory;
7455 remote_async_ops.to_files_info = remote_files_info;
7456 remote_async_ops.to_insert_breakpoint = remote_insert_breakpoint;
7457 remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
7458 remote_async_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
7459 remote_async_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
7460 remote_async_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
7461 remote_async_ops.to_insert_watchpoint = remote_insert_watchpoint;
7462 remote_async_ops.to_remove_watchpoint = remote_remove_watchpoint;
7463 remote_async_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
7464 remote_async_ops.to_stopped_data_address = remote_stopped_data_address;
7465 remote_async_ops.to_terminal_inferior = remote_async_terminal_inferior;
7466 remote_async_ops.to_terminal_ours = remote_async_terminal_ours;
7467 remote_async_ops.to_kill = remote_async_kill;
7468 remote_async_ops.to_load = generic_load;
7469 remote_async_ops.to_mourn_inferior = remote_async_mourn;
7470 remote_async_ops.to_thread_alive = remote_thread_alive;
7471 remote_async_ops.to_find_new_threads = remote_threads_info;
7472 remote_async_ops.to_pid_to_str = remote_pid_to_str;
7473 remote_async_ops.to_extra_thread_info = remote_threads_extra_info;
7474 remote_async_ops.to_stop = remote_stop;
7475 remote_async_ops.to_xfer_partial = remote_xfer_partial;
7476 remote_async_ops.to_rcmd = remote_rcmd;
7477 remote_async_ops.to_get_thread_local_address
7478 = remote_get_thread_local_address;
7479 remote_async_ops.to_stratum = process_stratum;
7480 remote_async_ops.to_has_all_memory = 1;
7481 remote_async_ops.to_has_memory = 1;
7482 remote_async_ops.to_has_stack = 1;
7483 remote_async_ops.to_has_registers = 1;
7484 remote_async_ops.to_has_execution = 1;
7485 remote_async_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
7486 remote_async_ops.to_can_async_p = remote_can_async_p;
7487 remote_async_ops.to_is_async_p = remote_is_async_p;
7488 remote_async_ops.to_async = remote_async;
7489 remote_async_ops.to_async_mask = remote_async_mask;
7490 remote_async_ops.to_magic = OPS_MAGIC;
7491 remote_async_ops.to_memory_map = remote_memory_map;
7492 remote_async_ops.to_flash_erase = remote_flash_erase;
7493 remote_async_ops.to_flash_done = remote_flash_done;
7494 remote_async_ops.to_read_description = remote_read_description;
7495 remote_async_ops.to_search_memory = remote_search_memory;
7498 /* Set up the async extended remote vector by making a copy of the standard
7499 remote vector and adding to it. */
7502 init_extended_async_remote_ops (void)
7504 extended_async_remote_ops = remote_async_ops;
7506 extended_async_remote_ops.to_shortname = "extended-async";
7507 extended_async_remote_ops.to_longname =
7508 "Extended remote serial target in async gdb-specific protocol";
7509 extended_async_remote_ops.to_doc =
7510 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
7511 Specify the serial device it is connected to (e.g. /dev/ttya).",
7512 extended_async_remote_ops.to_open = extended_remote_async_open;
7513 extended_async_remote_ops.to_create_inferior = extended_remote_async_create_inferior;
7514 extended_async_remote_ops.to_mourn_inferior = extended_async_remote_mourn;
7515 extended_async_remote_ops.to_detach = extended_remote_detach;
7516 extended_async_remote_ops.to_attach = extended_async_remote_attach;
7520 set_remote_cmd (char *args, int from_tty)
7522 help_list (remote_set_cmdlist, "set remote ", -1, gdb_stdout);
7526 show_remote_cmd (char *args, int from_tty)
7528 /* We can't just use cmd_show_list here, because we want to skip
7529 the redundant "show remote Z-packet" and the legacy aliases. */
7530 struct cleanup *showlist_chain;
7531 struct cmd_list_element *list = remote_show_cmdlist;
7533 showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
7534 for (; list != NULL; list = list->next)
7535 if (strcmp (list->name, "Z-packet") == 0)
7537 else if (list->type == not_set_cmd)
7538 /* Alias commands are exactly like the original, except they
7539 don't have the normal type. */
7543 struct cleanup *option_chain
7544 = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
7545 ui_out_field_string (uiout, "name", list->name);
7546 ui_out_text (uiout, ": ");
7547 if (list->type == show_cmd)
7548 do_setshow_command ((char *) NULL, from_tty, list);
7550 cmd_func (list, NULL, from_tty);
7551 /* Close the tuple. */
7552 do_cleanups (option_chain);
7555 /* Close the tuple. */
7556 do_cleanups (showlist_chain);
7560 /* Function to be called whenever a new objfile (shlib) is detected. */
7562 remote_new_objfile (struct objfile *objfile)
7564 if (remote_desc != 0) /* Have a remote connection. */
7565 remote_check_symbols (objfile);
7569 _initialize_remote (void)
7571 struct remote_state *rs;
7573 /* architecture specific data */
7574 remote_gdbarch_data_handle =
7575 gdbarch_data_register_post_init (init_remote_state);
7576 remote_g_packet_data_handle =
7577 gdbarch_data_register_pre_init (remote_g_packet_data_init);
7579 /* Initialize the per-target state. At the moment there is only one
7580 of these, not one per target. Only one target is active at a
7581 time. The default buffer size is unimportant; it will be expanded
7582 whenever a larger buffer is needed. */
7583 rs = get_remote_state_raw ();
7585 rs->buf = xmalloc (rs->buf_size);
7588 add_target (&remote_ops);
7590 init_extended_remote_ops ();
7591 add_target (&extended_remote_ops);
7593 init_remote_async_ops ();
7594 add_target (&remote_async_ops);
7596 init_extended_async_remote_ops ();
7597 add_target (&extended_async_remote_ops);
7599 /* Hook into new objfile notification. */
7600 observer_attach_new_objfile (remote_new_objfile);
7602 /* Set up signal handlers. */
7603 sigint_remote_token =
7604 create_async_signal_handler (async_remote_interrupt, NULL);
7605 sigint_remote_twice_token =
7606 create_async_signal_handler (inferior_event_handler_wrapper, NULL);
7609 init_remote_threadtests ();
7612 /* set/show remote ... */
7614 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
7615 Remote protocol specific variables\n\
7616 Configure various remote-protocol specific variables such as\n\
7617 the packets being used"),
7618 &remote_set_cmdlist, "set remote ",
7619 0 /* allow-unknown */, &setlist);
7620 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
7621 Remote protocol specific variables\n\
7622 Configure various remote-protocol specific variables such as\n\
7623 the packets being used"),
7624 &remote_show_cmdlist, "show remote ",
7625 0 /* allow-unknown */, &showlist);
7627 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
7628 Compare section data on target to the exec file.\n\
7629 Argument is a single section name (default: all loaded sections)."),
7632 add_cmd ("packet", class_maintenance, packet_command, _("\
7633 Send an arbitrary packet to a remote target.\n\
7634 maintenance packet TEXT\n\
7635 If GDB is talking to an inferior via the GDB serial protocol, then\n\
7636 this command sends the string TEXT to the inferior, and displays the\n\
7637 response packet. GDB supplies the initial `$' character, and the\n\
7638 terminating `#' character and checksum."),
7641 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
7642 Set whether to send break if interrupted."), _("\
7643 Show whether to send break if interrupted."), _("\
7644 If set, a break, instead of a cntrl-c, is sent to the remote target."),
7645 NULL, NULL, /* FIXME: i18n: Whether to send break if interrupted is %s. */
7646 &setlist, &showlist);
7648 /* Install commands for configuring memory read/write packets. */
7650 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
7651 Set the maximum number of bytes per memory write packet (deprecated)."),
7653 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
7654 Show the maximum number of bytes per memory write packet (deprecated)."),
7656 add_cmd ("memory-write-packet-size", no_class,
7657 set_memory_write_packet_size, _("\
7658 Set the maximum number of bytes per memory-write packet.\n\
7659 Specify the number of bytes in a packet or 0 (zero) for the\n\
7660 default packet size. The actual limit is further reduced\n\
7661 dependent on the target. Specify ``fixed'' to disable the\n\
7662 further restriction and ``limit'' to enable that restriction."),
7663 &remote_set_cmdlist);
7664 add_cmd ("memory-read-packet-size", no_class,
7665 set_memory_read_packet_size, _("\
7666 Set the maximum number of bytes per memory-read packet.\n\
7667 Specify the number of bytes in a packet or 0 (zero) for the\n\
7668 default packet size. The actual limit is further reduced\n\
7669 dependent on the target. Specify ``fixed'' to disable the\n\
7670 further restriction and ``limit'' to enable that restriction."),
7671 &remote_set_cmdlist);
7672 add_cmd ("memory-write-packet-size", no_class,
7673 show_memory_write_packet_size,
7674 _("Show the maximum number of bytes per memory-write packet."),
7675 &remote_show_cmdlist);
7676 add_cmd ("memory-read-packet-size", no_class,
7677 show_memory_read_packet_size,
7678 _("Show the maximum number of bytes per memory-read packet."),
7679 &remote_show_cmdlist);
7681 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class,
7682 &remote_hw_watchpoint_limit, _("\
7683 Set the maximum number of target hardware watchpoints."), _("\
7684 Show the maximum number of target hardware watchpoints."), _("\
7685 Specify a negative limit for unlimited."),
7686 NULL, NULL, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
7687 &remote_set_cmdlist, &remote_show_cmdlist);
7688 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
7689 &remote_hw_breakpoint_limit, _("\
7690 Set the maximum number of target hardware breakpoints."), _("\
7691 Show the maximum number of target hardware breakpoints."), _("\
7692 Specify a negative limit for unlimited."),
7693 NULL, NULL, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
7694 &remote_set_cmdlist, &remote_show_cmdlist);
7696 add_setshow_integer_cmd ("remoteaddresssize", class_obscure,
7697 &remote_address_size, _("\
7698 Set the maximum size of the address (in bits) in a memory packet."), _("\
7699 Show the maximum size of the address (in bits) in a memory packet."), NULL,
7701 NULL, /* FIXME: i18n: */
7702 &setlist, &showlist);
7704 add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
7705 "X", "binary-download", 1);
7707 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
7708 "vCont", "verbose-resume", 0);
7710 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
7711 "QPassSignals", "pass-signals", 0);
7713 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
7714 "qSymbol", "symbol-lookup", 0);
7716 add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
7717 "P", "set-register", 1);
7719 add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
7720 "p", "fetch-register", 1);
7722 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
7723 "Z0", "software-breakpoint", 0);
7725 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
7726 "Z1", "hardware-breakpoint", 0);
7728 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
7729 "Z2", "write-watchpoint", 0);
7731 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
7732 "Z3", "read-watchpoint", 0);
7734 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
7735 "Z4", "access-watchpoint", 0);
7737 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
7738 "qXfer:auxv:read", "read-aux-vector", 0);
7740 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features],
7741 "qXfer:features:read", "target-features", 0);
7743 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
7744 "qXfer:libraries:read", "library-info", 0);
7746 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
7747 "qXfer:memory-map:read", "memory-map", 0);
7749 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
7750 "qXfer:spu:read", "read-spu-object", 0);
7752 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
7753 "qXfer:spu:write", "write-spu-object", 0);
7755 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
7756 "qGetTLSAddr", "get-thread-local-storage-address",
7759 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
7760 "qSupported", "supported-packets", 0);
7762 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory],
7763 "qSearch:memory", "search-memory", 0);
7765 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open],
7766 "vFile:open", "hostio-open", 0);
7768 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread],
7769 "vFile:pread", "hostio-pread", 0);
7771 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite],
7772 "vFile:pwrite", "hostio-pwrite", 0);
7774 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close],
7775 "vFile:close", "hostio-close", 0);
7777 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink],
7778 "vFile:unlink", "hostio-unlink", 0);
7780 add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach],
7781 "vAttach", "attach", 0);
7783 add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun],
7786 /* Keep the old ``set remote Z-packet ...'' working. Each individual
7787 Z sub-packet has its own set and show commands, but users may
7788 have sets to this variable in their .gdbinit files (or in their
7790 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
7791 &remote_Z_packet_detect, _("\
7792 Set use of remote protocol `Z' packets"), _("\
7793 Show use of remote protocol `Z' packets "), _("\
7794 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
7796 set_remote_protocol_Z_packet_cmd,
7797 show_remote_protocol_Z_packet_cmd, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
7798 &remote_set_cmdlist, &remote_show_cmdlist);
7800 add_prefix_cmd ("remote", class_files, remote_command, _("\
7801 Manipulate files on the remote system\n\
7802 Transfer files to and from the remote target system."),
7803 &remote_cmdlist, "remote ",
7804 0 /* allow-unknown */, &cmdlist);
7806 add_cmd ("put", class_files, remote_put_command,
7807 _("Copy a local file to the remote system."),
7810 add_cmd ("get", class_files, remote_get_command,
7811 _("Copy a remote file to the local system."),
7814 add_cmd ("delete", class_files, remote_delete_command,
7815 _("Delete a remote file."),
7818 remote_exec_file = xstrdup ("");
7819 add_setshow_string_noescape_cmd ("exec-file", class_files,
7820 &remote_exec_file, _("\
7821 Set the remote pathname for \"run\""), _("\
7822 Show the remote pathname for \"run\""), NULL, NULL, NULL,
7823 &remote_set_cmdlist, &remote_show_cmdlist);
7825 /* Eventually initialize fileio. See fileio.c */
7826 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);