1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* See the GDB User Guide for details of the GDB remote protocol. */
27 #include "gdb_string.h"
33 #include "exceptions.h"
35 /*#include "terminal.h" */
38 #include "gdb-stabs.h"
39 #include "gdbthread.h"
43 #include "gdb_assert.h"
46 #include "cli/cli-decode.h"
47 #include "cli/cli-setshow.h"
52 #include "event-loop.h"
53 #include "event-top.h"
59 #include "gdbcore.h" /* for exec_bfd */
61 #include "remote-fileio.h"
63 /* The size to align memory write packets, when practical. The protocol
64 does not guarantee any alignment, and gdb will generate short
65 writes and unaligned writes, but even as a best-effort attempt this
66 can improve bulk transfers. For instance, if a write is misaligned
67 relative to the target's data bus, the stub may need to make an extra
68 round trip fetching data from the target. This doesn't make a
69 huge difference, but it's easy to do, so we try to be helpful.
71 The alignment chosen is arbitrary; usually data bus width is
72 important here, not the possibly larger cache line size. */
73 enum { REMOTE_ALIGN_WRITES
= 16 };
75 /* Prototypes for local functions. */
76 static void cleanup_sigint_signal_handler (void *dummy
);
77 static void initialize_sigint_signal_handler (void);
78 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
80 static void handle_remote_sigint (int);
81 static void handle_remote_sigint_twice (int);
82 static void async_remote_interrupt (gdb_client_data
);
83 void async_remote_interrupt_twice (gdb_client_data
);
85 static void build_remote_gdbarch_data (void);
87 static void remote_files_info (struct target_ops
*ignore
);
89 static void remote_prepare_to_store (void);
91 static void remote_fetch_registers (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 (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);
211 /* For "set remote" and "show remote". */
213 static struct cmd_list_element
*remote_set_cmdlist
;
214 static struct cmd_list_element
*remote_show_cmdlist
;
216 /* Description of the remote protocol state for the currently
217 connected target. This is per-target state, and independent of the
218 selected architecture. */
222 /* A buffer to use for incoming packets, and its current size. The
223 buffer is grown dynamically for larger incoming packets.
224 Outgoing packets may also be constructed in this buffer.
225 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
226 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
231 /* If we negotiated packet size explicitly (and thus can bypass
232 heuristics for the largest packet size that will not overflow
233 a buffer in the stub), this will be set to that packet size.
234 Otherwise zero, meaning to use the guessed size. */
235 long explicit_packet_size
;
238 /* This data could be associated with a target, but we do not always
239 have access to the current target when we need it, so for now it is
240 static. This will be fine for as long as only one target is in use
242 static struct remote_state remote_state
;
244 static struct remote_state
*
245 get_remote_state (void)
247 return &remote_state
;
250 /* Description of the remote protocol for a given architecture. */
254 long offset
; /* Offset into G packet. */
255 long regnum
; /* GDB's internal register number. */
256 LONGEST pnum
; /* Remote protocol register number. */
257 int in_g_packet
; /* Always part of G packet. */
258 /* long size in bytes; == register_size (current_gdbarch, regnum);
260 /* char *name; == REGISTER_NAME (regnum); at present. */
263 struct remote_arch_state
265 /* Description of the remote protocol registers. */
266 long sizeof_g_packet
;
268 /* Description of the remote protocol registers indexed by REGNUM
269 (making an array of NUM_REGS + NUM_PSEUDO_REGS in size). */
270 struct packet_reg
*regs
;
272 /* This is the size (in chars) of the first response to the ``g''
273 packet. It is used as a heuristic when determining the maximum
274 size of memory-read and memory-write packets. A target will
275 typically only reserve a buffer large enough to hold the ``g''
276 packet. The size does not include packet overhead (headers and
278 long actual_register_packet_size
;
280 /* This is the maximum size (in chars) of a non read/write packet.
281 It is also used as a cap on the size of read/write packets. */
282 long remote_packet_size
;
286 /* Handle for retreving the remote protocol data from gdbarch. */
287 static struct gdbarch_data
*remote_gdbarch_data_handle
;
289 static struct remote_arch_state
*
290 get_remote_arch_state (void)
292 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
296 init_remote_state (struct gdbarch
*gdbarch
)
299 struct remote_state
*rs
= get_remote_state ();
300 struct remote_arch_state
*rsa
;
302 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
304 rsa
->sizeof_g_packet
= 0;
306 /* Assume a 1:1 regnum<->pnum table. */
307 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
, NUM_REGS
+ NUM_PSEUDO_REGS
,
309 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
311 struct packet_reg
*r
= &rsa
->regs
[regnum
];
314 r
->offset
= DEPRECATED_REGISTER_BYTE (regnum
);
315 r
->in_g_packet
= (regnum
< NUM_REGS
);
316 /* ...name = REGISTER_NAME (regnum); */
318 /* Compute packet size by accumulating the size of all registers. */
319 if (regnum
< NUM_REGS
)
320 rsa
->sizeof_g_packet
+= register_size (current_gdbarch
, regnum
);
323 /* Default maximum number of characters in a packet body. Many
324 remote stubs have a hardwired buffer size of 400 bytes
325 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
326 as the maximum packet-size to ensure that the packet and an extra
327 NUL character can always fit in the buffer. This stops GDB
328 trashing stubs that try to squeeze an extra NUL into what is
329 already a full buffer (As of 1999-12-04 that was most stubs). */
330 rsa
->remote_packet_size
= 400 - 1;
332 /* This one is filled in when a ``g'' packet is received. */
333 rsa
->actual_register_packet_size
= 0;
335 /* Should rsa->sizeof_g_packet needs more space than the
336 default, adjust the size accordingly. Remember that each byte is
337 encoded as two characters. 32 is the overhead for the packet
338 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
339 (``$NN:G...#NN'') is a better guess, the below has been padded a
341 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
342 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
344 /* Make sure that the packet buffer is plenty big enough for
345 this architecture. */
346 if (rs
->buf_size
< rsa
->remote_packet_size
)
348 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
349 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
355 /* Return the current allowed size of a remote packet. This is
356 inferred from the current architecture, and should be used to
357 limit the length of outgoing packets. */
359 get_remote_packet_size (void)
361 struct remote_state
*rs
= get_remote_state ();
362 struct remote_arch_state
*rsa
= get_remote_arch_state ();
364 if (rs
->explicit_packet_size
)
365 return rs
->explicit_packet_size
;
367 return rsa
->remote_packet_size
;
370 static struct packet_reg
*
371 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
373 if (regnum
< 0 && regnum
>= NUM_REGS
+ NUM_PSEUDO_REGS
)
377 struct packet_reg
*r
= &rsa
->regs
[regnum
];
378 gdb_assert (r
->regnum
== regnum
);
383 static struct packet_reg
*
384 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
387 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
389 struct packet_reg
*r
= &rsa
->regs
[i
];
396 /* FIXME: graces/2002-08-08: These variables should eventually be
397 bound to an instance of the target object (as in gdbarch-tdep()),
398 when such a thing exists. */
400 /* This is set to the data address of the access causing the target
401 to stop for a watchpoint. */
402 static CORE_ADDR remote_watch_data_address
;
404 /* This is non-zero if target stopped for a watchpoint. */
405 static int remote_stopped_by_watchpoint_p
;
407 static struct target_ops remote_ops
;
409 static struct target_ops extended_remote_ops
;
411 /* Temporary target ops. Just like the remote_ops and
412 extended_remote_ops, but with asynchronous support. */
413 static struct target_ops remote_async_ops
;
415 static struct target_ops extended_async_remote_ops
;
417 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
418 ``forever'' still use the normal timeout mechanism. This is
419 currently used by the ASYNC code to guarentee that target reads
420 during the initial connect always time-out. Once getpkt has been
421 modified to return a timeout indication and, in turn
422 remote_wait()/wait_for_inferior() have gained a timeout parameter
424 static int wait_forever_enabled_p
= 1;
427 /* This variable chooses whether to send a ^C or a break when the user
428 requests program interruption. Although ^C is usually what remote
429 systems expect, and that is the default here, sometimes a break is
430 preferable instead. */
432 static int remote_break
;
434 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
435 remote_open knows that we don't have a file open when the program
437 static struct serial
*remote_desc
= NULL
;
439 /* This variable sets the number of bits in an address that are to be
440 sent in a memory ("M" or "m") packet. Normally, after stripping
441 leading zeros, the entire address would be sent. This variable
442 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
443 initial implementation of remote.c restricted the address sent in
444 memory packets to ``host::sizeof long'' bytes - (typically 32
445 bits). Consequently, for 64 bit targets, the upper 32 bits of an
446 address was never sent. Since fixing this bug may cause a break in
447 some remote targets this variable is principly provided to
448 facilitate backward compatibility. */
450 static int remote_address_size
;
452 /* Tempoary to track who currently owns the terminal. See
453 target_async_terminal_* for more details. */
455 static int remote_async_terminal_ours_p
;
458 /* User configurable variables for the number of characters in a
459 memory read/write packet. MIN (rsa->remote_packet_size,
460 rsa->sizeof_g_packet) is the default. Some targets need smaller
461 values (fifo overruns, et.al.) and some users need larger values
462 (speed up transfers). The variables ``preferred_*'' (the user
463 request), ``current_*'' (what was actually set) and ``forced_*''
464 (Positive - a soft limit, negative - a hard limit). */
466 struct memory_packet_config
473 /* Compute the current size of a read/write packet. Since this makes
474 use of ``actual_register_packet_size'' the computation is dynamic. */
477 get_memory_packet_size (struct memory_packet_config
*config
)
479 struct remote_state
*rs
= get_remote_state ();
480 struct remote_arch_state
*rsa
= get_remote_arch_state ();
482 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
483 law?) that some hosts don't cope very well with large alloca()
484 calls. Eventually the alloca() code will be replaced by calls to
485 xmalloc() and make_cleanups() allowing this restriction to either
486 be lifted or removed. */
487 #ifndef MAX_REMOTE_PACKET_SIZE
488 #define MAX_REMOTE_PACKET_SIZE 16384
490 /* NOTE: 20 ensures we can write at least one byte. */
491 #ifndef MIN_REMOTE_PACKET_SIZE
492 #define MIN_REMOTE_PACKET_SIZE 20
497 if (config
->size
<= 0)
498 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
500 what_they_get
= config
->size
;
504 what_they_get
= get_remote_packet_size ();
505 /* Limit the packet to the size specified by the user. */
507 && what_they_get
> config
->size
)
508 what_they_get
= config
->size
;
510 /* Limit it to the size of the targets ``g'' response unless we have
511 permission from the stub to use a larger packet size. */
512 if (rs
->explicit_packet_size
== 0
513 && rsa
->actual_register_packet_size
> 0
514 && what_they_get
> rsa
->actual_register_packet_size
)
515 what_they_get
= rsa
->actual_register_packet_size
;
517 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
518 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
519 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
520 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
522 /* Make sure there is room in the global buffer for this packet
523 (including its trailing NUL byte). */
524 if (rs
->buf_size
< what_they_get
+ 1)
526 rs
->buf_size
= 2 * what_they_get
;
527 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
530 return what_they_get
;
533 /* Update the size of a read/write packet. If they user wants
534 something really big then do a sanity check. */
537 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
539 int fixed_p
= config
->fixed_p
;
540 long size
= config
->size
;
542 error (_("Argument required (integer, `fixed' or `limited')."));
543 else if (strcmp (args
, "hard") == 0
544 || strcmp (args
, "fixed") == 0)
546 else if (strcmp (args
, "soft") == 0
547 || strcmp (args
, "limit") == 0)
552 size
= strtoul (args
, &end
, 0);
554 error (_("Invalid %s (bad syntax)."), config
->name
);
556 /* Instead of explicitly capping the size of a packet to
557 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
558 instead allowed to set the size to something arbitrarily
560 if (size
> MAX_REMOTE_PACKET_SIZE
)
561 error (_("Invalid %s (too large)."), config
->name
);
565 if (fixed_p
&& !config
->fixed_p
)
567 if (! query (_("The target may not be able to correctly handle a %s\n"
568 "of %ld bytes. Change the packet size? "),
570 error (_("Packet size not changed."));
572 /* Update the config. */
573 config
->fixed_p
= fixed_p
;
578 show_memory_packet_size (struct memory_packet_config
*config
)
580 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
582 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
583 get_memory_packet_size (config
));
585 printf_filtered (_("Packets are limited to %ld bytes.\n"),
586 get_memory_packet_size (config
));
589 static struct memory_packet_config memory_write_packet_config
=
591 "memory-write-packet-size",
595 set_memory_write_packet_size (char *args
, int from_tty
)
597 set_memory_packet_size (args
, &memory_write_packet_config
);
601 show_memory_write_packet_size (char *args
, int from_tty
)
603 show_memory_packet_size (&memory_write_packet_config
);
607 get_memory_write_packet_size (void)
609 return get_memory_packet_size (&memory_write_packet_config
);
612 static struct memory_packet_config memory_read_packet_config
=
614 "memory-read-packet-size",
618 set_memory_read_packet_size (char *args
, int from_tty
)
620 set_memory_packet_size (args
, &memory_read_packet_config
);
624 show_memory_read_packet_size (char *args
, int from_tty
)
626 show_memory_packet_size (&memory_read_packet_config
);
630 get_memory_read_packet_size (void)
632 long size
= get_memory_packet_size (&memory_read_packet_config
);
633 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
634 extra buffer size argument before the memory read size can be
635 increased beyond this. */
636 if (size
> get_remote_packet_size ())
637 size
= get_remote_packet_size ();
642 /* Generic configuration support for packets the stub optionally
643 supports. Allows the user to specify the use of the packet as well
644 as allowing GDB to auto-detect support in the remote stub. */
648 PACKET_SUPPORT_UNKNOWN
= 0,
657 enum auto_boolean detect
;
658 enum packet_support support
;
661 /* Analyze a packet's return value and update the packet config
672 update_packet_config (struct packet_config
*config
)
674 switch (config
->detect
)
676 case AUTO_BOOLEAN_TRUE
:
677 config
->support
= PACKET_ENABLE
;
679 case AUTO_BOOLEAN_FALSE
:
680 config
->support
= PACKET_DISABLE
;
682 case AUTO_BOOLEAN_AUTO
:
683 config
->support
= PACKET_SUPPORT_UNKNOWN
;
689 show_packet_config_cmd (struct packet_config
*config
)
691 char *support
= "internal-error";
692 switch (config
->support
)
698 support
= "disabled";
700 case PACKET_SUPPORT_UNKNOWN
:
704 switch (config
->detect
)
706 case AUTO_BOOLEAN_AUTO
:
707 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
708 config
->name
, support
);
710 case AUTO_BOOLEAN_TRUE
:
711 case AUTO_BOOLEAN_FALSE
:
712 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
713 config
->name
, support
);
719 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
720 const char *title
, int legacy
)
727 config
->title
= title
;
728 config
->detect
= AUTO_BOOLEAN_AUTO
;
729 config
->support
= PACKET_SUPPORT_UNKNOWN
;
730 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
732 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
734 /* set/show TITLE-packet {auto,on,off} */
735 cmd_name
= xstrprintf ("%s-packet", title
);
736 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
737 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
738 set_remote_protocol_packet_cmd
,
739 show_remote_protocol_packet_cmd
,
740 &remote_set_cmdlist
, &remote_show_cmdlist
);
741 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
745 legacy_name
= xstrprintf ("%s-packet", name
);
746 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
747 &remote_set_cmdlist
);
748 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
749 &remote_show_cmdlist
);
753 static enum packet_result
754 packet_ok (const char *buf
, struct packet_config
*config
)
758 /* The stub recognized the packet request. Check that the
759 operation succeeded. */
760 switch (config
->support
)
762 case PACKET_SUPPORT_UNKNOWN
:
764 fprintf_unfiltered (gdb_stdlog
,
765 "Packet %s (%s) is supported\n",
766 config
->name
, config
->title
);
767 config
->support
= PACKET_ENABLE
;
770 internal_error (__FILE__
, __LINE__
,
771 _("packet_ok: attempt to use a disabled packet"));
776 if (buf
[0] == 'O' && buf
[1] == 'K' && buf
[2] == '\0')
777 /* "OK" - definitly OK. */
780 && isxdigit (buf
[1]) && isxdigit (buf
[2])
782 /* "Enn" - definitly an error. */
784 /* The packet may or may not be OK. Just assume it is. */
789 /* The stub does not support the packet. */
790 switch (config
->support
)
793 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
794 /* If the stub previously indicated that the packet was
795 supported then there is a protocol error.. */
796 error (_("Protocol error: %s (%s) conflicting enabled responses."),
797 config
->name
, config
->title
);
799 /* The user set it wrong. */
800 error (_("Enabled packet %s (%s) not recognized by stub"),
801 config
->name
, config
->title
);
803 case PACKET_SUPPORT_UNKNOWN
:
805 fprintf_unfiltered (gdb_stdlog
,
806 "Packet %s (%s) is NOT supported\n",
807 config
->name
, config
->title
);
808 config
->support
= PACKET_DISABLE
;
813 return PACKET_UNKNOWN
;
834 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
837 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
838 struct cmd_list_element
*c
)
840 struct packet_config
*packet
;
842 for (packet
= remote_protocol_packets
;
843 packet
< &remote_protocol_packets
[PACKET_MAX
];
846 if (&packet
->detect
== c
->var
)
848 update_packet_config (packet
);
852 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
857 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
858 struct cmd_list_element
*c
,
861 struct packet_config
*packet
;
863 for (packet
= remote_protocol_packets
;
864 packet
< &remote_protocol_packets
[PACKET_MAX
];
867 if (&packet
->detect
== c
->var
)
869 show_packet_config_cmd (packet
);
873 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
877 /* Should we try one of the 'Z' requests? */
881 Z_PACKET_SOFTWARE_BP
,
882 Z_PACKET_HARDWARE_BP
,
889 /* For compatibility with older distributions. Provide a ``set remote
890 Z-packet ...'' command that updates all the Z packet types. */
892 static enum auto_boolean remote_Z_packet_detect
;
895 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
896 struct cmd_list_element
*c
)
899 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
901 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
902 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
907 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
908 struct cmd_list_element
*c
,
912 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
914 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
918 /* Should we try the 'ThreadInfo' query packet?
920 This variable (NOT available to the user: auto-detect only!)
921 determines whether GDB will use the new, simpler "ThreadInfo"
922 query or the older, more complex syntax for thread queries.
923 This is an auto-detect variable (set to true at each connect,
924 and set to false when the target fails to recognize it). */
926 static int use_threadinfo_query
;
927 static int use_threadextra_query
;
929 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
930 static void *sigint_remote_twice_token
;
931 static void *sigint_remote_token
;
933 /* These are pointers to hook functions that may be set in order to
934 modify resume/wait behavior for a particular architecture. */
936 void (*deprecated_target_resume_hook
) (void);
937 void (*deprecated_target_wait_loop_hook
) (void);
941 /* These are the threads which we last sent to the remote system.
942 -1 for all or -2 for not sent yet. */
943 static int general_thread
;
944 static int continue_thread
;
946 /* Call this function as a result of
947 1) A halt indication (T packet) containing a thread id
948 2) A direct query of currthread
949 3) Successful execution of set thread
953 record_currthread (int currthread
)
955 general_thread
= currthread
;
957 /* If this is a new thread, add it to GDB's thread list.
958 If we leave it up to WFI to do this, bad things will happen. */
959 if (!in_thread_list (pid_to_ptid (currthread
)))
961 add_thread (pid_to_ptid (currthread
));
962 ui_out_text (uiout
, "[New ");
963 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
964 ui_out_text (uiout
, "]\n");
968 #define MAGIC_NULL_PID 42000
971 set_thread (int th
, int gen
)
973 struct remote_state
*rs
= get_remote_state ();
975 int state
= gen
? general_thread
: continue_thread
;
981 buf
[1] = gen
? 'g' : 'c';
982 if (th
== MAGIC_NULL_PID
)
988 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
990 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
992 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
996 continue_thread
= th
;
999 /* Return nonzero if the thread TH is still alive on the remote system. */
1002 remote_thread_alive (ptid_t ptid
)
1004 struct remote_state
*rs
= get_remote_state ();
1005 int tid
= PIDGET (ptid
);
1008 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1010 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1012 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1013 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1016 /* About these extended threadlist and threadinfo packets. They are
1017 variable length packets but, the fields within them are often fixed
1018 length. They are redundent enough to send over UDP as is the
1019 remote protocol in general. There is a matching unit test module
1022 #define OPAQUETHREADBYTES 8
1024 /* a 64 bit opaque identifier */
1025 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1027 /* WARNING: This threadref data structure comes from the remote O.S.,
1028 libstub protocol encoding, and remote.c. it is not particularly
1031 /* Right now, the internal structure is int. We want it to be bigger.
1035 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1037 /* gdb_ext_thread_info is an internal GDB data structure which is
1038 equivalent to the reply of the remote threadinfo packet. */
1040 struct gdb_ext_thread_info
1042 threadref threadid
; /* External form of thread reference. */
1043 int active
; /* Has state interesting to GDB?
1045 char display
[256]; /* Brief state display, name,
1046 blocked/suspended. */
1047 char shortname
[32]; /* To be used to name threads. */
1048 char more_display
[256]; /* Long info, statistics, queue depth,
1052 /* The volume of remote transfers can be limited by submitting
1053 a mask containing bits specifying the desired information.
1054 Use a union of these values as the 'selection' parameter to
1055 get_thread_info. FIXME: Make these TAG names more thread specific.
1058 #define TAG_THREADID 1
1059 #define TAG_EXISTS 2
1060 #define TAG_DISPLAY 4
1061 #define TAG_THREADNAME 8
1062 #define TAG_MOREDISPLAY 16
1064 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1066 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1068 static char *unpack_nibble (char *buf
, int *val
);
1070 static char *pack_nibble (char *buf
, int nibble
);
1072 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1074 static char *unpack_byte (char *buf
, int *value
);
1076 static char *pack_int (char *buf
, int value
);
1078 static char *unpack_int (char *buf
, int *value
);
1080 static char *unpack_string (char *src
, char *dest
, int length
);
1082 static char *pack_threadid (char *pkt
, threadref
*id
);
1084 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1086 void int_to_threadref (threadref
*id
, int value
);
1088 static int threadref_to_int (threadref
*ref
);
1090 static void copy_threadref (threadref
*dest
, threadref
*src
);
1092 static int threadmatch (threadref
*dest
, threadref
*src
);
1094 static char *pack_threadinfo_request (char *pkt
, int mode
,
1097 static int remote_unpack_thread_info_response (char *pkt
,
1098 threadref
*expectedref
,
1099 struct gdb_ext_thread_info
1103 static int remote_get_threadinfo (threadref
*threadid
,
1104 int fieldset
, /*TAG mask */
1105 struct gdb_ext_thread_info
*info
);
1107 static char *pack_threadlist_request (char *pkt
, int startflag
,
1109 threadref
*nextthread
);
1111 static int parse_threadlist_response (char *pkt
,
1113 threadref
*original_echo
,
1114 threadref
*resultlist
,
1117 static int remote_get_threadlist (int startflag
,
1118 threadref
*nextthread
,
1122 threadref
*threadlist
);
1124 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1126 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1127 void *context
, int looplimit
);
1129 static int remote_newthread_step (threadref
*ref
, void *context
);
1131 /* Encode 64 bits in 16 chars of hex. */
1133 static const char hexchars
[] = "0123456789abcdef";
1136 ishex (int ch
, int *val
)
1138 if ((ch
>= 'a') && (ch
<= 'f'))
1140 *val
= ch
- 'a' + 10;
1143 if ((ch
>= 'A') && (ch
<= 'F'))
1145 *val
= ch
- 'A' + 10;
1148 if ((ch
>= '0') && (ch
<= '9'))
1159 if (ch
>= 'a' && ch
<= 'f')
1160 return ch
- 'a' + 10;
1161 if (ch
>= '0' && ch
<= '9')
1163 if (ch
>= 'A' && ch
<= 'F')
1164 return ch
- 'A' + 10;
1169 stub_unpack_int (char *buff
, int fieldlength
)
1176 nibble
= stubhex (*buff
++);
1180 retval
= retval
<< 4;
1186 unpack_varlen_hex (char *buff
, /* packet to parse */
1190 ULONGEST retval
= 0;
1192 while (ishex (*buff
, &nibble
))
1195 retval
= retval
<< 4;
1196 retval
|= nibble
& 0x0f;
1203 unpack_nibble (char *buf
, int *val
)
1205 ishex (*buf
++, val
);
1210 pack_nibble (char *buf
, int nibble
)
1212 *buf
++ = hexchars
[(nibble
& 0x0f)];
1217 pack_hex_byte (char *pkt
, int byte
)
1219 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1220 *pkt
++ = hexchars
[(byte
& 0xf)];
1225 unpack_byte (char *buf
, int *value
)
1227 *value
= stub_unpack_int (buf
, 2);
1232 pack_int (char *buf
, int value
)
1234 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1235 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1236 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1237 buf
= pack_hex_byte (buf
, (value
& 0xff));
1242 unpack_int (char *buf
, int *value
)
1244 *value
= stub_unpack_int (buf
, 8);
1248 #if 0 /* Currently unused, uncomment when needed. */
1249 static char *pack_string (char *pkt
, char *string
);
1252 pack_string (char *pkt
, char *string
)
1257 len
= strlen (string
);
1259 len
= 200; /* Bigger than most GDB packets, junk??? */
1260 pkt
= pack_hex_byte (pkt
, len
);
1264 if ((ch
== '\0') || (ch
== '#'))
1265 ch
= '*'; /* Protect encapsulation. */
1270 #endif /* 0 (unused) */
1273 unpack_string (char *src
, char *dest
, int length
)
1282 pack_threadid (char *pkt
, threadref
*id
)
1285 unsigned char *altid
;
1287 altid
= (unsigned char *) id
;
1288 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1290 pkt
= pack_hex_byte (pkt
, *altid
++);
1296 unpack_threadid (char *inbuf
, threadref
*id
)
1299 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1302 altref
= (char *) id
;
1304 while (inbuf
< limit
)
1306 x
= stubhex (*inbuf
++);
1307 y
= stubhex (*inbuf
++);
1308 *altref
++ = (x
<< 4) | y
;
1313 /* Externally, threadrefs are 64 bits but internally, they are still
1314 ints. This is due to a mismatch of specifications. We would like
1315 to use 64bit thread references internally. This is an adapter
1319 int_to_threadref (threadref
*id
, int value
)
1321 unsigned char *scan
;
1323 scan
= (unsigned char *) id
;
1329 *scan
++ = (value
>> 24) & 0xff;
1330 *scan
++ = (value
>> 16) & 0xff;
1331 *scan
++ = (value
>> 8) & 0xff;
1332 *scan
++ = (value
& 0xff);
1336 threadref_to_int (threadref
*ref
)
1339 unsigned char *scan
;
1345 value
= (value
<< 8) | ((*scan
++) & 0xff);
1350 copy_threadref (threadref
*dest
, threadref
*src
)
1353 unsigned char *csrc
, *cdest
;
1355 csrc
= (unsigned char *) src
;
1356 cdest
= (unsigned char *) dest
;
1363 threadmatch (threadref
*dest
, threadref
*src
)
1365 /* Things are broken right now, so just assume we got a match. */
1367 unsigned char *srcp
, *destp
;
1369 srcp
= (char *) src
;
1370 destp
= (char *) dest
;
1374 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1381 threadid:1, # always request threadid
1388 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1391 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1393 *pkt
++ = 'q'; /* Info Query */
1394 *pkt
++ = 'P'; /* process or thread info */
1395 pkt
= pack_int (pkt
, mode
); /* mode */
1396 pkt
= pack_threadid (pkt
, id
); /* threadid */
1397 *pkt
= '\0'; /* terminate */
1401 /* These values tag the fields in a thread info response packet. */
1402 /* Tagging the fields allows us to request specific fields and to
1403 add more fields as time goes by. */
1405 #define TAG_THREADID 1 /* Echo the thread identifier. */
1406 #define TAG_EXISTS 2 /* Is this process defined enough to
1407 fetch registers and its stack? */
1408 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1409 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1410 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1414 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1415 struct gdb_ext_thread_info
*info
)
1417 struct remote_state
*rs
= get_remote_state ();
1421 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1424 /* info->threadid = 0; FIXME: implement zero_threadref. */
1426 info
->display
[0] = '\0';
1427 info
->shortname
[0] = '\0';
1428 info
->more_display
[0] = '\0';
1430 /* Assume the characters indicating the packet type have been
1432 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1433 pkt
= unpack_threadid (pkt
, &ref
);
1436 warning (_("Incomplete response to threadinfo request."));
1437 if (!threadmatch (&ref
, expectedref
))
1438 { /* This is an answer to a different request. */
1439 warning (_("ERROR RMT Thread info mismatch."));
1442 copy_threadref (&info
->threadid
, &ref
);
1444 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1446 /* Packets are terminated with nulls. */
1447 while ((pkt
< limit
) && mask
&& *pkt
)
1449 pkt
= unpack_int (pkt
, &tag
); /* tag */
1450 pkt
= unpack_byte (pkt
, &length
); /* length */
1451 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1453 warning (_("ERROR RMT: threadinfo tag mismatch."));
1457 if (tag
== TAG_THREADID
)
1461 warning (_("ERROR RMT: length of threadid is not 16."));
1465 pkt
= unpack_threadid (pkt
, &ref
);
1466 mask
= mask
& ~TAG_THREADID
;
1469 if (tag
== TAG_EXISTS
)
1471 info
->active
= stub_unpack_int (pkt
, length
);
1473 mask
= mask
& ~(TAG_EXISTS
);
1476 warning (_("ERROR RMT: 'exists' length too long."));
1482 if (tag
== TAG_THREADNAME
)
1484 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1485 mask
= mask
& ~TAG_THREADNAME
;
1488 if (tag
== TAG_DISPLAY
)
1490 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1491 mask
= mask
& ~TAG_DISPLAY
;
1494 if (tag
== TAG_MOREDISPLAY
)
1496 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1497 mask
= mask
& ~TAG_MOREDISPLAY
;
1500 warning (_("ERROR RMT: unknown thread info tag."));
1501 break; /* Not a tag we know about. */
1507 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1508 struct gdb_ext_thread_info
*info
)
1510 struct remote_state
*rs
= get_remote_state ();
1513 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1515 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1516 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1521 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1524 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1525 threadref
*nextthread
)
1527 *pkt
++ = 'q'; /* info query packet */
1528 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1529 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1530 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1531 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1536 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1539 parse_threadlist_response (char *pkt
, int result_limit
,
1540 threadref
*original_echo
, threadref
*resultlist
,
1543 struct remote_state
*rs
= get_remote_state ();
1545 int count
, resultcount
, done
;
1548 /* Assume the 'q' and 'M chars have been stripped. */
1549 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1550 /* done parse past here */
1551 pkt
= unpack_byte (pkt
, &count
); /* count field */
1552 pkt
= unpack_nibble (pkt
, &done
);
1553 /* The first threadid is the argument threadid. */
1554 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1555 while ((count
-- > 0) && (pkt
< limit
))
1557 pkt
= unpack_threadid (pkt
, resultlist
++);
1558 if (resultcount
++ >= result_limit
)
1567 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1568 int *done
, int *result_count
, threadref
*threadlist
)
1570 struct remote_state
*rs
= get_remote_state ();
1571 static threadref echo_nextthread
;
1574 /* Trancate result limit to be smaller than the packet size. */
1575 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1576 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1578 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1580 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1583 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1586 if (!threadmatch (&echo_nextthread
, nextthread
))
1588 /* FIXME: This is a good reason to drop the packet. */
1589 /* Possably, there is a duplicate response. */
1591 retransmit immediatly - race conditions
1592 retransmit after timeout - yes
1594 wait for packet, then exit
1596 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1597 return 0; /* I choose simply exiting. */
1599 if (*result_count
<= 0)
1603 warning (_("RMT ERROR : failed to get remote thread list."));
1606 return result
; /* break; */
1608 if (*result_count
> result_limit
)
1611 warning (_("RMT ERROR: threadlist response longer than requested."));
1617 /* This is the interface between remote and threads, remotes upper
1620 /* remote_find_new_threads retrieves the thread list and for each
1621 thread in the list, looks up the thread in GDB's internal list,
1622 ading the thread if it does not already exist. This involves
1623 getting partial thread lists from the remote target so, polling the
1624 quit_flag is required. */
1627 /* About this many threadisds fit in a packet. */
1629 #define MAXTHREADLISTRESULTS 32
1632 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1635 int done
, i
, result_count
;
1639 static threadref nextthread
;
1640 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1645 if (loopcount
++ > looplimit
)
1648 warning (_("Remote fetch threadlist -infinite loop-."));
1651 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1652 &done
, &result_count
, resultthreadlist
))
1657 /* Clear for later iterations. */
1659 /* Setup to resume next batch of thread references, set nextthread. */
1660 if (result_count
>= 1)
1661 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1663 while (result_count
--)
1664 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1671 remote_newthread_step (threadref
*ref
, void *context
)
1675 ptid
= pid_to_ptid (threadref_to_int (ref
));
1677 if (!in_thread_list (ptid
))
1679 return 1; /* continue iterator */
1682 #define CRAZY_MAX_THREADS 1000
1685 remote_current_thread (ptid_t oldpid
)
1687 struct remote_state
*rs
= get_remote_state ();
1690 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1691 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1692 /* Use strtoul here, so we'll correctly parse values whose highest
1693 bit is set. The protocol carries them as a simple series of
1694 hex digits; in the absence of a sign, strtol will see such
1695 values as positive numbers out of range for signed 'long', and
1696 return LONG_MAX to indicate an overflow. */
1697 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1702 /* Find new threads for info threads command.
1703 * Original version, using John Metzler's thread protocol.
1707 remote_find_new_threads (void)
1709 remote_threadlist_iterator (remote_newthread_step
, 0,
1711 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1712 inferior_ptid
= remote_current_thread (inferior_ptid
);
1716 * Find all threads for info threads command.
1717 * Uses new thread protocol contributed by Cisco.
1718 * Falls back and attempts to use the older method (above)
1719 * if the target doesn't respond to the new method.
1723 remote_threads_info (void)
1725 struct remote_state
*rs
= get_remote_state ();
1729 if (remote_desc
== 0) /* paranoia */
1730 error (_("Command can only be used when connected to the remote target."));
1732 if (use_threadinfo_query
)
1734 putpkt ("qfThreadInfo");
1735 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1737 if (bufp
[0] != '\0') /* q packet recognized */
1739 while (*bufp
++ == 'm') /* reply contains one or more TID */
1743 /* Use strtoul here, so we'll correctly parse values
1744 whose highest bit is set. The protocol carries
1745 them as a simple series of hex digits; in the
1746 absence of a sign, strtol will see such values as
1747 positive numbers out of range for signed 'long',
1748 and return LONG_MAX to indicate an overflow. */
1749 tid
= strtoul (bufp
, &bufp
, 16);
1750 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1751 add_thread (pid_to_ptid (tid
));
1753 while (*bufp
++ == ','); /* comma-separated list */
1754 putpkt ("qsThreadInfo");
1755 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1762 /* Else fall back to old method based on jmetzler protocol. */
1763 use_threadinfo_query
= 0;
1764 remote_find_new_threads ();
1769 * Collect a descriptive string about the given thread.
1770 * The target may say anything it wants to about the thread
1771 * (typically info about its blocked / runnable state, name, etc.).
1772 * This string will appear in the info threads display.
1774 * Optional: targets are not required to implement this function.
1778 remote_threads_extra_info (struct thread_info
*tp
)
1780 struct remote_state
*rs
= get_remote_state ();
1784 struct gdb_ext_thread_info threadinfo
;
1785 static char display_buf
[100]; /* arbitrary... */
1786 int n
= 0; /* position in display_buf */
1788 if (remote_desc
== 0) /* paranoia */
1789 internal_error (__FILE__
, __LINE__
,
1790 _("remote_threads_extra_info"));
1792 if (use_threadextra_query
)
1794 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1797 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1798 if (rs
->buf
[0] != 0)
1800 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1801 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1802 display_buf
[result
] = '\0';
1807 /* If the above query fails, fall back to the old method. */
1808 use_threadextra_query
= 0;
1809 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1810 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1811 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1812 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1813 if (threadinfo
.active
)
1815 if (*threadinfo
.shortname
)
1816 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1817 " Name: %s,", threadinfo
.shortname
);
1818 if (*threadinfo
.display
)
1819 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1820 " State: %s,", threadinfo
.display
);
1821 if (*threadinfo
.more_display
)
1822 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1823 " Priority: %s", threadinfo
.more_display
);
1827 /* For purely cosmetic reasons, clear up trailing commas. */
1828 if (',' == display_buf
[n
-1])
1829 display_buf
[n
-1] = ' ';
1837 /* Restart the remote side; this is an extended protocol operation. */
1840 extended_remote_restart (void)
1842 struct remote_state
*rs
= get_remote_state ();
1844 /* Send the restart command; for reasons I don't understand the
1845 remote side really expects a number after the "R". */
1846 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1849 remote_fileio_reset ();
1851 /* Now query for status so this looks just like we restarted
1852 gdbserver from scratch. */
1854 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1857 /* Clean up connection to a remote debugger. */
1860 remote_close (int quitting
)
1863 serial_close (remote_desc
);
1867 /* Query the remote side for the text, data and bss offsets. */
1872 struct remote_state
*rs
= get_remote_state ();
1876 CORE_ADDR text_addr
, data_addr
, bss_addr
;
1877 struct section_offsets
*offs
;
1879 putpkt ("qOffsets");
1880 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1883 if (buf
[0] == '\000')
1884 return; /* Return silently. Stub doesn't support
1888 warning (_("Remote failure reply: %s"), buf
);
1892 /* Pick up each field in turn. This used to be done with scanf, but
1893 scanf will make trouble if CORE_ADDR size doesn't match
1894 conversion directives correctly. The following code will work
1895 with any size of CORE_ADDR. */
1896 text_addr
= data_addr
= bss_addr
= 0;
1900 if (strncmp (ptr
, "Text=", 5) == 0)
1903 /* Don't use strtol, could lose on big values. */
1904 while (*ptr
&& *ptr
!= ';')
1905 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
1910 if (!lose
&& strncmp (ptr
, ";Data=", 6) == 0)
1913 while (*ptr
&& *ptr
!= ';')
1914 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
1919 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
1922 while (*ptr
&& *ptr
!= ';')
1923 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
1929 error (_("Malformed response to offset query, %s"), buf
);
1931 if (symfile_objfile
== NULL
)
1934 offs
= ((struct section_offsets
*)
1935 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
1936 memcpy (offs
, symfile_objfile
->section_offsets
,
1937 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
1939 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
1941 /* This is a temporary kludge to force data and bss to use the same offsets
1942 because that's what nlmconv does now. The real solution requires changes
1943 to the stub and remote.c that I don't have time to do right now. */
1945 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
1946 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
1948 objfile_relocate (symfile_objfile
, offs
);
1951 /* Stub for catch_errors. */
1954 remote_start_remote_dummy (struct ui_out
*uiout
, void *dummy
)
1956 start_remote (); /* Initialize gdb process mechanisms. */
1957 /* NOTE: Return something >=0. A -ve value is reserved for
1958 catch_exceptions. */
1963 remote_start_remote (struct ui_out
*uiout
, void *dummy
)
1965 immediate_quit
++; /* Allow user to interrupt it. */
1967 /* Ack any packet which the remote side has already sent. */
1968 serial_write (remote_desc
, "+", 1);
1970 /* Let the stub know that we want it to return the thread. */
1973 inferior_ptid
= remote_current_thread (inferior_ptid
);
1975 get_offsets (); /* Get text, data & bss offsets. */
1977 putpkt ("?"); /* Initiate a query from remote machine. */
1980 remote_start_remote_dummy (uiout
, dummy
);
1983 /* Open a connection to a remote debugger.
1984 NAME is the filename used for communication. */
1987 remote_open (char *name
, int from_tty
)
1989 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
1992 /* Just like remote_open, but with asynchronous support. */
1994 remote_async_open (char *name
, int from_tty
)
1996 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
1999 /* Open a connection to a remote debugger using the extended
2000 remote gdb protocol. NAME is the filename used for communication. */
2003 extended_remote_open (char *name
, int from_tty
)
2005 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2009 /* Just like extended_remote_open, but with asynchronous support. */
2011 extended_remote_async_open (char *name
, int from_tty
)
2013 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2014 1 /*extended_p */, 1 /* async_p */);
2017 /* Generic code for opening a connection to a remote target. */
2020 init_all_packet_configs (void)
2023 for (i
= 0; i
< PACKET_MAX
; i
++)
2024 update_packet_config (&remote_protocol_packets
[i
]);
2027 /* Symbol look-up. */
2030 remote_check_symbols (struct objfile
*objfile
)
2032 struct remote_state
*rs
= get_remote_state ();
2033 char *msg
, *reply
, *tmp
;
2034 struct minimal_symbol
*sym
;
2037 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2040 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2041 because we need both at the same time. */
2042 msg
= alloca (get_remote_packet_size ());
2044 /* Invite target to request symbol lookups. */
2046 putpkt ("qSymbol::");
2047 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2048 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2051 while (strncmp (reply
, "qSymbol:", 8) == 0)
2054 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2056 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2058 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2060 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2061 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2064 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2069 static struct serial
*
2070 remote_serial_open (char *name
)
2072 static int udp_warning
= 0;
2074 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2075 of in ser-tcp.c, because it is the remote protocol assuming that the
2076 serial connection is reliable and not the serial connection promising
2078 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2081 The remote protocol may be unreliable over UDP.\n\
2082 Some events may be lost, rendering further debugging impossible."));
2086 return serial_open (name
);
2089 /* This type describes each known response to the qSupported
2091 struct protocol_feature
2093 /* The name of this protocol feature. */
2096 /* The default for this protocol feature. */
2097 enum packet_support default_support
;
2099 /* The function to call when this feature is reported, or after
2100 qSupported processing if the feature is not supported.
2101 The first argument points to this structure. The second
2102 argument indicates whether the packet requested support be
2103 enabled, disabled, or probed (or the default, if this function
2104 is being called at the end of processing and this feature was
2105 not reported). The third argument may be NULL; if not NULL, it
2106 is a NUL-terminated string taken from the packet following
2107 this feature's name and an equals sign. */
2108 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2111 /* The corresponding packet for this feature. Only used if
2112 FUNC is remote_supported_packet. */
2117 remote_supported_packet (const struct protocol_feature
*feature
,
2118 enum packet_support support
,
2119 const char *argument
)
2123 warning (_("Remote qSupported response supplied an unexpected value for"
2124 " \"%s\"."), feature
->name
);
2128 if (remote_protocol_packets
[feature
->packet
].support
2129 == PACKET_SUPPORT_UNKNOWN
)
2130 remote_protocol_packets
[feature
->packet
].support
= support
;
2134 remote_packet_size (const struct protocol_feature
*feature
,
2135 enum packet_support support
, const char *value
)
2137 struct remote_state
*rs
= get_remote_state ();
2142 if (support
!= PACKET_ENABLE
)
2145 if (value
== NULL
|| *value
== '\0')
2147 warning (_("Remote target reported \"%s\" without a size."),
2153 packet_size
= strtol (value
, &value_end
, 16);
2154 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2156 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2157 feature
->name
, value
);
2161 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2163 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2164 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2165 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2168 /* Record the new maximum packet size. */
2169 rs
->explicit_packet_size
= packet_size
;
2172 static struct protocol_feature remote_protocol_features
[] = {
2173 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2174 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2179 remote_query_supported (void)
2181 struct remote_state
*rs
= get_remote_state ();
2184 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2186 /* The packet support flags are handled differently for this packet
2187 than for most others. We treat an error, a disabled packet, and
2188 an empty response identically: any features which must be reported
2189 to be used will be automatically disabled. An empty buffer
2190 accomplishes this, since that is also the representation for a list
2191 containing no features. */
2194 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2196 putpkt ("qSupported");
2197 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2199 /* If an error occured, warn, but do not return - just reset the
2200 buffer to empty and go on to disable features. */
2201 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2204 warning (_("Remote failure reply: %s"), rs
->buf
);
2209 memset (seen
, 0, sizeof (seen
));
2214 enum packet_support is_supported
;
2215 char *p
, *end
, *name_end
, *value
;
2217 /* First separate out this item from the rest of the packet. If
2218 there's another item after this, we overwrite the separator
2219 (terminated strings are much easier to work with). */
2221 end
= strchr (p
, ';');
2224 end
= p
+ strlen (p
);
2231 warning (_("empty item in \"qSupported\" response"));
2239 name_end
= strchr (p
, '=');
2242 /* This is a name=value entry. */
2243 is_supported
= PACKET_ENABLE
;
2244 value
= name_end
+ 1;
2253 is_supported
= PACKET_ENABLE
;
2257 is_supported
= PACKET_DISABLE
;
2261 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2265 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2271 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2272 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2274 const struct protocol_feature
*feature
;
2277 feature
= &remote_protocol_features
[i
];
2278 feature
->func (feature
, is_supported
, value
);
2283 /* If we increased the packet size, make sure to increase the global
2284 buffer size also. We delay this until after parsing the entire
2285 qSupported packet, because this is the same buffer we were
2287 if (rs
->buf_size
< rs
->explicit_packet_size
)
2289 rs
->buf_size
= rs
->explicit_packet_size
;
2290 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2293 /* Handle the defaults for unmentioned features. */
2294 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2297 const struct protocol_feature
*feature
;
2299 feature
= &remote_protocol_features
[i
];
2300 feature
->func (feature
, feature
->default_support
, NULL
);
2306 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2307 int extended_p
, int async_p
)
2309 struct remote_state
*rs
= get_remote_state ();
2311 error (_("To open a remote debug connection, you need to specify what\n"
2312 "serial device is attached to the remote system\n"
2313 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2315 /* See FIXME above. */
2317 wait_forever_enabled_p
= 1;
2319 target_preopen (from_tty
);
2321 unpush_target (target
);
2323 remote_fileio_reset ();
2324 reopen_exec_file ();
2327 remote_desc
= remote_serial_open (name
);
2329 perror_with_name (name
);
2331 if (baud_rate
!= -1)
2333 if (serial_setbaudrate (remote_desc
, baud_rate
))
2335 /* The requested speed could not be set. Error out to
2336 top level after closing remote_desc. Take care to
2337 set remote_desc to NULL to avoid closing remote_desc
2339 serial_close (remote_desc
);
2341 perror_with_name (name
);
2345 serial_raw (remote_desc
);
2347 /* If there is something sitting in the buffer we might take it as a
2348 response to a command, which would be bad. */
2349 serial_flush_input (remote_desc
);
2353 puts_filtered ("Remote debugging using ");
2354 puts_filtered (name
);
2355 puts_filtered ("\n");
2357 push_target (target
); /* Switch to using remote target now. */
2359 /* Reset the target state; these things will be queried either by
2360 remote_query_supported or as they are needed. */
2361 init_all_packet_configs ();
2362 rs
->explicit_packet_size
= 0;
2364 general_thread
= -2;
2365 continue_thread
= -2;
2367 /* Probe for ability to use "ThreadInfo" query, as required. */
2368 use_threadinfo_query
= 1;
2369 use_threadextra_query
= 1;
2371 /* The first packet we send to the target is the optional "supported
2372 packets" request. If the target can answer this, it will tell us
2373 which later probes to skip. */
2374 remote_query_supported ();
2376 /* Without this, some commands which require an active target (such
2377 as kill) won't work. This variable serves (at least) double duty
2378 as both the pid of the target process (if it has such), and as a
2379 flag indicating that a target is active. These functions should
2380 be split out into seperate variables, especially since GDB will
2381 someday have a notion of debugging several processes. */
2383 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2387 /* With this target we start out by owning the terminal. */
2388 remote_async_terminal_ours_p
= 1;
2390 /* FIXME: cagney/1999-09-23: During the initial connection it is
2391 assumed that the target is already ready and able to respond to
2392 requests. Unfortunately remote_start_remote() eventually calls
2393 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2394 around this. Eventually a mechanism that allows
2395 wait_for_inferior() to expect/get timeouts will be
2397 wait_forever_enabled_p
= 0;
2400 /* First delete any symbols previously loaded from shared libraries. */
2401 no_shared_libraries (NULL
, 0);
2403 /* Start the remote connection. If error() or QUIT, discard this
2404 target (we'd otherwise be in an inconsistent state) and then
2405 propogate the error on up the exception chain. This ensures that
2406 the caller doesn't stumble along blindly assuming that the
2407 function succeeded. The CLI doesn't have this problem but other
2408 UI's, such as MI do.
2410 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2411 this function should return an error indication letting the
2412 caller restore the previous state. Unfortunately the command
2413 ``target remote'' is directly wired to this function making that
2414 impossible. On a positive note, the CLI side of this problem has
2415 been fixed - the function set_cmd_context() makes it possible for
2416 all the ``target ....'' commands to share a common callback
2417 function. See cli-dump.c. */
2419 struct gdb_exception ex
2420 = catch_exception (uiout
, remote_start_remote
, NULL
, RETURN_MASK_ALL
);
2425 wait_forever_enabled_p
= 1;
2426 throw_exception (ex
);
2431 wait_forever_enabled_p
= 1;
2435 /* Tell the remote that we are using the extended protocol. */
2437 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2440 post_create_inferior (¤t_target
, from_tty
);
2442 if (exec_bfd
) /* No use without an exec file. */
2443 remote_check_symbols (symfile_objfile
);
2446 /* This takes a program previously attached to and detaches it. After
2447 this is done, GDB can be used to debug some other program. We
2448 better not have left any breakpoints in the target program or it'll
2449 die when it hits one. */
2452 remote_detach (char *args
, int from_tty
)
2454 struct remote_state
*rs
= get_remote_state ();
2457 error (_("Argument given to \"detach\" when remotely debugging."));
2459 /* Tell the remote target to detach. */
2460 strcpy (rs
->buf
, "D");
2461 remote_send (&rs
->buf
, &rs
->buf_size
);
2463 /* Unregister the file descriptor from the event loop. */
2464 if (target_is_async_p ())
2465 serial_async (remote_desc
, NULL
, 0);
2467 target_mourn_inferior ();
2469 puts_filtered ("Ending remote debugging.\n");
2472 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2475 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2478 error (_("Argument given to \"detach\" when remotely debugging."));
2480 /* Unregister the file descriptor from the event loop. */
2481 if (target_is_async_p ())
2482 serial_async (remote_desc
, NULL
, 0);
2484 target_mourn_inferior ();
2486 puts_filtered ("Ending remote debugging.\n");
2489 /* Convert hex digit A to a number. */
2494 if (a
>= '0' && a
<= '9')
2496 else if (a
>= 'a' && a
<= 'f')
2497 return a
- 'a' + 10;
2498 else if (a
>= 'A' && a
<= 'F')
2499 return a
- 'A' + 10;
2501 error (_("Reply contains invalid hex digit %d"), a
);
2505 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2509 for (i
= 0; i
< count
; i
++)
2511 if (hex
[0] == 0 || hex
[1] == 0)
2513 /* Hex string is short, or of uneven length.
2514 Return the count that has been converted so far. */
2517 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2523 /* Convert number NIB to a hex digit. */
2531 return 'a' + nib
- 10;
2535 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2538 /* May use a length, or a nul-terminated string as input. */
2540 count
= strlen ((char *) bin
);
2542 for (i
= 0; i
< count
; i
++)
2544 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2545 *hex
++ = tohex (*bin
++ & 0xf);
2551 /* Check for the availability of vCont. This function should also check
2555 remote_vcont_probe (struct remote_state
*rs
)
2559 strcpy (rs
->buf
, "vCont?");
2561 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2564 /* Make sure that the features we assume are supported. */
2565 if (strncmp (buf
, "vCont", 5) == 0)
2568 int support_s
, support_S
, support_c
, support_C
;
2574 while (p
&& *p
== ';')
2577 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2579 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2581 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2583 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2586 p
= strchr (p
, ';');
2589 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2590 BUF will make packet_ok disable the packet. */
2591 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2595 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2598 /* Resume the remote inferior by using a "vCont" packet. The thread
2599 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2600 resumed thread should be single-stepped and/or signalled. If PTID's
2601 PID is -1, then all threads are resumed; the thread to be stepped and/or
2602 signalled is given in the global INFERIOR_PTID. This function returns
2603 non-zero iff it resumes the inferior.
2605 This function issues a strict subset of all possible vCont commands at the
2609 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2611 struct remote_state
*rs
= get_remote_state ();
2612 int pid
= PIDGET (ptid
);
2613 char *buf
= NULL
, *outbuf
;
2614 struct cleanup
*old_cleanup
;
2616 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2617 remote_vcont_probe (rs
);
2619 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2622 /* If we could generate a wider range of packets, we'd have to worry
2623 about overflowing BUF. Should there be a generic
2624 "multi-part-packet" packet? */
2626 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2628 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2629 don't have any PID numbers the inferior will understand. Make sure
2630 to only send forms that do not specify a PID. */
2631 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2632 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2634 outbuf
= xstrprintf ("vCont;s");
2635 else if (siggnal
!= TARGET_SIGNAL_0
)
2636 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2638 outbuf
= xstrprintf ("vCont;c");
2642 /* Resume all threads, with preference for INFERIOR_PTID. */
2643 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2644 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2645 PIDGET (inferior_ptid
));
2647 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2648 else if (siggnal
!= TARGET_SIGNAL_0
)
2649 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2650 PIDGET (inferior_ptid
));
2652 outbuf
= xstrprintf ("vCont;c");
2656 /* Scheduler locking; resume only PTID. */
2657 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2658 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2660 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2661 else if (siggnal
!= TARGET_SIGNAL_0
)
2662 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2664 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2667 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2668 old_cleanup
= make_cleanup (xfree
, outbuf
);
2672 do_cleanups (old_cleanup
);
2677 /* Tell the remote machine to resume. */
2679 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2681 static int last_sent_step
;
2684 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2686 struct remote_state
*rs
= get_remote_state ();
2688 int pid
= PIDGET (ptid
);
2690 last_sent_signal
= siggnal
;
2691 last_sent_step
= step
;
2693 /* A hook for when we need to do something at the last moment before
2695 if (deprecated_target_resume_hook
)
2696 (*deprecated_target_resume_hook
) ();
2698 /* The vCont packet doesn't need to specify threads via Hc. */
2699 if (remote_vcont_resume (ptid
, step
, siggnal
))
2702 /* All other supported resume packets do use Hc, so call set_thread. */
2704 set_thread (0, 0); /* Run any thread. */
2706 set_thread (pid
, 0); /* Run this thread. */
2709 if (siggnal
!= TARGET_SIGNAL_0
)
2711 buf
[0] = step
? 'S' : 'C';
2712 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2713 buf
[2] = tohex (((int) siggnal
) & 0xf);
2717 strcpy (buf
, step
? "s" : "c");
2722 /* Same as remote_resume, but with async support. */
2724 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2726 remote_resume (ptid
, step
, siggnal
);
2728 /* We are about to start executing the inferior, let's register it
2729 with the event loop. NOTE: this is the one place where all the
2730 execution commands end up. We could alternatively do this in each
2731 of the execution commands in infcmd.c. */
2732 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2733 into infcmd.c in order to allow inferior function calls to work
2734 NOT asynchronously. */
2735 if (target_can_async_p ())
2736 target_async (inferior_event_handler
, 0);
2737 /* Tell the world that the target is now executing. */
2738 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2739 this? Instead, should the client of target just assume (for
2740 async targets) that the target is going to start executing? Is
2741 this information already found in the continuation block? */
2742 if (target_is_async_p ())
2743 target_executing
= 1;
2747 /* Set up the signal handler for SIGINT, while the target is
2748 executing, ovewriting the 'regular' SIGINT signal handler. */
2750 initialize_sigint_signal_handler (void)
2752 sigint_remote_token
=
2753 create_async_signal_handler (async_remote_interrupt
, NULL
);
2754 signal (SIGINT
, handle_remote_sigint
);
2757 /* Signal handler for SIGINT, while the target is executing. */
2759 handle_remote_sigint (int sig
)
2761 signal (sig
, handle_remote_sigint_twice
);
2762 sigint_remote_twice_token
=
2763 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2764 mark_async_signal_handler_wrapper (sigint_remote_token
);
2767 /* Signal handler for SIGINT, installed after SIGINT has already been
2768 sent once. It will take effect the second time that the user sends
2771 handle_remote_sigint_twice (int sig
)
2773 signal (sig
, handle_sigint
);
2774 sigint_remote_twice_token
=
2775 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
2776 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
2779 /* Perform the real interruption of the target execution, in response
2782 async_remote_interrupt (gdb_client_data arg
)
2785 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2790 /* Perform interrupt, if the first attempt did not succeed. Just give
2791 up on the target alltogether. */
2793 async_remote_interrupt_twice (gdb_client_data arg
)
2796 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
2797 /* Do something only if the target was not killed by the previous
2799 if (target_executing
)
2802 signal (SIGINT
, handle_remote_sigint
);
2806 /* Reinstall the usual SIGINT handlers, after the target has
2809 cleanup_sigint_signal_handler (void *dummy
)
2811 signal (SIGINT
, handle_sigint
);
2812 if (sigint_remote_twice_token
)
2813 delete_async_signal_handler ((struct async_signal_handler
**)
2814 &sigint_remote_twice_token
);
2815 if (sigint_remote_token
)
2816 delete_async_signal_handler ((struct async_signal_handler
**)
2817 &sigint_remote_token
);
2820 /* Send ^C to target to halt it. Target will respond, and send us a
2822 static void (*ofunc
) (int);
2824 /* The command line interface's stop routine. This function is installed
2825 as a signal handler for SIGINT. The first time a user requests a
2826 stop, we call remote_stop to send a break or ^C. If there is no
2827 response from the target (it didn't stop when the user requested it),
2828 we ask the user if he'd like to detach from the target. */
2830 remote_interrupt (int signo
)
2832 /* If this doesn't work, try more severe steps. */
2833 signal (signo
, remote_interrupt_twice
);
2836 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2841 /* The user typed ^C twice. */
2844 remote_interrupt_twice (int signo
)
2846 signal (signo
, ofunc
);
2848 signal (signo
, remote_interrupt
);
2851 /* This is the generic stop called via the target vector. When a target
2852 interrupt is requested, either by the command line or the GUI, we
2853 will eventually end up here. */
2857 /* Send a break or a ^C, depending on user preference. */
2859 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
2862 serial_send_break (remote_desc
);
2864 serial_write (remote_desc
, "\003", 1);
2867 /* Ask the user what to do when an interrupt is received. */
2870 interrupt_query (void)
2872 target_terminal_ours ();
2874 if (query ("Interrupted while waiting for the program.\n\
2875 Give up (and stop debugging it)? "))
2877 target_mourn_inferior ();
2878 deprecated_throw_reason (RETURN_QUIT
);
2881 target_terminal_inferior ();
2884 /* Enable/disable target terminal ownership. Most targets can use
2885 terminal groups to control terminal ownership. Remote targets are
2886 different in that explicit transfer of ownership to/from GDB/target
2890 remote_async_terminal_inferior (void)
2892 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
2893 sync_execution here. This function should only be called when
2894 GDB is resuming the inferior in the forground. A background
2895 resume (``run&'') should leave GDB in control of the terminal and
2896 consequently should not call this code. */
2897 if (!sync_execution
)
2899 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
2900 calls target_terminal_*() idenpotent. The event-loop GDB talking
2901 to an asynchronous target with a synchronous command calls this
2902 function from both event-top.c and infrun.c/infcmd.c. Once GDB
2903 stops trying to transfer the terminal to the target when it
2904 shouldn't this guard can go away. */
2905 if (!remote_async_terminal_ours_p
)
2907 delete_file_handler (input_fd
);
2908 remote_async_terminal_ours_p
= 0;
2909 initialize_sigint_signal_handler ();
2910 /* NOTE: At this point we could also register our selves as the
2911 recipient of all input. Any characters typed could then be
2912 passed on down to the target. */
2916 remote_async_terminal_ours (void)
2918 /* See FIXME in remote_async_terminal_inferior. */
2919 if (!sync_execution
)
2921 /* See FIXME in remote_async_terminal_inferior. */
2922 if (remote_async_terminal_ours_p
)
2924 cleanup_sigint_signal_handler (NULL
);
2925 add_file_handler (input_fd
, stdin_event_handler
, 0);
2926 remote_async_terminal_ours_p
= 1;
2929 /* If nonzero, ignore the next kill. */
2934 remote_console_output (char *msg
)
2938 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
2941 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
2944 fputs_unfiltered (tb
, gdb_stdtarg
);
2946 gdb_flush (gdb_stdtarg
);
2949 /* Wait until the remote machine stops, then return,
2950 storing status in STATUS just as `wait' would.
2951 Returns "pid", which in the case of a multi-threaded
2952 remote OS, is the thread-id. */
2955 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2957 struct remote_state
*rs
= get_remote_state ();
2958 struct remote_arch_state
*rsa
= get_remote_arch_state ();
2959 ULONGEST thread_num
= -1;
2962 status
->kind
= TARGET_WAITKIND_EXITED
;
2963 status
->value
.integer
= 0;
2969 ofunc
= signal (SIGINT
, remote_interrupt
);
2970 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
2971 signal (SIGINT
, ofunc
);
2975 /* This is a hook for when we need to do something (perhaps the
2976 collection of trace data) every time the target stops. */
2977 if (deprecated_target_wait_loop_hook
)
2978 (*deprecated_target_wait_loop_hook
) ();
2980 remote_stopped_by_watchpoint_p
= 0;
2984 case 'E': /* Error of some sort. */
2985 warning (_("Remote failure reply: %s"), buf
);
2987 case 'F': /* File-I/O request. */
2988 remote_fileio_request (buf
);
2990 case 'T': /* Status with PC, SP, FP, ... */
2992 gdb_byte regs
[MAX_REGISTER_SIZE
];
2994 /* Expedited reply, containing Signal, {regno, reg} repeat. */
2995 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
2997 n... = register number
2998 r... = register contents
3000 p
= &buf
[3]; /* after Txx */
3009 /* If the packet contains a register number save it in
3010 pnum and set p1 to point to the character following
3011 it. Otherwise p1 points to p. */
3013 /* If this packet is an awatch packet, don't parse the
3014 'a' as a register number. */
3016 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3018 /* Read the ``P'' register number. */
3019 pnum
= strtol (p
, &p_temp
, 16);
3025 if (p1
== p
) /* No register number present here. */
3027 p1
= strchr (p
, ':');
3029 error (_("Malformed packet(a) (missing colon): %s\n\
3032 if (strncmp (p
, "thread", p1
- p
) == 0)
3034 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3035 record_currthread (thread_num
);
3038 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3039 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3040 || (strncmp (p
, "awatch", p1
- p
) == 0))
3042 remote_stopped_by_watchpoint_p
= 1;
3043 p
= unpack_varlen_hex (++p1
, &addr
);
3044 remote_watch_data_address
= (CORE_ADDR
)addr
;
3048 /* Silently skip unknown optional info. */
3049 p_temp
= strchr (p1
+ 1, ';');
3056 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3060 error (_("Malformed packet(b) (missing colon): %s\n\
3065 error (_("Remote sent bad register number %s: %s\n\
3067 phex_nz (pnum
, 0), p
, buf
);
3069 fieldsize
= hex2bin (p
, regs
,
3070 register_size (current_gdbarch
,
3073 if (fieldsize
< register_size (current_gdbarch
,
3075 warning (_("Remote reply is too short: %s"), buf
);
3076 regcache_raw_supply (current_regcache
,
3081 error (_("Remote register badly formatted: %s\nhere: %s"),
3086 case 'S': /* Old style status, just signal only. */
3087 status
->kind
= TARGET_WAITKIND_STOPPED
;
3088 status
->value
.sig
= (enum target_signal
)
3089 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3093 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3094 record_currthread (thread_num
);
3097 case 'W': /* Target exited. */
3099 /* The remote process exited. */
3100 status
->kind
= TARGET_WAITKIND_EXITED
;
3101 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3105 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3106 status
->value
.sig
= (enum target_signal
)
3107 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3111 case 'O': /* Console output. */
3112 remote_console_output (buf
+ 1);
3115 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3117 /* Zero length reply means that we tried 'S' or 'C' and
3118 the remote system doesn't support it. */
3119 target_terminal_ours_for_output ();
3121 ("Can't send signals to this remote system. %s not sent.\n",
3122 target_signal_to_name (last_sent_signal
));
3123 last_sent_signal
= TARGET_SIGNAL_0
;
3124 target_terminal_inferior ();
3126 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3127 putpkt ((char *) buf
);
3130 /* else fallthrough */
3132 warning (_("Invalid remote reply: %s"), buf
);
3137 if (thread_num
!= -1)
3139 return pid_to_ptid (thread_num
);
3141 return inferior_ptid
;
3144 /* Async version of remote_wait. */
3146 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3148 struct remote_state
*rs
= get_remote_state ();
3149 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3150 ULONGEST thread_num
= -1;
3153 status
->kind
= TARGET_WAITKIND_EXITED
;
3154 status
->value
.integer
= 0;
3156 remote_stopped_by_watchpoint_p
= 0;
3162 if (!target_is_async_p ())
3163 ofunc
= signal (SIGINT
, remote_interrupt
);
3164 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3165 _never_ wait for ever -> test on target_is_async_p().
3166 However, before we do that we need to ensure that the caller
3167 knows how to take the target into/out of async mode. */
3168 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3169 if (!target_is_async_p ())
3170 signal (SIGINT
, ofunc
);
3174 /* This is a hook for when we need to do something (perhaps the
3175 collection of trace data) every time the target stops. */
3176 if (deprecated_target_wait_loop_hook
)
3177 (*deprecated_target_wait_loop_hook
) ();
3181 case 'E': /* Error of some sort. */
3182 warning (_("Remote failure reply: %s"), buf
);
3184 case 'F': /* File-I/O request. */
3185 remote_fileio_request (buf
);
3187 case 'T': /* Status with PC, SP, FP, ... */
3189 gdb_byte regs
[MAX_REGISTER_SIZE
];
3191 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3192 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3194 n... = register number
3195 r... = register contents
3197 p
= &buf
[3]; /* after Txx */
3206 /* If the packet contains a register number, save it
3207 in pnum and set p1 to point to the character
3208 following it. Otherwise p1 points to p. */
3210 /* If this packet is an awatch packet, don't parse the 'a'
3211 as a register number. */
3213 if (!strncmp (p
, "awatch", strlen ("awatch")) != 0)
3215 /* Read the register number. */
3216 pnum
= strtol (p
, &p_temp
, 16);
3222 if (p1
== p
) /* No register number present here. */
3224 p1
= strchr (p
, ':');
3226 error (_("Malformed packet(a) (missing colon): %s\n\
3229 if (strncmp (p
, "thread", p1
- p
) == 0)
3231 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3232 record_currthread (thread_num
);
3235 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3236 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3237 || (strncmp (p
, "awatch", p1
- p
) == 0))
3239 remote_stopped_by_watchpoint_p
= 1;
3240 p
= unpack_varlen_hex (++p1
, &addr
);
3241 remote_watch_data_address
= (CORE_ADDR
)addr
;
3245 /* Silently skip unknown optional info. */
3246 p_temp
= strchr (p1
+ 1, ';');
3254 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3257 error (_("Malformed packet(b) (missing colon): %s\n\
3262 error (_("Remote sent bad register number %ld: %s\n\
3266 fieldsize
= hex2bin (p
, regs
,
3267 register_size (current_gdbarch
,
3270 if (fieldsize
< register_size (current_gdbarch
,
3272 warning (_("Remote reply is too short: %s"), buf
);
3273 regcache_raw_supply (current_regcache
, reg
->regnum
, regs
);
3277 error (_("Remote register badly formatted: %s\nhere: %s"),
3282 case 'S': /* Old style status, just signal only. */
3283 status
->kind
= TARGET_WAITKIND_STOPPED
;
3284 status
->value
.sig
= (enum target_signal
)
3285 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3289 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3290 record_currthread (thread_num
);
3293 case 'W': /* Target exited. */
3295 /* The remote process exited. */
3296 status
->kind
= TARGET_WAITKIND_EXITED
;
3297 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3301 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3302 status
->value
.sig
= (enum target_signal
)
3303 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3307 case 'O': /* Console output. */
3308 remote_console_output (buf
+ 1);
3309 /* Return immediately to the event loop. The event loop will
3310 still be waiting on the inferior afterwards. */
3311 status
->kind
= TARGET_WAITKIND_IGNORE
;
3314 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3316 /* Zero length reply means that we tried 'S' or 'C' and
3317 the remote system doesn't support it. */
3318 target_terminal_ours_for_output ();
3320 ("Can't send signals to this remote system. %s not sent.\n",
3321 target_signal_to_name (last_sent_signal
));
3322 last_sent_signal
= TARGET_SIGNAL_0
;
3323 target_terminal_inferior ();
3325 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3326 putpkt ((char *) buf
);
3329 /* else fallthrough */
3331 warning (_("Invalid remote reply: %s"), buf
);
3336 if (thread_num
!= -1)
3338 return pid_to_ptid (thread_num
);
3340 return inferior_ptid
;
3343 /* Number of bytes of registers this stub implements. */
3345 static int register_bytes_found
;
3347 /* Read the remote registers into the block REGS. */
3348 /* Currently we just read all the registers, so we don't use regnum. */
3351 fetch_register_using_p (int regnum
)
3353 struct remote_state
*rs
= get_remote_state ();
3355 char regp
[MAX_REGISTER_SIZE
];
3360 p
+= hexnumstr (p
, regnum
);
3362 remote_send (&rs
->buf
, &rs
->buf_size
);
3366 /* If the stub didn't recognize the packet, or if we got an error,
3368 if (buf
[0] == '\0' || buf
[0] == 'E')
3371 /* If this register is unfetchable, tell the regcache. */
3374 regcache_raw_supply (current_regcache
, regnum
, NULL
);
3375 set_register_cached (regnum
, -1);
3379 /* Otherwise, parse and supply the value. */
3386 error (_("fetch_register_using_p: early buf termination"));
3390 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3393 regcache_raw_supply (current_regcache
, regnum
, regp
);
3398 remote_fetch_registers (int regnum
)
3400 struct remote_state
*rs
= get_remote_state ();
3401 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3405 char *regs
= alloca (rsa
->sizeof_g_packet
);
3407 set_thread (PIDGET (inferior_ptid
), 1);
3411 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3412 gdb_assert (reg
!= NULL
);
3413 if (!reg
->in_g_packet
)
3414 internal_error (__FILE__
, __LINE__
,
3415 _("Attempt to fetch a non G-packet register when this "
3416 "remote.c does not support the p-packet."));
3418 switch (remote_protocol_packets
[PACKET_p
].support
)
3420 case PACKET_DISABLE
:
3423 if (fetch_register_using_p (regnum
))
3426 error (_("Protocol error: p packet not recognized by stub"));
3427 case PACKET_SUPPORT_UNKNOWN
:
3428 if (fetch_register_using_p (regnum
))
3430 /* The stub recognized the 'p' packet. Remember this. */
3431 remote_protocol_packets
[PACKET_p
].support
= PACKET_ENABLE
;
3436 /* The stub does not support the 'P' packet. Use 'G'
3437 instead, and don't try using 'P' in the future (it
3438 will just waste our time). */
3439 remote_protocol_packets
[PACKET_p
].support
= PACKET_DISABLE
;
3444 sprintf (rs
->buf
, "g");
3445 remote_send (&rs
->buf
, &rs
->buf_size
);
3448 /* Save the size of the packet sent to us by the target. Its used
3449 as a heuristic when determining the max size of packets that the
3450 target can safely receive. */
3451 if ((rsa
->actual_register_packet_size
) == 0)
3452 (rsa
->actual_register_packet_size
) = strlen (buf
);
3454 /* Unimplemented registers read as all bits zero. */
3455 memset (regs
, 0, rsa
->sizeof_g_packet
);
3457 /* We can get out of synch in various cases. If the first character
3458 in the buffer is not a hex character, assume that has happened
3459 and try to fetch another packet to read. */
3460 while ((buf
[0] < '0' || buf
[0] > '9')
3461 && (buf
[0] < 'A' || buf
[0] > 'F')
3462 && (buf
[0] < 'a' || buf
[0] > 'f')
3463 && buf
[0] != 'x') /* New: unavailable register value. */
3466 fprintf_unfiltered (gdb_stdlog
,
3467 "Bad register packet; fetching a new packet\n");
3468 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3472 /* Reply describes registers byte by byte, each byte encoded as two
3473 hex characters. Suck them all up, then supply them to the
3474 register cacheing/storage mechanism. */
3477 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3483 warning (_("Remote reply is of odd length: %s"), buf
);
3484 /* Don't change register_bytes_found in this case, and don't
3485 print a second warning. */
3488 if (p
[0] == 'x' && p
[1] == 'x')
3489 regs
[i
] = 0; /* 'x' */
3491 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3495 if (i
!= register_bytes_found
)
3497 register_bytes_found
= i
;
3498 if (REGISTER_BYTES_OK_P ()
3499 && !REGISTER_BYTES_OK (i
))
3500 warning (_("Remote reply is too short: %s"), buf
);
3506 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
3508 struct packet_reg
*r
= &rsa
->regs
[i
];
3511 if (r
->offset
* 2 >= strlen (buf
))
3512 /* A short packet that didn't include the register's
3513 value, this implies that the register is zero (and
3514 not that the register is unavailable). Supply that
3516 regcache_raw_supply (current_regcache
, r
->regnum
, NULL
);
3517 else if (buf
[r
->offset
* 2] == 'x')
3519 gdb_assert (r
->offset
* 2 < strlen (buf
));
3520 /* The register isn't available, mark it as such (at
3521 the same time setting the value to zero). */
3522 regcache_raw_supply (current_regcache
, r
->regnum
, NULL
);
3523 set_register_cached (i
, -1);
3526 regcache_raw_supply (current_regcache
, r
->regnum
,
3533 /* Prepare to store registers. Since we may send them all (using a
3534 'G' request), we have to read out the ones we don't want to change
3538 remote_prepare_to_store (void)
3540 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3542 gdb_byte buf
[MAX_REGISTER_SIZE
];
3544 /* Make sure the entire registers array is valid. */
3545 switch (remote_protocol_packets
[PACKET_P
].support
)
3547 case PACKET_DISABLE
:
3548 case PACKET_SUPPORT_UNKNOWN
:
3549 /* Make sure all the necessary registers are cached. */
3550 for (i
= 0; i
< NUM_REGS
; i
++)
3551 if (rsa
->regs
[i
].in_g_packet
)
3552 regcache_raw_read (current_regcache
, rsa
->regs
[i
].regnum
, buf
);
3559 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3560 packet was not recognized. */
3563 store_register_using_P (int regnum
)
3565 struct remote_state
*rs
= get_remote_state ();
3566 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3567 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3568 /* Try storing a single register. */
3569 char *buf
= rs
->buf
;
3570 gdb_byte regp
[MAX_REGISTER_SIZE
];
3573 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3574 p
= buf
+ strlen (buf
);
3575 regcache_raw_collect (current_regcache
, reg
->regnum
, regp
);
3576 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3577 remote_send (&rs
->buf
, &rs
->buf_size
);
3579 return rs
->buf
[0] != '\0';
3583 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3584 contents of the register cache buffer. FIXME: ignores errors. */
3587 remote_store_registers (int regnum
)
3589 struct remote_state
*rs
= get_remote_state ();
3590 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3594 set_thread (PIDGET (inferior_ptid
), 1);
3598 switch (remote_protocol_packets
[PACKET_P
].support
)
3600 case PACKET_DISABLE
:
3603 if (store_register_using_P (regnum
))
3606 error (_("Protocol error: P packet not recognized by stub"));
3607 case PACKET_SUPPORT_UNKNOWN
:
3608 if (store_register_using_P (regnum
))
3610 /* The stub recognized the 'P' packet. Remember this. */
3611 remote_protocol_packets
[PACKET_P
].support
= PACKET_ENABLE
;
3616 /* The stub does not support the 'P' packet. Use 'G'
3617 instead, and don't try using 'P' in the future (it
3618 will just waste our time). */
3619 remote_protocol_packets
[PACKET_P
].support
= PACKET_DISABLE
;
3625 /* Extract all the registers in the regcache copying them into a
3629 regs
= alloca (rsa
->sizeof_g_packet
);
3630 memset (regs
, 0, rsa
->sizeof_g_packet
);
3631 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
3633 struct packet_reg
*r
= &rsa
->regs
[i
];
3635 regcache_raw_collect (current_regcache
, r
->regnum
, regs
+ r
->offset
);
3639 /* Command describes registers byte by byte,
3640 each byte encoded as two hex characters. */
3643 /* remote_prepare_to_store insures that register_bytes_found gets set. */
3644 bin2hex (regs
, p
, register_bytes_found
);
3645 remote_send (&rs
->buf
, &rs
->buf_size
);
3649 /* Return the number of hex digits in num. */
3652 hexnumlen (ULONGEST num
)
3656 for (i
= 0; num
!= 0; i
++)
3662 /* Set BUF to the minimum number of hex digits representing NUM. */
3665 hexnumstr (char *buf
, ULONGEST num
)
3667 int len
= hexnumlen (num
);
3668 return hexnumnstr (buf
, num
, len
);
3672 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3675 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3681 for (i
= width
- 1; i
>= 0; i
--)
3683 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3690 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3693 remote_address_masked (CORE_ADDR addr
)
3695 if (remote_address_size
> 0
3696 && remote_address_size
< (sizeof (ULONGEST
) * 8))
3698 /* Only create a mask when that mask can safely be constructed
3699 in a ULONGEST variable. */
3701 mask
= (mask
<< remote_address_size
) - 1;
3707 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
3708 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
3709 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
3710 (which may be more than *OUT_LEN due to escape characters). The
3711 total number of bytes in the output buffer will be at most
3715 remote_escape_output (const gdb_byte
*buffer
, int len
,
3716 gdb_byte
*out_buf
, int *out_len
,
3719 int input_index
, output_index
;
3722 for (input_index
= 0; input_index
< len
; input_index
++)
3724 gdb_byte b
= buffer
[input_index
];
3726 if (b
== '$' || b
== '#' || b
== '}')
3728 /* These must be escaped. */
3729 if (output_index
+ 2 > out_maxlen
)
3731 out_buf
[output_index
++] = '}';
3732 out_buf
[output_index
++] = b
^ 0x20;
3736 if (output_index
+ 1 > out_maxlen
)
3738 out_buf
[output_index
++] = b
;
3742 *out_len
= input_index
;
3743 return output_index
;
3746 /* Convert BUFFER, escaped data LEN bytes long, into binary data
3747 in OUT_BUF. Return the number of bytes written to OUT_BUF.
3748 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
3750 This function reverses remote_escape_output. It allows more
3751 escaped characters than that function does, in particular because
3752 '*' must be escaped to avoid the run-length encoding processing
3753 in reading packets. */
3756 remote_unescape_input (const gdb_byte
*buffer
, int len
,
3757 gdb_byte
*out_buf
, int out_maxlen
)
3759 int input_index
, output_index
;
3764 for (input_index
= 0; input_index
< len
; input_index
++)
3766 gdb_byte b
= buffer
[input_index
];
3768 if (output_index
+ 1 > out_maxlen
)
3770 warning (_("Received too much data from remote target;"
3771 " ignoring overflow."));
3772 return output_index
;
3777 out_buf
[output_index
++] = b
^ 0x20;
3783 out_buf
[output_index
++] = b
;
3787 error (_("Unmatched escape character in target response."));
3789 return output_index
;
3792 /* Determine whether the remote target supports binary downloading.
3793 This is accomplished by sending a no-op memory write of zero length
3794 to the target at the specified address. It does not suffice to send
3795 the whole packet, since many stubs strip the eighth bit and
3796 subsequently compute a wrong checksum, which causes real havoc with
3799 NOTE: This can still lose if the serial line is not eight-bit
3800 clean. In cases like this, the user should clear "remote
3804 check_binary_download (CORE_ADDR addr
)
3806 struct remote_state
*rs
= get_remote_state ();
3808 switch (remote_protocol_packets
[PACKET_X
].support
)
3810 case PACKET_DISABLE
:
3814 case PACKET_SUPPORT_UNKNOWN
:
3820 p
+= hexnumstr (p
, (ULONGEST
) addr
);
3822 p
+= hexnumstr (p
, (ULONGEST
) 0);
3826 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
3827 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3829 if (rs
->buf
[0] == '\0')
3832 fprintf_unfiltered (gdb_stdlog
,
3833 "binary downloading NOT suppported by target\n");
3834 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
3839 fprintf_unfiltered (gdb_stdlog
,
3840 "binary downloading suppported by target\n");
3841 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
3848 /* Write memory data directly to the remote machine.
3849 This does not inform the data cache; the data cache uses this.
3850 MEMADDR is the address in the remote memory space.
3851 MYADDR is the address of the buffer in our space.
3852 LEN is the number of bytes.
3854 Returns number of bytes transferred, or 0 (setting errno) for
3855 error. Only transfer a single packet. */
3858 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
3860 struct remote_state
*rs
= get_remote_state ();
3869 /* Should this be the selected frame? */
3870 gdbarch_remote_translate_xfer_address (current_gdbarch
,
3878 /* Verify that the target can support a binary download. */
3879 check_binary_download (memaddr
);
3881 payload_size
= get_memory_write_packet_size ();
3883 /* The packet buffer will be large enough for the payload;
3884 get_memory_packet_size ensures this. */
3886 /* Compute the size of the actual payload by subtracting out the
3887 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
3889 payload_size
-= strlen ("$M,:#NN");
3890 payload_size
-= hexnumlen (memaddr
);
3892 /* Construct the packet header: "[MX]<memaddr>,<len>:". */
3894 /* Append "[XM]". Compute a best guess of the number of bytes
3895 actually transfered. */
3897 switch (remote_protocol_packets
[PACKET_X
].support
)
3901 /* Best guess at number of bytes that will fit. */
3902 todo
= min (len
, payload_size
);
3903 payload_size
-= hexnumlen (todo
);
3904 todo
= min (todo
, payload_size
);
3906 case PACKET_DISABLE
:
3908 /* Num bytes that will fit. */
3909 todo
= min (len
, payload_size
/ 2);
3910 payload_size
-= hexnumlen (todo
);
3911 todo
= min (todo
, payload_size
/ 2);
3913 case PACKET_SUPPORT_UNKNOWN
:
3914 internal_error (__FILE__
, __LINE__
,
3915 _("remote_write_bytes: bad internal state"));
3917 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3920 internal_error (__FILE__
, __LINE__
,
3921 _("minumum packet size too small to write data"));
3923 /* If we already need another packet, then try to align the end
3924 of this packet to a useful boundary. */
3925 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
3926 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
3928 /* Append "<memaddr>". */
3929 memaddr
= remote_address_masked (memaddr
);
3930 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
3935 /* Append <len>. Retain the location/size of <len>. It may need to
3936 be adjusted once the packet body has been created. */
3938 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
3945 /* Append the packet body. */
3946 switch (remote_protocol_packets
[PACKET_X
].support
)
3949 /* Binary mode. Send target system values byte by byte, in
3950 increasing byte addresses. Only escape certain critical
3952 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
3955 /* If not all TODO bytes fit, then we'll need another packet. Make
3956 a second try to keep the end of the packet aligned. */
3957 if (nr_bytes
< todo
)
3961 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
3963 if (new_nr_bytes
!= nr_bytes
)
3964 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
3969 p
+= payload_length
;
3970 if (nr_bytes
< todo
)
3972 /* Escape chars have filled up the buffer prematurely,
3973 and we have actually sent fewer bytes than planned.
3974 Fix-up the length field of the packet. Use the same
3975 number of characters as before. */
3976 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
3977 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
3980 case PACKET_DISABLE
:
3981 /* Normal mode: Send target system values byte by byte, in
3982 increasing byte addresses. Each byte is encoded as a two hex
3984 nr_bytes
= bin2hex (myaddr
, p
, todo
);
3987 case PACKET_SUPPORT_UNKNOWN
:
3988 internal_error (__FILE__
, __LINE__
,
3989 _("remote_write_bytes: bad internal state"));
3991 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3994 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
3995 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3997 if (rs
->buf
[0] == 'E')
3999 /* There is no correspondance between what the remote protocol
4000 uses for errors and errno codes. We would like a cleaner way
4001 of representing errors (big enough to include errno codes,
4002 bfd_error codes, and others). But for now just return EIO. */
4007 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4008 fewer bytes than we'd planned. */
4012 /* Read memory data directly from the remote machine.
4013 This does not use the data cache; the data cache uses this.
4014 MEMADDR is the address in the remote memory space.
4015 MYADDR is the address of the buffer in our space.
4016 LEN is the number of bytes.
4018 Returns number of bytes transferred, or 0 for error. */
4020 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4021 remote targets) shouldn't attempt to read the entire buffer.
4022 Instead it should read a single packet worth of data and then
4023 return the byte size of that packet to the caller. The caller (its
4024 caller and its callers caller ;-) already contains code for
4025 handling partial reads. */
4028 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4030 struct remote_state
*rs
= get_remote_state ();
4031 int max_buf_size
; /* Max size of packet output buffer. */
4034 /* Should this be the selected frame? */
4035 gdbarch_remote_translate_xfer_address (current_gdbarch
,
4043 max_buf_size
= get_memory_read_packet_size ();
4044 /* The packet buffer will be large enough for the payload;
4045 get_memory_packet_size ensures this. */
4054 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4056 /* construct "m"<memaddr>","<len>" */
4057 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4058 memaddr
= remote_address_masked (memaddr
);
4061 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4063 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4067 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4069 if (rs
->buf
[0] == 'E'
4070 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4071 && rs
->buf
[3] == '\0')
4073 /* There is no correspondance between what the remote
4074 protocol uses for errors and errno codes. We would like
4075 a cleaner way of representing errors (big enough to
4076 include errno codes, bfd_error codes, and others). But
4077 for now just return EIO. */
4082 /* Reply describes memory byte by byte,
4083 each byte encoded as two hex characters. */
4086 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4088 /* Reply is short. This means that we were able to read
4089 only part of what we wanted to. */
4090 return i
+ (origlen
- len
);
4099 /* Read or write LEN bytes from inferior memory at MEMADDR,
4100 transferring to or from debugger address BUFFER. Write to inferior
4101 if SHOULD_WRITE is nonzero. Returns length of data written or
4102 read; 0 for error. TARGET is unused. */
4105 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4106 int should_write
, struct mem_attrib
*attrib
,
4107 struct target_ops
*target
)
4112 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4114 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4120 remote_files_info (struct target_ops
*ignore
)
4122 puts_filtered ("Debugging a target over a serial line.\n");
4125 /* Stuff for dealing with the packets which are part of this protocol.
4126 See comment at top of file for details. */
4128 /* Read a single character from the remote end. */
4131 readchar (int timeout
)
4135 ch
= serial_readchar (remote_desc
, timeout
);
4140 switch ((enum serial_rc
) ch
)
4143 target_mourn_inferior ();
4144 error (_("Remote connection closed"));
4147 perror_with_name (_("Remote communication error"));
4149 case SERIAL_TIMEOUT
:
4155 /* Send the command in *BUF to the remote machine, and read the reply
4156 into *BUF. Report an error if we get an error reply. Resize
4157 *BUF using xrealloc if necessary to hold the result, and update
4161 remote_send (char **buf
,
4165 getpkt (buf
, sizeof_buf
, 0);
4167 if ((*buf
)[0] == 'E')
4168 error (_("Remote failure reply: %s"), *buf
);
4171 /* Display a null-terminated packet on stdout, for debugging, using C
4175 print_packet (char *buf
)
4177 puts_filtered ("\"");
4178 fputstr_filtered (buf
, '"', gdb_stdout
);
4179 puts_filtered ("\"");
4185 return putpkt_binary (buf
, strlen (buf
));
4188 /* Send a packet to the remote machine, with error checking. The data
4189 of the packet is in BUF. The string in BUF can be at most
4190 get_remote_packet_size () - 5 to account for the $, # and checksum,
4191 and for a possible /0 if we are debugging (remote_debug) and want
4192 to print the sent packet as a string. */
4195 putpkt_binary (char *buf
, int cnt
)
4198 unsigned char csum
= 0;
4199 char *buf2
= alloca (cnt
+ 6);
4205 /* Copy the packet into buffer BUF2, encapsulating it
4206 and giving it a checksum. */
4211 for (i
= 0; i
< cnt
; i
++)
4217 *p
++ = tohex ((csum
>> 4) & 0xf);
4218 *p
++ = tohex (csum
& 0xf);
4220 /* Send it over and over until we get a positive ack. */
4224 int started_error_output
= 0;
4229 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4230 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4231 fprintf_unfiltered (gdb_stdlog
, "...");
4232 gdb_flush (gdb_stdlog
);
4234 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4235 perror_with_name (_("putpkt: write failed"));
4237 /* Read until either a timeout occurs (-2) or '+' is read. */
4240 ch
= readchar (remote_timeout
);
4248 case SERIAL_TIMEOUT
:
4250 if (started_error_output
)
4252 putchar_unfiltered ('\n');
4253 started_error_output
= 0;
4262 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4266 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4267 case SERIAL_TIMEOUT
:
4271 break; /* Retransmit buffer. */
4275 fprintf_unfiltered (gdb_stdlog
,
4276 "Packet instead of Ack, ignoring it\n");
4277 /* It's probably an old response sent because an ACK
4278 was lost. Gobble up the packet and ack it so it
4279 doesn't get retransmitted when we resend this
4282 serial_write (remote_desc
, "+", 1);
4283 continue; /* Now, go look for +. */
4288 if (!started_error_output
)
4290 started_error_output
= 1;
4291 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4293 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4297 break; /* Here to retransmit. */
4301 /* This is wrong. If doing a long backtrace, the user should be
4302 able to get out next time we call QUIT, without anything as
4303 violent as interrupt_query. If we want to provide a way out of
4304 here without getting to the next QUIT, it should be based on
4305 hitting ^C twice as in remote_wait. */
4315 /* Come here after finding the start of a frame when we expected an
4316 ack. Do our best to discard the rest of this packet. */
4325 c
= readchar (remote_timeout
);
4328 case SERIAL_TIMEOUT
:
4329 /* Nothing we can do. */
4332 /* Discard the two bytes of checksum and stop. */
4333 c
= readchar (remote_timeout
);
4335 c
= readchar (remote_timeout
);
4338 case '*': /* Run length encoding. */
4339 /* Discard the repeat count. */
4340 c
= readchar (remote_timeout
);
4345 /* A regular character. */
4351 /* Come here after finding the start of the frame. Collect the rest
4352 into *BUF, verifying the checksum, length, and handling run-length
4353 compression. NUL terminate the buffer. If there is not enough room,
4354 expand *BUF using xrealloc.
4356 Returns -1 on error, number of characters in buffer (ignoring the
4357 trailing NULL) on success. (could be extended to return one of the
4358 SERIAL status indications). */
4361 read_frame (char **buf_p
,
4374 c
= readchar (remote_timeout
);
4377 case SERIAL_TIMEOUT
:
4379 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4383 fputs_filtered ("Saw new packet start in middle of old one\n",
4385 return -1; /* Start a new packet, count retries. */
4388 unsigned char pktcsum
;
4394 check_0
= readchar (remote_timeout
);
4396 check_1
= readchar (remote_timeout
);
4398 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4401 fputs_filtered ("Timeout in checksum, retrying\n",
4405 else if (check_0
< 0 || check_1
< 0)
4408 fputs_filtered ("Communication error in checksum\n",
4413 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4414 if (csum
== pktcsum
)
4419 fprintf_filtered (gdb_stdlog
,
4420 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4422 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4423 fputs_filtered ("\n", gdb_stdlog
);
4425 /* Number of characters in buffer ignoring trailing
4429 case '*': /* Run length encoding. */
4434 c
= readchar (remote_timeout
);
4436 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4438 /* The character before ``*'' is repeated. */
4440 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4442 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4444 /* Make some more room in the buffer. */
4445 *sizeof_buf
+= repeat
;
4446 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4450 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4456 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4460 if (bc
>= *sizeof_buf
- 1)
4462 /* Make some more room in the buffer. */
4464 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4475 /* Read a packet from the remote machine, with error checking, and
4476 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4477 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4478 rather than timing out; this is used (in synchronous mode) to wait
4479 for a target that is is executing user code to stop. */
4480 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4481 don't have to change all the calls to getpkt to deal with the
4482 return value, because at the moment I don't know what the right
4483 thing to do it for those. */
4491 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4495 /* Read a packet from the remote machine, with error checking, and
4496 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4497 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4498 rather than timing out; this is used (in synchronous mode) to wait
4499 for a target that is is executing user code to stop. If FOREVER ==
4500 0, this function is allowed to time out gracefully and return an
4501 indication of this to the caller. Otherwise return the number
4504 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4511 strcpy (*buf
, "timeout");
4515 timeout
= watchdog
> 0 ? watchdog
: -1;
4519 timeout
= remote_timeout
;
4523 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4525 /* This can loop forever if the remote side sends us characters
4526 continuously, but if it pauses, we'll get a zero from
4527 readchar because of timeout. Then we'll count that as a
4530 /* Note that we will only wait forever prior to the start of a
4531 packet. After that, we expect characters to arrive at a
4532 brisk pace. They should show up within remote_timeout
4537 c
= readchar (timeout
);
4539 if (c
== SERIAL_TIMEOUT
)
4541 if (forever
) /* Watchdog went off? Kill the target. */
4544 target_mourn_inferior ();
4545 error (_("Watchdog has expired. Target detached."));
4548 fputs_filtered ("Timed out.\n", gdb_stdlog
);
4554 /* We've found the start of a packet, now collect the data. */
4556 val
= read_frame (buf
, sizeof_buf
);
4562 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
4563 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
4564 fprintf_unfiltered (gdb_stdlog
, "\n");
4566 serial_write (remote_desc
, "+", 1);
4570 /* Try the whole thing again. */
4572 serial_write (remote_desc
, "-", 1);
4575 /* We have tried hard enough, and just can't receive the packet.
4578 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
4579 serial_write (remote_desc
, "+", 1);
4586 /* For some mysterious reason, wait_for_inferior calls kill instead of
4587 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4591 target_mourn_inferior ();
4595 /* Use catch_errors so the user can quit from gdb even when we aren't on
4596 speaking terms with the remote system. */
4597 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4599 /* Don't wait for it to die. I'm not really sure it matters whether
4600 we do or not. For the existing stubs, kill is a noop. */
4601 target_mourn_inferior ();
4604 /* Async version of remote_kill. */
4606 remote_async_kill (void)
4608 /* Unregister the file descriptor from the event loop. */
4609 if (target_is_async_p ())
4610 serial_async (remote_desc
, NULL
, 0);
4612 /* For some mysterious reason, wait_for_inferior calls kill instead of
4613 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4617 target_mourn_inferior ();
4621 /* Use catch_errors so the user can quit from gdb even when we
4622 aren't on speaking terms with the remote system. */
4623 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4625 /* Don't wait for it to die. I'm not really sure it matters whether
4626 we do or not. For the existing stubs, kill is a noop. */
4627 target_mourn_inferior ();
4633 remote_mourn_1 (&remote_ops
);
4637 remote_async_mourn (void)
4639 remote_mourn_1 (&remote_async_ops
);
4643 extended_remote_mourn (void)
4645 /* We do _not_ want to mourn the target like this; this will
4646 remove the extended remote target from the target stack,
4647 and the next time the user says "run" it'll fail.
4649 FIXME: What is the right thing to do here? */
4651 remote_mourn_1 (&extended_remote_ops
);
4655 /* Worker function for remote_mourn. */
4657 remote_mourn_1 (struct target_ops
*target
)
4659 unpush_target (target
);
4660 generic_mourn_inferior ();
4663 /* In the extended protocol we want to be able to do things like
4664 "run" and have them basically work as expected. So we need
4665 a special create_inferior function.
4667 FIXME: One day add support for changing the exec file
4668 we're debugging, arguments and an environment. */
4671 extended_remote_create_inferior (char *exec_file
, char *args
,
4672 char **env
, int from_tty
)
4674 /* Rip out the breakpoints; we'll reinsert them after restarting
4675 the remote server. */
4676 remove_breakpoints ();
4678 /* Now restart the remote server. */
4679 extended_remote_restart ();
4681 /* Now put the breakpoints back in. This way we're safe if the
4682 restart function works via a unix fork on the remote side. */
4683 insert_breakpoints ();
4685 /* Clean up from the last time we were running. */
4686 clear_proceed_status ();
4689 /* Async version of extended_remote_create_inferior. */
4691 extended_remote_async_create_inferior (char *exec_file
, char *args
,
4692 char **env
, int from_tty
)
4694 /* Rip out the breakpoints; we'll reinsert them after restarting
4695 the remote server. */
4696 remove_breakpoints ();
4698 /* If running asynchronously, register the target file descriptor
4699 with the event loop. */
4700 if (target_can_async_p ())
4701 target_async (inferior_event_handler
, 0);
4703 /* Now restart the remote server. */
4704 extended_remote_restart ();
4706 /* Now put the breakpoints back in. This way we're safe if the
4707 restart function works via a unix fork on the remote side. */
4708 insert_breakpoints ();
4710 /* Clean up from the last time we were running. */
4711 clear_proceed_status ();
4715 /* On some machines, e.g. 68k, we may use a different breakpoint
4716 instruction than other targets; in those use
4717 DEPRECATED_REMOTE_BREAKPOINT instead of just BREAKPOINT_FROM_PC.
4718 Also, bi-endian targets may define
4719 DEPRECATED_LITTLE_REMOTE_BREAKPOINT and
4720 DEPRECATED_BIG_REMOTE_BREAKPOINT. If none of these are defined, we
4721 just call the standard routines that are in mem-break.c. */
4723 /* NOTE: cagney/2003-06-08: This is silly. A remote and simulator
4724 target should use an identical BREAKPOINT_FROM_PC. As for native,
4725 the ARCH-OS-tdep.c code can override the default. */
4727 #if defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && defined (DEPRECATED_BIG_REMOTE_BREAKPOINT) && !defined(DEPRECATED_REMOTE_BREAKPOINT)
4728 #define DEPRECATED_REMOTE_BREAKPOINT
4731 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4733 /* If the target isn't bi-endian, just pretend it is. */
4734 #if !defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && !defined (DEPRECATED_BIG_REMOTE_BREAKPOINT)
4735 #define DEPRECATED_LITTLE_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4736 #define DEPRECATED_BIG_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
4739 static unsigned char big_break_insn
[] = DEPRECATED_BIG_REMOTE_BREAKPOINT
;
4740 static unsigned char little_break_insn
[] = DEPRECATED_LITTLE_REMOTE_BREAKPOINT
;
4742 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4744 /* Insert a breakpoint. On targets that have software breakpoint
4745 support, we ask the remote target to do the work; on targets
4746 which don't, we insert a traditional memory breakpoint. */
4749 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
4751 CORE_ADDR addr
= bp_tgt
->placed_address
;
4752 struct remote_state
*rs
= get_remote_state ();
4753 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4757 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
4758 If it succeeds, then set the support to PACKET_ENABLE. If it
4759 fails, and the user has explicitly requested the Z support then
4760 report an error, otherwise, mark it disabled and go on. */
4762 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
4769 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
4770 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
4771 p
+= hexnumstr (p
, addr
);
4772 sprintf (p
, ",%d", bp_tgt
->placed_size
);
4775 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4777 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
4783 case PACKET_UNKNOWN
:
4788 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4789 bp_tgt
->placed_size
= bp_tgt
->shadow_len
= sizeof big_break_insn
;
4790 val
= target_read_memory (addr
, bp_tgt
->shadow_contents
, bp_tgt
->shadow_len
);
4794 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
4795 val
= target_write_memory (addr
, (char *) big_break_insn
,
4796 sizeof big_break_insn
);
4798 val
= target_write_memory (addr
, (char *) little_break_insn
,
4799 sizeof little_break_insn
);
4804 return memory_insert_breakpoint (bp_tgt
);
4805 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4809 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
4811 CORE_ADDR addr
= bp_tgt
->placed_address
;
4812 struct remote_state
*rs
= get_remote_state ();
4815 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
4823 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
4824 p
+= hexnumstr (p
, addr
);
4825 sprintf (p
, ",%d", bp_tgt
->placed_size
);
4828 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4830 return (rs
->buf
[0] == 'E');
4833 #ifdef DEPRECATED_REMOTE_BREAKPOINT
4834 return target_write_memory (bp_tgt
->placed_address
, bp_tgt
->shadow_contents
,
4835 bp_tgt
->shadow_len
);
4837 return memory_remove_breakpoint (bp_tgt
);
4838 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
4842 watchpoint_to_Z_packet (int type
)
4847 return Z_PACKET_WRITE_WP
;
4850 return Z_PACKET_READ_WP
;
4853 return Z_PACKET_ACCESS_WP
;
4856 internal_error (__FILE__
, __LINE__
,
4857 _("hw_bp_to_z: bad watchpoint type %d"), type
);
4862 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
4864 struct remote_state
*rs
= get_remote_state ();
4866 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
4868 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
4871 sprintf (rs
->buf
, "Z%x,", packet
);
4872 p
= strchr (rs
->buf
, '\0');
4873 addr
= remote_address_masked (addr
);
4874 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4875 sprintf (p
, ",%x", len
);
4878 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4880 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
4883 case PACKET_UNKNOWN
:
4888 internal_error (__FILE__
, __LINE__
,
4889 _("remote_insert_watchpoint: reached end of function"));
4894 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
4896 struct remote_state
*rs
= get_remote_state ();
4898 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
4900 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
4903 sprintf (rs
->buf
, "z%x,", packet
);
4904 p
= strchr (rs
->buf
, '\0');
4905 addr
= remote_address_masked (addr
);
4906 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4907 sprintf (p
, ",%x", len
);
4909 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4911 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
4914 case PACKET_UNKNOWN
:
4919 internal_error (__FILE__
, __LINE__
,
4920 _("remote_remove_watchpoint: reached end of function"));
4924 int remote_hw_watchpoint_limit
= -1;
4925 int remote_hw_breakpoint_limit
= -1;
4928 remote_check_watch_resources (int type
, int cnt
, int ot
)
4930 if (type
== bp_hardware_breakpoint
)
4932 if (remote_hw_breakpoint_limit
== 0)
4934 else if (remote_hw_breakpoint_limit
< 0)
4936 else if (cnt
<= remote_hw_breakpoint_limit
)
4941 if (remote_hw_watchpoint_limit
== 0)
4943 else if (remote_hw_watchpoint_limit
< 0)
4947 else if (cnt
<= remote_hw_watchpoint_limit
)
4954 remote_stopped_by_watchpoint (void)
4956 return remote_stopped_by_watchpoint_p
;
4959 extern int stepped_after_stopped_by_watchpoint
;
4962 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
4965 if (remote_stopped_by_watchpoint ()
4966 || stepped_after_stopped_by_watchpoint
)
4968 *addr_p
= remote_watch_data_address
;
4977 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
4980 struct remote_state
*rs
= get_remote_state ();
4983 /* The length field should be set to the size of a breakpoint
4984 instruction, even though we aren't inserting one ourselves. */
4986 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
4988 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
4995 addr
= remote_address_masked (bp_tgt
->placed_address
);
4996 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4997 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5000 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5002 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5005 case PACKET_UNKNOWN
:
5010 internal_error (__FILE__
, __LINE__
,
5011 _("remote_insert_hw_breakpoint: reached end of function"));
5016 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5019 struct remote_state
*rs
= get_remote_state ();
5022 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5029 addr
= remote_address_masked (bp_tgt
->placed_address
);
5030 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5031 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5034 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5036 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5039 case PACKET_UNKNOWN
:
5044 internal_error (__FILE__
, __LINE__
,
5045 _("remote_remove_hw_breakpoint: reached end of function"));
5048 /* Some targets are only capable of doing downloads, and afterwards
5049 they switch to the remote serial protocol. This function provides
5050 a clean way to get from the download target to the remote target.
5051 It's basically just a wrapper so that we don't have to expose any
5052 of the internal workings of remote.c.
5054 Prior to calling this routine, you should shutdown the current
5055 target code, else you will get the "A program is being debugged
5056 already..." message. Usually a call to pop_target() suffices. */
5059 push_remote_target (char *name
, int from_tty
)
5061 printf_filtered (_("Switching to remote protocol\n"));
5062 remote_open (name
, from_tty
);
5065 /* Table used by the crc32 function to calcuate the checksum. */
5067 static unsigned long crc32_table
[256] =
5070 static unsigned long
5071 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5073 if (!crc32_table
[1])
5075 /* Initialize the CRC table and the decoding table. */
5079 for (i
= 0; i
< 256; i
++)
5081 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5082 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5089 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5095 /* compare-sections command
5097 With no arguments, compares each loadable section in the exec bfd
5098 with the same memory range on the target, and reports mismatches.
5099 Useful for verifying the image on the target against the exec file.
5100 Depends on the target understanding the new "qCRC:" request. */
5102 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5103 target method (target verify memory) and generic version of the
5104 actual command. This will allow other high-level code (especially
5105 generic_load()) to make use of this target functionality. */
5108 compare_sections_command (char *args
, int from_tty
)
5110 struct remote_state
*rs
= get_remote_state ();
5112 unsigned long host_crc
, target_crc
;
5113 extern bfd
*exec_bfd
;
5114 struct cleanup
*old_chain
;
5117 const char *sectname
;
5124 error (_("command cannot be used without an exec file"));
5125 if (!current_target
.to_shortname
||
5126 strcmp (current_target
.to_shortname
, "remote") != 0)
5127 error (_("command can only be used with remote target"));
5129 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5131 if (!(s
->flags
& SEC_LOAD
))
5132 continue; /* skip non-loadable section */
5134 size
= bfd_get_section_size (s
);
5136 continue; /* skip zero-length section */
5138 sectname
= bfd_get_section_name (exec_bfd
, s
);
5139 if (args
&& strcmp (args
, sectname
) != 0)
5140 continue; /* not the section selected by user */
5142 matched
= 1; /* do this section */
5144 /* FIXME: assumes lma can fit into long. */
5145 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5146 (long) lma
, (long) size
);
5149 /* Be clever; compute the host_crc before waiting for target
5151 sectdata
= xmalloc (size
);
5152 old_chain
= make_cleanup (xfree
, sectdata
);
5153 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5154 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5156 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5157 if (rs
->buf
[0] == 'E')
5158 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5159 sectname
, paddr (lma
), paddr (lma
+ size
));
5160 if (rs
->buf
[0] != 'C')
5161 error (_("remote target does not support this operation"));
5163 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5164 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5166 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5167 sectname
, paddr (lma
), paddr (lma
+ size
));
5168 if (host_crc
== target_crc
)
5169 printf_filtered ("matched.\n");
5172 printf_filtered ("MIS-MATCHED!\n");
5176 do_cleanups (old_chain
);
5179 warning (_("One or more sections of the remote executable does not match\n\
5180 the loaded file\n"));
5181 if (args
&& !matched
)
5182 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5185 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5186 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5187 number of bytes read is returned, or 0 for EOF, or -1 for error.
5188 The number of bytes read may be less than LEN without indicating an
5189 EOF. PACKET is checked and updated to indicate whether the remote
5190 target supports this object. */
5193 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5195 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5196 struct packet_config
*packet
)
5198 static char *finished_object
;
5199 static char *finished_annex
;
5200 static ULONGEST finished_offset
;
5202 struct remote_state
*rs
= get_remote_state ();
5203 unsigned int total
= 0;
5204 LONGEST i
, n
, packet_len
;
5206 if (packet
->support
== PACKET_DISABLE
)
5209 /* Check whether we've cached an end-of-object packet that matches
5211 if (finished_object
)
5213 if (strcmp (object_name
, finished_object
) == 0
5214 && strcmp (annex
? annex
: "", finished_annex
) == 0
5215 && offset
== finished_offset
)
5218 /* Otherwise, we're now reading something different. Discard
5220 xfree (finished_object
);
5221 xfree (finished_annex
);
5222 finished_object
= NULL
;
5223 finished_annex
= NULL
;
5226 /* Request only enough to fit in a single packet. The actual data
5227 may not, since we don't know how much of it will need to be escaped;
5228 the target is free to respond with slightly less data. We subtract
5229 five to account for the response type and the protocol frame. */
5230 n
= min (get_remote_packet_size () - 5, len
);
5231 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5232 object_name
, annex
? annex
: "",
5233 phex_nz (offset
, sizeof offset
),
5234 phex_nz (n
, sizeof n
));
5235 i
= putpkt (rs
->buf
);
5240 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5241 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5244 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5245 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5247 /* 'm' means there is (or at least might be) more data after this
5248 batch. That does not make sense unless there's at least one byte
5249 of data in this reply. */
5250 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5251 error (_("Remote qXfer reply contained no data."));
5253 /* Got some data. */
5254 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5256 /* 'l' is an EOF marker, possibly including a final block of data,
5257 or possibly empty. Record it to bypass the next read, if one is
5259 if (rs
->buf
[0] == 'l')
5261 finished_object
= xstrdup (object_name
);
5262 finished_annex
= xstrdup (annex
? annex
: "");
5263 finished_offset
= offset
+ i
;
5270 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5271 const char *annex
, gdb_byte
*readbuf
,
5272 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5274 struct remote_state
*rs
= get_remote_state ();
5279 /* Handle memory using the standard memory routines. */
5280 if (object
== TARGET_OBJECT_MEMORY
)
5285 if (writebuf
!= NULL
)
5286 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5288 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5292 else if (xfered
== 0 && errno
== 0)
5298 /* Only handle reads. */
5299 if (writebuf
!= NULL
|| readbuf
== NULL
)
5302 /* Map pre-existing objects onto letters. DO NOT do this for new
5303 objects!!! Instead specify new query packets. */
5306 case TARGET_OBJECT_AVR
:
5310 case TARGET_OBJECT_AUXV
:
5311 gdb_assert (annex
== NULL
);
5312 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5313 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5319 /* Note: a zero OFFSET and LEN can be used to query the minimum
5321 if (offset
== 0 && len
== 0)
5322 return (get_remote_packet_size ());
5323 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5324 large enough let the caller deal with it. */
5325 if (len
< get_remote_packet_size ())
5327 len
= get_remote_packet_size ();
5329 /* Except for querying the minimum buffer size, target must be open. */
5331 error (_("remote query is only available after target open"));
5333 gdb_assert (annex
!= NULL
);
5334 gdb_assert (readbuf
!= NULL
);
5340 /* We used one buffer char for the remote protocol q command and
5341 another for the query type. As the remote protocol encapsulation
5342 uses 4 chars plus one extra in case we are debugging
5343 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5346 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5348 /* Bad caller may have sent forbidden characters. */
5349 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5354 gdb_assert (annex
[i
] == '\0');
5356 i
= putpkt (rs
->buf
);
5360 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5361 strcpy ((char *) readbuf
, rs
->buf
);
5363 return strlen ((char *) readbuf
);
5367 remote_rcmd (char *command
,
5368 struct ui_file
*outbuf
)
5370 struct remote_state
*rs
= get_remote_state ();
5374 error (_("remote rcmd is only available after target open"));
5376 /* Send a NULL command across as an empty command. */
5377 if (command
== NULL
)
5380 /* The query prefix. */
5381 strcpy (rs
->buf
, "qRcmd,");
5382 p
= strchr (rs
->buf
, '\0');
5384 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5385 error (_("\"monitor\" command ``%s'' is too long."), command
);
5387 /* Encode the actual command. */
5388 bin2hex ((gdb_byte
*) command
, p
, 0);
5390 if (putpkt (rs
->buf
) < 0)
5391 error (_("Communication problem with target."));
5393 /* get/display the response */
5398 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5400 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5403 error (_("Target does not support this command."));
5404 if (buf
[0] == 'O' && buf
[1] != 'K')
5406 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5409 if (strcmp (buf
, "OK") == 0)
5411 if (strlen (buf
) == 3 && buf
[0] == 'E'
5412 && isdigit (buf
[1]) && isdigit (buf
[2]))
5414 error (_("Protocol error with Rcmd"));
5416 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5418 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5419 fputc_unfiltered (c
, outbuf
);
5426 packet_command (char *args
, int from_tty
)
5428 struct remote_state
*rs
= get_remote_state ();
5431 error (_("command can only be used with remote target"));
5434 error (_("remote-packet command requires packet text as argument"));
5436 puts_filtered ("sending: ");
5437 print_packet (args
);
5438 puts_filtered ("\n");
5441 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5442 puts_filtered ("received: ");
5443 print_packet (rs
->buf
);
5444 puts_filtered ("\n");
5448 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5450 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5452 static void threadset_test_cmd (char *cmd
, int tty
);
5454 static void threadalive_test (char *cmd
, int tty
);
5456 static void threadlist_test_cmd (char *cmd
, int tty
);
5458 int get_and_display_threadinfo (threadref
*ref
);
5460 static void threadinfo_test_cmd (char *cmd
, int tty
);
5462 static int thread_display_step (threadref
*ref
, void *context
);
5464 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5466 static void init_remote_threadtests (void);
5468 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5471 threadset_test_cmd (char *cmd
, int tty
)
5473 int sample_thread
= SAMPLE_THREAD
;
5475 printf_filtered (_("Remote threadset test\n"));
5476 set_thread (sample_thread
, 1);
5481 threadalive_test (char *cmd
, int tty
)
5483 int sample_thread
= SAMPLE_THREAD
;
5485 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5486 printf_filtered ("PASS: Thread alive test\n");
5488 printf_filtered ("FAIL: Thread alive test\n");
5491 void output_threadid (char *title
, threadref
*ref
);
5494 output_threadid (char *title
, threadref
*ref
)
5498 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
5500 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
5504 threadlist_test_cmd (char *cmd
, int tty
)
5507 threadref nextthread
;
5508 int done
, result_count
;
5509 threadref threadlist
[3];
5511 printf_filtered ("Remote Threadlist test\n");
5512 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
5513 &result_count
, &threadlist
[0]))
5514 printf_filtered ("FAIL: threadlist test\n");
5517 threadref
*scan
= threadlist
;
5518 threadref
*limit
= scan
+ result_count
;
5520 while (scan
< limit
)
5521 output_threadid (" thread ", scan
++);
5526 display_thread_info (struct gdb_ext_thread_info
*info
)
5528 output_threadid ("Threadid: ", &info
->threadid
);
5529 printf_filtered ("Name: %s\n ", info
->shortname
);
5530 printf_filtered ("State: %s\n", info
->display
);
5531 printf_filtered ("other: %s\n\n", info
->more_display
);
5535 get_and_display_threadinfo (threadref
*ref
)
5539 struct gdb_ext_thread_info threadinfo
;
5541 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
5542 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
5543 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
5544 display_thread_info (&threadinfo
);
5549 threadinfo_test_cmd (char *cmd
, int tty
)
5551 int athread
= SAMPLE_THREAD
;
5555 int_to_threadref (&thread
, athread
);
5556 printf_filtered ("Remote Threadinfo test\n");
5557 if (!get_and_display_threadinfo (&thread
))
5558 printf_filtered ("FAIL cannot get thread info\n");
5562 thread_display_step (threadref
*ref
, void *context
)
5564 /* output_threadid(" threadstep ",ref); *//* simple test */
5565 return get_and_display_threadinfo (ref
);
5569 threadlist_update_test_cmd (char *cmd
, int tty
)
5571 printf_filtered ("Remote Threadlist update test\n");
5572 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
5576 init_remote_threadtests (void)
5578 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
5579 Fetch and print the remote list of thread identifiers, one pkt only"));
5580 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
5581 _("Fetch and display info about one thread"));
5582 add_com ("tset", class_obscure
, threadset_test_cmd
,
5583 _("Test setting to a different thread"));
5584 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
5585 _("Iterate through updating all remote thread info"));
5586 add_com ("talive", class_obscure
, threadalive_test
,
5587 _(" Remote thread alive test "));
5592 /* Convert a thread ID to a string. Returns the string in a static
5596 remote_pid_to_str (ptid_t ptid
)
5598 static char buf
[32];
5600 xsnprintf (buf
, sizeof buf
, "thread %d", ptid_get_pid (ptid
));
5604 /* Get the address of the thread local variable in OBJFILE which is
5605 stored at OFFSET within the thread local storage for thread PTID. */
5608 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
5610 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
5612 struct remote_state
*rs
= get_remote_state ();
5614 enum packet_result result
;
5616 strcpy (p
, "qGetTLSAddr:");
5618 p
+= hexnumstr (p
, PIDGET (ptid
));
5620 p
+= hexnumstr (p
, offset
);
5622 p
+= hexnumstr (p
, lm
);
5626 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5627 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
5628 if (result
== PACKET_OK
)
5632 unpack_varlen_hex (rs
->buf
, &result
);
5635 else if (result
== PACKET_UNKNOWN
)
5636 throw_error (TLS_GENERIC_ERROR
,
5637 _("Remote target doesn't support qGetTLSAddr packet"));
5639 throw_error (TLS_GENERIC_ERROR
,
5640 _("Remote target failed to process qGetTLSAddr request"));
5643 throw_error (TLS_GENERIC_ERROR
,
5644 _("TLS not supported or disabled on this target"));
5650 init_remote_ops (void)
5652 remote_ops
.to_shortname
= "remote";
5653 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
5655 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5656 Specify the serial device it is connected to\n\
5657 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
5658 remote_ops
.to_open
= remote_open
;
5659 remote_ops
.to_close
= remote_close
;
5660 remote_ops
.to_detach
= remote_detach
;
5661 remote_ops
.to_disconnect
= remote_disconnect
;
5662 remote_ops
.to_resume
= remote_resume
;
5663 remote_ops
.to_wait
= remote_wait
;
5664 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
5665 remote_ops
.to_store_registers
= remote_store_registers
;
5666 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
5667 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
5668 remote_ops
.to_files_info
= remote_files_info
;
5669 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
5670 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
5671 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
5672 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
5673 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
5674 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
5675 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
5676 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
5677 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
5678 remote_ops
.to_kill
= remote_kill
;
5679 remote_ops
.to_load
= generic_load
;
5680 remote_ops
.to_mourn_inferior
= remote_mourn
;
5681 remote_ops
.to_thread_alive
= remote_thread_alive
;
5682 remote_ops
.to_find_new_threads
= remote_threads_info
;
5683 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
5684 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
5685 remote_ops
.to_stop
= remote_stop
;
5686 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
5687 remote_ops
.to_rcmd
= remote_rcmd
;
5688 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
5689 remote_ops
.to_stratum
= process_stratum
;
5690 remote_ops
.to_has_all_memory
= 1;
5691 remote_ops
.to_has_memory
= 1;
5692 remote_ops
.to_has_stack
= 1;
5693 remote_ops
.to_has_registers
= 1;
5694 remote_ops
.to_has_execution
= 1;
5695 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
5696 remote_ops
.to_magic
= OPS_MAGIC
;
5699 /* Set up the extended remote vector by making a copy of the standard
5700 remote vector and adding to it. */
5703 init_extended_remote_ops (void)
5705 extended_remote_ops
= remote_ops
;
5707 extended_remote_ops
.to_shortname
= "extended-remote";
5708 extended_remote_ops
.to_longname
=
5709 "Extended remote serial target in gdb-specific protocol";
5710 extended_remote_ops
.to_doc
=
5711 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5712 Specify the serial device it is connected to (e.g. /dev/ttya).",
5713 extended_remote_ops
.to_open
= extended_remote_open
;
5714 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
5715 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
5719 remote_can_async_p (void)
5721 /* We're async whenever the serial device is. */
5722 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
5726 remote_is_async_p (void)
5728 /* We're async whenever the serial device is. */
5729 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
5732 /* Pass the SERIAL event on and up to the client. One day this code
5733 will be able to delay notifying the client of an event until the
5734 point where an entire packet has been received. */
5736 static void (*async_client_callback
) (enum inferior_event_type event_type
,
5738 static void *async_client_context
;
5739 static serial_event_ftype remote_async_serial_handler
;
5742 remote_async_serial_handler (struct serial
*scb
, void *context
)
5744 /* Don't propogate error information up to the client. Instead let
5745 the client find out about the error by querying the target. */
5746 async_client_callback (INF_REG_EVENT
, async_client_context
);
5750 remote_async (void (*callback
) (enum inferior_event_type event_type
,
5751 void *context
), void *context
)
5753 if (current_target
.to_async_mask_value
== 0)
5754 internal_error (__FILE__
, __LINE__
,
5755 _("Calling remote_async when async is masked"));
5757 if (callback
!= NULL
)
5759 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
5760 async_client_callback
= callback
;
5761 async_client_context
= context
;
5764 serial_async (remote_desc
, NULL
, NULL
);
5767 /* Target async and target extended-async.
5769 This are temporary targets, until it is all tested. Eventually
5770 async support will be incorporated int the usual 'remote'
5774 init_remote_async_ops (void)
5776 remote_async_ops
.to_shortname
= "async";
5777 remote_async_ops
.to_longname
=
5778 "Remote serial target in async version of the gdb-specific protocol";
5779 remote_async_ops
.to_doc
=
5780 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5781 Specify the serial device it is connected to (e.g. /dev/ttya).";
5782 remote_async_ops
.to_open
= remote_async_open
;
5783 remote_async_ops
.to_close
= remote_close
;
5784 remote_async_ops
.to_detach
= remote_detach
;
5785 remote_async_ops
.to_disconnect
= remote_disconnect
;
5786 remote_async_ops
.to_resume
= remote_async_resume
;
5787 remote_async_ops
.to_wait
= remote_async_wait
;
5788 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
5789 remote_async_ops
.to_store_registers
= remote_store_registers
;
5790 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
5791 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
5792 remote_async_ops
.to_files_info
= remote_files_info
;
5793 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
5794 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
5795 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
5796 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
5797 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
5798 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
5799 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
5800 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
5801 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
5802 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
5803 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
5804 remote_async_ops
.to_kill
= remote_async_kill
;
5805 remote_async_ops
.to_load
= generic_load
;
5806 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
5807 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
5808 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
5809 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
5810 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
5811 remote_async_ops
.to_stop
= remote_stop
;
5812 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
5813 remote_async_ops
.to_rcmd
= remote_rcmd
;
5814 remote_async_ops
.to_stratum
= process_stratum
;
5815 remote_async_ops
.to_has_all_memory
= 1;
5816 remote_async_ops
.to_has_memory
= 1;
5817 remote_async_ops
.to_has_stack
= 1;
5818 remote_async_ops
.to_has_registers
= 1;
5819 remote_async_ops
.to_has_execution
= 1;
5820 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
5821 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
5822 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
5823 remote_async_ops
.to_async
= remote_async
;
5824 remote_async_ops
.to_async_mask_value
= 1;
5825 remote_async_ops
.to_magic
= OPS_MAGIC
;
5828 /* Set up the async extended remote vector by making a copy of the standard
5829 remote vector and adding to it. */
5832 init_extended_async_remote_ops (void)
5834 extended_async_remote_ops
= remote_async_ops
;
5836 extended_async_remote_ops
.to_shortname
= "extended-async";
5837 extended_async_remote_ops
.to_longname
=
5838 "Extended remote serial target in async gdb-specific protocol";
5839 extended_async_remote_ops
.to_doc
=
5840 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
5841 Specify the serial device it is connected to (e.g. /dev/ttya).",
5842 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
5843 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
5844 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
5848 set_remote_cmd (char *args
, int from_tty
)
5853 show_remote_cmd (char *args
, int from_tty
)
5855 /* We can't just use cmd_show_list here, because we want to skip
5856 the redundant "show remote Z-packet". */
5857 struct cleanup
*showlist_chain
;
5858 struct cmd_list_element
*list
= remote_show_cmdlist
;
5860 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
5861 for (; list
!= NULL
; list
= list
->next
)
5862 if (strcmp (list
->name
, "Z-packet") == 0)
5864 else if (list
->type
== show_cmd
)
5866 struct cleanup
*option_chain
5867 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
5868 ui_out_field_string (uiout
, "name", list
->name
);
5869 ui_out_text (uiout
, ": ");
5870 do_setshow_command ((char *) NULL
, from_tty
, list
);
5871 /* Close the tuple. */
5872 do_cleanups (option_chain
);
5877 build_remote_gdbarch_data (void)
5879 remote_address_size
= TARGET_ADDR_BIT
;
5882 /* Saved pointer to previous owner of the new_objfile event. */
5883 static void (*remote_new_objfile_chain
) (struct objfile
*);
5885 /* Function to be called whenever a new objfile (shlib) is detected. */
5887 remote_new_objfile (struct objfile
*objfile
)
5889 if (remote_desc
!= 0) /* Have a remote connection. */
5891 remote_check_symbols (objfile
);
5893 /* Call predecessor on chain, if any. */
5894 if (remote_new_objfile_chain
!= 0 &&
5896 remote_new_objfile_chain (objfile
);
5900 _initialize_remote (void)
5902 struct remote_state
*rs
;
5904 /* architecture specific data */
5905 remote_gdbarch_data_handle
=
5906 gdbarch_data_register_post_init (init_remote_state
);
5908 /* Old tacky stuff. NOTE: This comes after the remote protocol so
5909 that the remote protocol has been initialized. */
5910 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size
);
5911 deprecated_register_gdbarch_swap (NULL
, 0, build_remote_gdbarch_data
);
5913 /* Initialize the per-target state. At the moment there is only one
5914 of these, not one per target. Only one target is active at a
5915 time. The default buffer size is unimportant; it will be expanded
5916 whenever a larger buffer is needed. */
5917 rs
= get_remote_state ();
5919 rs
->buf
= xmalloc (rs
->buf_size
);
5922 add_target (&remote_ops
);
5924 init_extended_remote_ops ();
5925 add_target (&extended_remote_ops
);
5927 init_remote_async_ops ();
5928 add_target (&remote_async_ops
);
5930 init_extended_async_remote_ops ();
5931 add_target (&extended_async_remote_ops
);
5933 /* Hook into new objfile notification. */
5934 remote_new_objfile_chain
= deprecated_target_new_objfile_hook
;
5935 deprecated_target_new_objfile_hook
= remote_new_objfile
;
5938 init_remote_threadtests ();
5941 /* set/show remote ... */
5943 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
5944 Remote protocol specific variables\n\
5945 Configure various remote-protocol specific variables such as\n\
5946 the packets being used"),
5947 &remote_set_cmdlist
, "set remote ",
5948 0 /* allow-unknown */, &setlist
);
5949 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
5950 Remote protocol specific variables\n\
5951 Configure various remote-protocol specific variables such as\n\
5952 the packets being used"),
5953 &remote_show_cmdlist
, "show remote ",
5954 0 /* allow-unknown */, &showlist
);
5956 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
5957 Compare section data on target to the exec file.\n\
5958 Argument is a single section name (default: all loaded sections)."),
5961 add_cmd ("packet", class_maintenance
, packet_command
, _("\
5962 Send an arbitrary packet to a remote target.\n\
5963 maintenance packet TEXT\n\
5964 If GDB is talking to an inferior via the GDB serial protocol, then\n\
5965 this command sends the string TEXT to the inferior, and displays the\n\
5966 response packet. GDB supplies the initial `$' character, and the\n\
5967 terminating `#' character and checksum."),
5970 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
5971 Set whether to send break if interrupted."), _("\
5972 Show whether to send break if interrupted."), _("\
5973 If set, a break, instead of a cntrl-c, is sent to the remote target."),
5974 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
5975 &setlist
, &showlist
);
5977 /* Install commands for configuring memory read/write packets. */
5979 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
5980 Set the maximum number of bytes per memory write packet (deprecated)."),
5982 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
5983 Show the maximum number of bytes per memory write packet (deprecated)."),
5985 add_cmd ("memory-write-packet-size", no_class
,
5986 set_memory_write_packet_size
, _("\
5987 Set the maximum number of bytes per memory-write packet.\n\
5988 Specify the number of bytes in a packet or 0 (zero) for the\n\
5989 default packet size. The actual limit is further reduced\n\
5990 dependent on the target. Specify ``fixed'' to disable the\n\
5991 further restriction and ``limit'' to enable that restriction."),
5992 &remote_set_cmdlist
);
5993 add_cmd ("memory-read-packet-size", no_class
,
5994 set_memory_read_packet_size
, _("\
5995 Set the maximum number of bytes per memory-read packet.\n\
5996 Specify the number of bytes in a packet or 0 (zero) for the\n\
5997 default packet size. The actual limit is further reduced\n\
5998 dependent on the target. Specify ``fixed'' to disable the\n\
5999 further restriction and ``limit'' to enable that restriction."),
6000 &remote_set_cmdlist
);
6001 add_cmd ("memory-write-packet-size", no_class
,
6002 show_memory_write_packet_size
,
6003 _("Show the maximum number of bytes per memory-write packet."),
6004 &remote_show_cmdlist
);
6005 add_cmd ("memory-read-packet-size", no_class
,
6006 show_memory_read_packet_size
,
6007 _("Show the maximum number of bytes per memory-read packet."),
6008 &remote_show_cmdlist
);
6010 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6011 &remote_hw_watchpoint_limit
, _("\
6012 Set the maximum number of target hardware watchpoints."), _("\
6013 Show the maximum number of target hardware watchpoints."), _("\
6014 Specify a negative limit for unlimited."),
6015 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6016 &remote_set_cmdlist
, &remote_show_cmdlist
);
6017 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6018 &remote_hw_breakpoint_limit
, _("\
6019 Set the maximum number of target hardware breakpoints."), _("\
6020 Show the maximum number of target hardware breakpoints."), _("\
6021 Specify a negative limit for unlimited."),
6022 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6023 &remote_set_cmdlist
, &remote_show_cmdlist
);
6025 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6026 &remote_address_size
, _("\
6027 Set the maximum size of the address (in bits) in a memory packet."), _("\
6028 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6030 NULL
, /* FIXME: i18n: */
6031 &setlist
, &showlist
);
6033 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6034 "X", "binary-download", 1);
6036 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6037 "vCont", "verbose-resume", 0);
6039 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6040 "qSymbol", "symbol-lookup", 0);
6042 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6043 "P", "set-register", 1);
6045 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6046 "p", "fetch-register", 1);
6048 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6049 "Z0", "software-breakpoint", 0);
6051 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6052 "Z1", "hardware-breakpoint", 0);
6054 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6055 "Z2", "write-watchpoint", 0);
6057 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6058 "Z3", "read-watchpoint", 0);
6060 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6061 "Z4", "access-watchpoint", 0);
6063 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6064 "qXfer:auxv:read", "read-aux-vector", 0);
6066 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6067 "qGetTLSAddr", "get-thread-local-storage-address",
6070 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6071 "qSupported", "supported-packets", 0);
6073 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6074 Z sub-packet has its own set and show commands, but users may
6075 have sets to this variable in their .gdbinit files (or in their
6077 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6078 &remote_Z_packet_detect
, _("\
6079 Set use of remote protocol `Z' packets"), _("\
6080 Show use of remote protocol `Z' packets "), _("\
6081 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6083 set_remote_protocol_Z_packet_cmd
,
6084 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6085 &remote_set_cmdlist
, &remote_show_cmdlist
);
6087 /* Eventually initialize fileio. See fileio.c */
6088 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);