1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* See the GDB User Guide for details of the GDB remote protocol. */
25 #include "gdb_string.h"
31 #include "exceptions.h"
33 /*#include "terminal.h" */
36 #include "gdb-stabs.h"
37 #include "gdbthread.h"
41 #include "gdb_assert.h"
44 #include "cli/cli-decode.h"
45 #include "cli/cli-setshow.h"
46 #include "target-descriptions.h"
51 #include "event-loop.h"
52 #include "event-top.h"
58 #include "gdbcore.h" /* for exec_bfd */
60 #include "remote-fileio.h"
62 #include "memory-map.h"
64 /* The size to align memory write packets, when practical. The protocol
65 does not guarantee any alignment, and gdb will generate short
66 writes and unaligned writes, but even as a best-effort attempt this
67 can improve bulk transfers. For instance, if a write is misaligned
68 relative to the target's data bus, the stub may need to make an extra
69 round trip fetching data from the target. This doesn't make a
70 huge difference, but it's easy to do, so we try to be helpful.
72 The alignment chosen is arbitrary; usually data bus width is
73 important here, not the possibly larger cache line size. */
74 enum { REMOTE_ALIGN_WRITES
= 16 };
76 /* Prototypes for local functions. */
77 static void cleanup_sigint_signal_handler (void *dummy
);
78 static void initialize_sigint_signal_handler (void);
79 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
81 static void handle_remote_sigint (int);
82 static void handle_remote_sigint_twice (int);
83 static void async_remote_interrupt (gdb_client_data
);
84 void async_remote_interrupt_twice (gdb_client_data
);
86 static void remote_files_info (struct target_ops
*ignore
);
88 static void remote_prepare_to_store (struct regcache
*regcache
);
90 static void remote_fetch_registers (struct regcache
*regcache
, int regno
);
92 static void remote_resume (ptid_t ptid
, int step
,
93 enum target_signal siggnal
);
94 static void remote_async_resume (ptid_t ptid
, int step
,
95 enum target_signal siggnal
);
96 static void remote_open (char *name
, int from_tty
);
97 static void remote_async_open (char *name
, int from_tty
);
99 static void extended_remote_open (char *name
, int from_tty
);
100 static void extended_remote_async_open (char *name
, int from_tty
);
102 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
,
105 static void remote_close (int quitting
);
107 static void remote_store_registers (struct regcache
*regcache
, int regno
);
109 static void remote_mourn (void);
110 static void remote_async_mourn (void);
112 static void extended_remote_restart (void);
114 static void extended_remote_mourn (void);
116 static void remote_mourn_1 (struct target_ops
*);
118 static void remote_send (char **buf
, long *sizeof_buf_p
);
120 static int readchar (int timeout
);
122 static ptid_t
remote_wait (ptid_t ptid
,
123 struct target_waitstatus
*status
);
124 static ptid_t
remote_async_wait (ptid_t ptid
,
125 struct target_waitstatus
*status
);
127 static void remote_kill (void);
128 static void remote_async_kill (void);
130 static int tohex (int nib
);
132 static void remote_detach (char *args
, int from_tty
);
134 static void remote_interrupt (int signo
);
136 static void remote_interrupt_twice (int signo
);
138 static void interrupt_query (void);
140 static void set_thread (int, int);
142 static int remote_thread_alive (ptid_t
);
144 static void get_offsets (void);
146 static void skip_frame (void);
148 static long read_frame (char **buf_p
, long *sizeof_buf
);
150 static int hexnumlen (ULONGEST num
);
152 static void init_remote_ops (void);
154 static void init_extended_remote_ops (void);
156 static void remote_stop (void);
158 static int ishex (int ch
, int *val
);
160 static int stubhex (int ch
);
162 static int hexnumstr (char *, ULONGEST
);
164 static int hexnumnstr (char *, ULONGEST
, int);
166 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
168 static void print_packet (char *);
170 static unsigned long crc32 (unsigned char *, int, unsigned int);
172 static void compare_sections_command (char *, int);
174 static void packet_command (char *, int);
176 static int stub_unpack_int (char *buff
, int fieldlength
);
178 static ptid_t
remote_current_thread (ptid_t oldptid
);
180 static void remote_find_new_threads (void);
182 static void record_currthread (int currthread
);
184 static int fromhex (int a
);
186 static int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
188 static int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
190 static int putpkt_binary (char *buf
, int cnt
);
192 static void check_binary_download (CORE_ADDR addr
);
194 struct packet_config
;
196 static void show_packet_config_cmd (struct packet_config
*config
);
198 static void update_packet_config (struct packet_config
*config
);
200 static void set_remote_protocol_packet_cmd (char *args
, int from_tty
,
201 struct cmd_list_element
*c
);
203 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
205 struct cmd_list_element
*c
,
208 void _initialize_remote (void);
210 /* For "set remote" and "show remote". */
212 static struct cmd_list_element
*remote_set_cmdlist
;
213 static struct cmd_list_element
*remote_show_cmdlist
;
215 /* Description of the remote protocol state for the currently
216 connected target. This is per-target state, and independent of the
217 selected architecture. */
221 /* A buffer to use for incoming packets, and its current size. The
222 buffer is grown dynamically for larger incoming packets.
223 Outgoing packets may also be constructed in this buffer.
224 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
225 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
230 /* If we negotiated packet size explicitly (and thus can bypass
231 heuristics for the largest packet size that will not overflow
232 a buffer in the stub), this will be set to that packet size.
233 Otherwise zero, meaning to use the guessed size. */
234 long explicit_packet_size
;
237 /* This data could be associated with a target, but we do not always
238 have access to the current target when we need it, so for now it is
239 static. This will be fine for as long as only one target is in use
241 static struct remote_state remote_state
;
243 static struct remote_state
*
244 get_remote_state_raw (void)
246 return &remote_state
;
249 /* Description of the remote protocol for a given architecture. */
253 long offset
; /* Offset into G packet. */
254 long regnum
; /* GDB's internal register number. */
255 LONGEST pnum
; /* Remote protocol register number. */
256 int in_g_packet
; /* Always part of G packet. */
257 /* long size in bytes; == register_size (current_gdbarch, regnum);
259 /* char *name; == gdbarch_register_name (current_gdbarch, regnum);
263 struct remote_arch_state
265 /* Description of the remote protocol registers. */
266 long sizeof_g_packet
;
268 /* Description of the remote protocol registers indexed by REGNUM
269 (making an array gdbarch_num_regs in size). */
270 struct packet_reg
*regs
;
272 /* This is the size (in chars) of the first response to the ``g''
273 packet. It is used as a heuristic when determining the maximum
274 size of memory-read and memory-write packets. A target will
275 typically only reserve a buffer large enough to hold the ``g''
276 packet. The size does not include packet overhead (headers and
278 long actual_register_packet_size
;
280 /* This is the maximum size (in chars) of a non read/write packet.
281 It is also used as a cap on the size of read/write packets. */
282 long remote_packet_size
;
286 /* Handle for retreving the remote protocol data from gdbarch. */
287 static struct gdbarch_data
*remote_gdbarch_data_handle
;
289 static struct remote_arch_state
*
290 get_remote_arch_state (void)
292 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
295 /* Fetch the global remote target state. */
297 static struct remote_state
*
298 get_remote_state (void)
300 /* Make sure that the remote architecture state has been
301 initialized, because doing so might reallocate rs->buf. Any
302 function which calls getpkt also needs to be mindful of changes
303 to rs->buf, but this call limits the number of places which run
305 get_remote_arch_state ();
307 return get_remote_state_raw ();
311 compare_pnums (const void *lhs_
, const void *rhs_
)
313 const struct packet_reg
* const *lhs
= lhs_
;
314 const struct packet_reg
* const *rhs
= rhs_
;
316 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
318 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
325 init_remote_state (struct gdbarch
*gdbarch
)
327 int regnum
, num_remote_regs
, offset
;
328 struct remote_state
*rs
= get_remote_state_raw ();
329 struct remote_arch_state
*rsa
;
330 struct packet_reg
**remote_regs
;
332 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
334 /* Use the architecture to build a regnum<->pnum table, which will be
335 1:1 unless a feature set specifies otherwise. */
336 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
337 gdbarch_num_regs (gdbarch
),
339 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
341 struct packet_reg
*r
= &rsa
->regs
[regnum
];
343 if (register_size (gdbarch
, regnum
) == 0)
344 /* Do not try to fetch zero-sized (placeholder) registers. */
347 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
352 /* Define the g/G packet format as the contents of each register
353 with a remote protocol number, in order of ascending protocol
356 remote_regs
= alloca (gdbarch_num_regs (gdbarch
)
357 * sizeof (struct packet_reg
*));
358 for (num_remote_regs
= 0, regnum
= 0;
359 regnum
< gdbarch_num_regs (gdbarch
);
361 if (rsa
->regs
[regnum
].pnum
!= -1)
362 remote_regs
[num_remote_regs
++] = &rsa
->regs
[regnum
];
364 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
367 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
369 remote_regs
[regnum
]->in_g_packet
= 1;
370 remote_regs
[regnum
]->offset
= offset
;
371 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
374 /* Record the maximum possible size of the g packet - it may turn out
376 rsa
->sizeof_g_packet
= offset
;
378 /* Default maximum number of characters in a packet body. Many
379 remote stubs have a hardwired buffer size of 400 bytes
380 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
381 as the maximum packet-size to ensure that the packet and an extra
382 NUL character can always fit in the buffer. This stops GDB
383 trashing stubs that try to squeeze an extra NUL into what is
384 already a full buffer (As of 1999-12-04 that was most stubs). */
385 rsa
->remote_packet_size
= 400 - 1;
387 /* This one is filled in when a ``g'' packet is received. */
388 rsa
->actual_register_packet_size
= 0;
390 /* Should rsa->sizeof_g_packet needs more space than the
391 default, adjust the size accordingly. Remember that each byte is
392 encoded as two characters. 32 is the overhead for the packet
393 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
394 (``$NN:G...#NN'') is a better guess, the below has been padded a
396 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
397 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
399 /* Make sure that the packet buffer is plenty big enough for
400 this architecture. */
401 if (rs
->buf_size
< rsa
->remote_packet_size
)
403 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
404 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
410 /* Return the current allowed size of a remote packet. This is
411 inferred from the current architecture, and should be used to
412 limit the length of outgoing packets. */
414 get_remote_packet_size (void)
416 struct remote_state
*rs
= get_remote_state ();
417 struct remote_arch_state
*rsa
= get_remote_arch_state ();
419 if (rs
->explicit_packet_size
)
420 return rs
->explicit_packet_size
;
422 return rsa
->remote_packet_size
;
425 static struct packet_reg
*
426 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
428 if (regnum
< 0 && regnum
>= gdbarch_num_regs (current_gdbarch
))
432 struct packet_reg
*r
= &rsa
->regs
[regnum
];
433 gdb_assert (r
->regnum
== regnum
);
438 static struct packet_reg
*
439 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
442 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
444 struct packet_reg
*r
= &rsa
->regs
[i
];
451 /* FIXME: graces/2002-08-08: These variables should eventually be
452 bound to an instance of the target object (as in gdbarch-tdep()),
453 when such a thing exists. */
455 /* This is set to the data address of the access causing the target
456 to stop for a watchpoint. */
457 static CORE_ADDR remote_watch_data_address
;
459 /* This is non-zero if target stopped for a watchpoint. */
460 static int remote_stopped_by_watchpoint_p
;
462 static struct target_ops remote_ops
;
464 static struct target_ops extended_remote_ops
;
466 /* Temporary target ops. Just like the remote_ops and
467 extended_remote_ops, but with asynchronous support. */
468 static struct target_ops remote_async_ops
;
470 static struct target_ops extended_async_remote_ops
;
472 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
473 ``forever'' still use the normal timeout mechanism. This is
474 currently used by the ASYNC code to guarentee that target reads
475 during the initial connect always time-out. Once getpkt has been
476 modified to return a timeout indication and, in turn
477 remote_wait()/wait_for_inferior() have gained a timeout parameter
479 static int wait_forever_enabled_p
= 1;
482 /* This variable chooses whether to send a ^C or a break when the user
483 requests program interruption. Although ^C is usually what remote
484 systems expect, and that is the default here, sometimes a break is
485 preferable instead. */
487 static int remote_break
;
489 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
490 remote_open knows that we don't have a file open when the program
492 static struct serial
*remote_desc
= NULL
;
494 /* This variable sets the number of bits in an address that are to be
495 sent in a memory ("M" or "m") packet. Normally, after stripping
496 leading zeros, the entire address would be sent. This variable
497 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
498 initial implementation of remote.c restricted the address sent in
499 memory packets to ``host::sizeof long'' bytes - (typically 32
500 bits). Consequently, for 64 bit targets, the upper 32 bits of an
501 address was never sent. Since fixing this bug may cause a break in
502 some remote targets this variable is principly provided to
503 facilitate backward compatibility. */
505 static int remote_address_size
;
507 /* Tempoary to track who currently owns the terminal. See
508 target_async_terminal_* for more details. */
510 static int remote_async_terminal_ours_p
;
513 /* User configurable variables for the number of characters in a
514 memory read/write packet. MIN (rsa->remote_packet_size,
515 rsa->sizeof_g_packet) is the default. Some targets need smaller
516 values (fifo overruns, et.al.) and some users need larger values
517 (speed up transfers). The variables ``preferred_*'' (the user
518 request), ``current_*'' (what was actually set) and ``forced_*''
519 (Positive - a soft limit, negative - a hard limit). */
521 struct memory_packet_config
528 /* Compute the current size of a read/write packet. Since this makes
529 use of ``actual_register_packet_size'' the computation is dynamic. */
532 get_memory_packet_size (struct memory_packet_config
*config
)
534 struct remote_state
*rs
= get_remote_state ();
535 struct remote_arch_state
*rsa
= get_remote_arch_state ();
537 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
538 law?) that some hosts don't cope very well with large alloca()
539 calls. Eventually the alloca() code will be replaced by calls to
540 xmalloc() and make_cleanups() allowing this restriction to either
541 be lifted or removed. */
542 #ifndef MAX_REMOTE_PACKET_SIZE
543 #define MAX_REMOTE_PACKET_SIZE 16384
545 /* NOTE: 20 ensures we can write at least one byte. */
546 #ifndef MIN_REMOTE_PACKET_SIZE
547 #define MIN_REMOTE_PACKET_SIZE 20
552 if (config
->size
<= 0)
553 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
555 what_they_get
= config
->size
;
559 what_they_get
= get_remote_packet_size ();
560 /* Limit the packet to the size specified by the user. */
562 && what_they_get
> config
->size
)
563 what_they_get
= config
->size
;
565 /* Limit it to the size of the targets ``g'' response unless we have
566 permission from the stub to use a larger packet size. */
567 if (rs
->explicit_packet_size
== 0
568 && rsa
->actual_register_packet_size
> 0
569 && what_they_get
> rsa
->actual_register_packet_size
)
570 what_they_get
= rsa
->actual_register_packet_size
;
572 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
573 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
574 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
575 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
577 /* Make sure there is room in the global buffer for this packet
578 (including its trailing NUL byte). */
579 if (rs
->buf_size
< what_they_get
+ 1)
581 rs
->buf_size
= 2 * what_they_get
;
582 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
585 return what_they_get
;
588 /* Update the size of a read/write packet. If they user wants
589 something really big then do a sanity check. */
592 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
594 int fixed_p
= config
->fixed_p
;
595 long size
= config
->size
;
597 error (_("Argument required (integer, `fixed' or `limited')."));
598 else if (strcmp (args
, "hard") == 0
599 || strcmp (args
, "fixed") == 0)
601 else if (strcmp (args
, "soft") == 0
602 || strcmp (args
, "limit") == 0)
607 size
= strtoul (args
, &end
, 0);
609 error (_("Invalid %s (bad syntax)."), config
->name
);
611 /* Instead of explicitly capping the size of a packet to
612 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
613 instead allowed to set the size to something arbitrarily
615 if (size
> MAX_REMOTE_PACKET_SIZE
)
616 error (_("Invalid %s (too large)."), config
->name
);
620 if (fixed_p
&& !config
->fixed_p
)
622 if (! query (_("The target may not be able to correctly handle a %s\n"
623 "of %ld bytes. Change the packet size? "),
625 error (_("Packet size not changed."));
627 /* Update the config. */
628 config
->fixed_p
= fixed_p
;
633 show_memory_packet_size (struct memory_packet_config
*config
)
635 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
637 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
638 get_memory_packet_size (config
));
640 printf_filtered (_("Packets are limited to %ld bytes.\n"),
641 get_memory_packet_size (config
));
644 static struct memory_packet_config memory_write_packet_config
=
646 "memory-write-packet-size",
650 set_memory_write_packet_size (char *args
, int from_tty
)
652 set_memory_packet_size (args
, &memory_write_packet_config
);
656 show_memory_write_packet_size (char *args
, int from_tty
)
658 show_memory_packet_size (&memory_write_packet_config
);
662 get_memory_write_packet_size (void)
664 return get_memory_packet_size (&memory_write_packet_config
);
667 static struct memory_packet_config memory_read_packet_config
=
669 "memory-read-packet-size",
673 set_memory_read_packet_size (char *args
, int from_tty
)
675 set_memory_packet_size (args
, &memory_read_packet_config
);
679 show_memory_read_packet_size (char *args
, int from_tty
)
681 show_memory_packet_size (&memory_read_packet_config
);
685 get_memory_read_packet_size (void)
687 long size
= get_memory_packet_size (&memory_read_packet_config
);
688 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
689 extra buffer size argument before the memory read size can be
690 increased beyond this. */
691 if (size
> get_remote_packet_size ())
692 size
= get_remote_packet_size ();
697 /* Generic configuration support for packets the stub optionally
698 supports. Allows the user to specify the use of the packet as well
699 as allowing GDB to auto-detect support in the remote stub. */
703 PACKET_SUPPORT_UNKNOWN
= 0,
712 enum auto_boolean detect
;
713 enum packet_support support
;
716 /* Analyze a packet's return value and update the packet config
727 update_packet_config (struct packet_config
*config
)
729 switch (config
->detect
)
731 case AUTO_BOOLEAN_TRUE
:
732 config
->support
= PACKET_ENABLE
;
734 case AUTO_BOOLEAN_FALSE
:
735 config
->support
= PACKET_DISABLE
;
737 case AUTO_BOOLEAN_AUTO
:
738 config
->support
= PACKET_SUPPORT_UNKNOWN
;
744 show_packet_config_cmd (struct packet_config
*config
)
746 char *support
= "internal-error";
747 switch (config
->support
)
753 support
= "disabled";
755 case PACKET_SUPPORT_UNKNOWN
:
759 switch (config
->detect
)
761 case AUTO_BOOLEAN_AUTO
:
762 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
763 config
->name
, support
);
765 case AUTO_BOOLEAN_TRUE
:
766 case AUTO_BOOLEAN_FALSE
:
767 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
768 config
->name
, support
);
774 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
775 const char *title
, int legacy
)
782 config
->title
= title
;
783 config
->detect
= AUTO_BOOLEAN_AUTO
;
784 config
->support
= PACKET_SUPPORT_UNKNOWN
;
785 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
787 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
789 /* set/show TITLE-packet {auto,on,off} */
790 cmd_name
= xstrprintf ("%s-packet", title
);
791 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
792 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
793 set_remote_protocol_packet_cmd
,
794 show_remote_protocol_packet_cmd
,
795 &remote_set_cmdlist
, &remote_show_cmdlist
);
796 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
800 legacy_name
= xstrprintf ("%s-packet", name
);
801 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
802 &remote_set_cmdlist
);
803 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
804 &remote_show_cmdlist
);
808 static enum packet_result
809 packet_check_result (const char *buf
)
813 /* The stub recognized the packet request. Check that the
814 operation succeeded. */
816 && isxdigit (buf
[1]) && isxdigit (buf
[2])
818 /* "Enn" - definitly an error. */
821 /* Always treat "E." as an error. This will be used for
822 more verbose error messages, such as E.memtypes. */
823 if (buf
[0] == 'E' && buf
[1] == '.')
826 /* The packet may or may not be OK. Just assume it is. */
830 /* The stub does not support the packet. */
831 return PACKET_UNKNOWN
;
834 static enum packet_result
835 packet_ok (const char *buf
, struct packet_config
*config
)
837 enum packet_result result
;
839 result
= packet_check_result (buf
);
844 /* The stub recognized the packet request. */
845 switch (config
->support
)
847 case PACKET_SUPPORT_UNKNOWN
:
849 fprintf_unfiltered (gdb_stdlog
,
850 "Packet %s (%s) is supported\n",
851 config
->name
, config
->title
);
852 config
->support
= PACKET_ENABLE
;
855 internal_error (__FILE__
, __LINE__
,
856 _("packet_ok: attempt to use a disabled packet"));
863 /* The stub does not support the packet. */
864 switch (config
->support
)
867 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
868 /* If the stub previously indicated that the packet was
869 supported then there is a protocol error.. */
870 error (_("Protocol error: %s (%s) conflicting enabled responses."),
871 config
->name
, config
->title
);
873 /* The user set it wrong. */
874 error (_("Enabled packet %s (%s) not recognized by stub"),
875 config
->name
, config
->title
);
877 case PACKET_SUPPORT_UNKNOWN
:
879 fprintf_unfiltered (gdb_stdlog
,
880 "Packet %s (%s) is NOT supported\n",
881 config
->name
, config
->title
);
882 config
->support
= PACKET_DISABLE
;
905 PACKET_qXfer_features
,
906 PACKET_qXfer_libraries
,
907 PACKET_qXfer_memory_map
,
908 PACKET_qXfer_spu_read
,
909 PACKET_qXfer_spu_write
,
916 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
919 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
920 struct cmd_list_element
*c
)
922 struct packet_config
*packet
;
924 for (packet
= remote_protocol_packets
;
925 packet
< &remote_protocol_packets
[PACKET_MAX
];
928 if (&packet
->detect
== c
->var
)
930 update_packet_config (packet
);
934 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
939 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
940 struct cmd_list_element
*c
,
943 struct packet_config
*packet
;
945 for (packet
= remote_protocol_packets
;
946 packet
< &remote_protocol_packets
[PACKET_MAX
];
949 if (&packet
->detect
== c
->var
)
951 show_packet_config_cmd (packet
);
955 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
959 /* Should we try one of the 'Z' requests? */
963 Z_PACKET_SOFTWARE_BP
,
964 Z_PACKET_HARDWARE_BP
,
971 /* For compatibility with older distributions. Provide a ``set remote
972 Z-packet ...'' command that updates all the Z packet types. */
974 static enum auto_boolean remote_Z_packet_detect
;
977 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
978 struct cmd_list_element
*c
)
981 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
983 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
984 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
989 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
990 struct cmd_list_element
*c
,
994 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
996 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1000 /* Should we try the 'ThreadInfo' query packet?
1002 This variable (NOT available to the user: auto-detect only!)
1003 determines whether GDB will use the new, simpler "ThreadInfo"
1004 query or the older, more complex syntax for thread queries.
1005 This is an auto-detect variable (set to true at each connect,
1006 and set to false when the target fails to recognize it). */
1008 static int use_threadinfo_query
;
1009 static int use_threadextra_query
;
1011 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1012 static struct async_signal_handler
*sigint_remote_twice_token
;
1013 static struct async_signal_handler
*sigint_remote_token
;
1015 /* These are pointers to hook functions that may be set in order to
1016 modify resume/wait behavior for a particular architecture. */
1018 void (*deprecated_target_resume_hook
) (void);
1019 void (*deprecated_target_wait_loop_hook
) (void);
1023 /* These are the threads which we last sent to the remote system.
1024 -1 for all or -2 for not sent yet. */
1025 static int general_thread
;
1026 static int continue_thread
;
1028 /* Call this function as a result of
1029 1) A halt indication (T packet) containing a thread id
1030 2) A direct query of currthread
1031 3) Successful execution of set thread
1035 record_currthread (int currthread
)
1037 general_thread
= currthread
;
1039 /* If this is a new thread, add it to GDB's thread list.
1040 If we leave it up to WFI to do this, bad things will happen. */
1041 if (!in_thread_list (pid_to_ptid (currthread
)))
1043 add_thread (pid_to_ptid (currthread
));
1044 ui_out_text (uiout
, "[New ");
1045 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
1046 ui_out_text (uiout
, "]\n");
1050 static char *last_pass_packet
;
1052 /* If 'QPassSignals' is supported, tell the remote stub what signals
1053 it can simply pass through to the inferior without reporting. */
1056 remote_pass_signals (void)
1058 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1060 char *pass_packet
, *p
;
1061 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1064 gdb_assert (numsigs
< 256);
1065 for (i
= 0; i
< numsigs
; i
++)
1067 if (signal_stop_state (i
) == 0
1068 && signal_print_state (i
) == 0
1069 && signal_pass_state (i
) == 1)
1072 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1073 strcpy (pass_packet
, "QPassSignals:");
1074 p
= pass_packet
+ strlen (pass_packet
);
1075 for (i
= 0; i
< numsigs
; i
++)
1077 if (signal_stop_state (i
) == 0
1078 && signal_print_state (i
) == 0
1079 && signal_pass_state (i
) == 1)
1082 *p
++ = tohex (i
>> 4);
1083 *p
++ = tohex (i
& 15);
1092 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1094 struct remote_state
*rs
= get_remote_state ();
1095 char *buf
= rs
->buf
;
1097 putpkt (pass_packet
);
1098 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1099 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1100 if (last_pass_packet
)
1101 xfree (last_pass_packet
);
1102 last_pass_packet
= pass_packet
;
1105 xfree (pass_packet
);
1109 #define MAGIC_NULL_PID 42000
1112 set_thread (int th
, int gen
)
1114 struct remote_state
*rs
= get_remote_state ();
1115 char *buf
= rs
->buf
;
1116 int state
= gen
? general_thread
: continue_thread
;
1122 buf
[1] = gen
? 'g' : 'c';
1123 if (th
== MAGIC_NULL_PID
)
1129 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
1131 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
1133 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1135 general_thread
= th
;
1137 continue_thread
= th
;
1140 /* Return nonzero if the thread TH is still alive on the remote system. */
1143 remote_thread_alive (ptid_t ptid
)
1145 struct remote_state
*rs
= get_remote_state ();
1146 int tid
= PIDGET (ptid
);
1149 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1151 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1153 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1154 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1157 /* About these extended threadlist and threadinfo packets. They are
1158 variable length packets but, the fields within them are often fixed
1159 length. They are redundent enough to send over UDP as is the
1160 remote protocol in general. There is a matching unit test module
1163 #define OPAQUETHREADBYTES 8
1165 /* a 64 bit opaque identifier */
1166 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1168 /* WARNING: This threadref data structure comes from the remote O.S.,
1169 libstub protocol encoding, and remote.c. it is not particularly
1172 /* Right now, the internal structure is int. We want it to be bigger.
1176 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1178 /* gdb_ext_thread_info is an internal GDB data structure which is
1179 equivalent to the reply of the remote threadinfo packet. */
1181 struct gdb_ext_thread_info
1183 threadref threadid
; /* External form of thread reference. */
1184 int active
; /* Has state interesting to GDB?
1186 char display
[256]; /* Brief state display, name,
1187 blocked/suspended. */
1188 char shortname
[32]; /* To be used to name threads. */
1189 char more_display
[256]; /* Long info, statistics, queue depth,
1193 /* The volume of remote transfers can be limited by submitting
1194 a mask containing bits specifying the desired information.
1195 Use a union of these values as the 'selection' parameter to
1196 get_thread_info. FIXME: Make these TAG names more thread specific.
1199 #define TAG_THREADID 1
1200 #define TAG_EXISTS 2
1201 #define TAG_DISPLAY 4
1202 #define TAG_THREADNAME 8
1203 #define TAG_MOREDISPLAY 16
1205 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1207 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1209 static char *unpack_nibble (char *buf
, int *val
);
1211 static char *pack_nibble (char *buf
, int nibble
);
1213 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1215 static char *unpack_byte (char *buf
, int *value
);
1217 static char *pack_int (char *buf
, int value
);
1219 static char *unpack_int (char *buf
, int *value
);
1221 static char *unpack_string (char *src
, char *dest
, int length
);
1223 static char *pack_threadid (char *pkt
, threadref
*id
);
1225 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1227 void int_to_threadref (threadref
*id
, int value
);
1229 static int threadref_to_int (threadref
*ref
);
1231 static void copy_threadref (threadref
*dest
, threadref
*src
);
1233 static int threadmatch (threadref
*dest
, threadref
*src
);
1235 static char *pack_threadinfo_request (char *pkt
, int mode
,
1238 static int remote_unpack_thread_info_response (char *pkt
,
1239 threadref
*expectedref
,
1240 struct gdb_ext_thread_info
1244 static int remote_get_threadinfo (threadref
*threadid
,
1245 int fieldset
, /*TAG mask */
1246 struct gdb_ext_thread_info
*info
);
1248 static char *pack_threadlist_request (char *pkt
, int startflag
,
1250 threadref
*nextthread
);
1252 static int parse_threadlist_response (char *pkt
,
1254 threadref
*original_echo
,
1255 threadref
*resultlist
,
1258 static int remote_get_threadlist (int startflag
,
1259 threadref
*nextthread
,
1263 threadref
*threadlist
);
1265 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1267 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1268 void *context
, int looplimit
);
1270 static int remote_newthread_step (threadref
*ref
, void *context
);
1272 /* Encode 64 bits in 16 chars of hex. */
1274 static const char hexchars
[] = "0123456789abcdef";
1277 ishex (int ch
, int *val
)
1279 if ((ch
>= 'a') && (ch
<= 'f'))
1281 *val
= ch
- 'a' + 10;
1284 if ((ch
>= 'A') && (ch
<= 'F'))
1286 *val
= ch
- 'A' + 10;
1289 if ((ch
>= '0') && (ch
<= '9'))
1300 if (ch
>= 'a' && ch
<= 'f')
1301 return ch
- 'a' + 10;
1302 if (ch
>= '0' && ch
<= '9')
1304 if (ch
>= 'A' && ch
<= 'F')
1305 return ch
- 'A' + 10;
1310 stub_unpack_int (char *buff
, int fieldlength
)
1317 nibble
= stubhex (*buff
++);
1321 retval
= retval
<< 4;
1327 unpack_varlen_hex (char *buff
, /* packet to parse */
1331 ULONGEST retval
= 0;
1333 while (ishex (*buff
, &nibble
))
1336 retval
= retval
<< 4;
1337 retval
|= nibble
& 0x0f;
1344 unpack_nibble (char *buf
, int *val
)
1346 ishex (*buf
++, val
);
1351 pack_nibble (char *buf
, int nibble
)
1353 *buf
++ = hexchars
[(nibble
& 0x0f)];
1358 pack_hex_byte (char *pkt
, int byte
)
1360 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1361 *pkt
++ = hexchars
[(byte
& 0xf)];
1366 unpack_byte (char *buf
, int *value
)
1368 *value
= stub_unpack_int (buf
, 2);
1373 pack_int (char *buf
, int value
)
1375 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1376 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1377 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1378 buf
= pack_hex_byte (buf
, (value
& 0xff));
1383 unpack_int (char *buf
, int *value
)
1385 *value
= stub_unpack_int (buf
, 8);
1389 #if 0 /* Currently unused, uncomment when needed. */
1390 static char *pack_string (char *pkt
, char *string
);
1393 pack_string (char *pkt
, char *string
)
1398 len
= strlen (string
);
1400 len
= 200; /* Bigger than most GDB packets, junk??? */
1401 pkt
= pack_hex_byte (pkt
, len
);
1405 if ((ch
== '\0') || (ch
== '#'))
1406 ch
= '*'; /* Protect encapsulation. */
1411 #endif /* 0 (unused) */
1414 unpack_string (char *src
, char *dest
, int length
)
1423 pack_threadid (char *pkt
, threadref
*id
)
1426 unsigned char *altid
;
1428 altid
= (unsigned char *) id
;
1429 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1431 pkt
= pack_hex_byte (pkt
, *altid
++);
1437 unpack_threadid (char *inbuf
, threadref
*id
)
1440 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1443 altref
= (char *) id
;
1445 while (inbuf
< limit
)
1447 x
= stubhex (*inbuf
++);
1448 y
= stubhex (*inbuf
++);
1449 *altref
++ = (x
<< 4) | y
;
1454 /* Externally, threadrefs are 64 bits but internally, they are still
1455 ints. This is due to a mismatch of specifications. We would like
1456 to use 64bit thread references internally. This is an adapter
1460 int_to_threadref (threadref
*id
, int value
)
1462 unsigned char *scan
;
1464 scan
= (unsigned char *) id
;
1470 *scan
++ = (value
>> 24) & 0xff;
1471 *scan
++ = (value
>> 16) & 0xff;
1472 *scan
++ = (value
>> 8) & 0xff;
1473 *scan
++ = (value
& 0xff);
1477 threadref_to_int (threadref
*ref
)
1480 unsigned char *scan
;
1486 value
= (value
<< 8) | ((*scan
++) & 0xff);
1491 copy_threadref (threadref
*dest
, threadref
*src
)
1494 unsigned char *csrc
, *cdest
;
1496 csrc
= (unsigned char *) src
;
1497 cdest
= (unsigned char *) dest
;
1504 threadmatch (threadref
*dest
, threadref
*src
)
1506 /* Things are broken right now, so just assume we got a match. */
1508 unsigned char *srcp
, *destp
;
1510 srcp
= (char *) src
;
1511 destp
= (char *) dest
;
1515 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1522 threadid:1, # always request threadid
1529 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1532 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1534 *pkt
++ = 'q'; /* Info Query */
1535 *pkt
++ = 'P'; /* process or thread info */
1536 pkt
= pack_int (pkt
, mode
); /* mode */
1537 pkt
= pack_threadid (pkt
, id
); /* threadid */
1538 *pkt
= '\0'; /* terminate */
1542 /* These values tag the fields in a thread info response packet. */
1543 /* Tagging the fields allows us to request specific fields and to
1544 add more fields as time goes by. */
1546 #define TAG_THREADID 1 /* Echo the thread identifier. */
1547 #define TAG_EXISTS 2 /* Is this process defined enough to
1548 fetch registers and its stack? */
1549 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1550 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1551 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1555 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1556 struct gdb_ext_thread_info
*info
)
1558 struct remote_state
*rs
= get_remote_state ();
1562 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1565 /* info->threadid = 0; FIXME: implement zero_threadref. */
1567 info
->display
[0] = '\0';
1568 info
->shortname
[0] = '\0';
1569 info
->more_display
[0] = '\0';
1571 /* Assume the characters indicating the packet type have been
1573 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1574 pkt
= unpack_threadid (pkt
, &ref
);
1577 warning (_("Incomplete response to threadinfo request."));
1578 if (!threadmatch (&ref
, expectedref
))
1579 { /* This is an answer to a different request. */
1580 warning (_("ERROR RMT Thread info mismatch."));
1583 copy_threadref (&info
->threadid
, &ref
);
1585 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1587 /* Packets are terminated with nulls. */
1588 while ((pkt
< limit
) && mask
&& *pkt
)
1590 pkt
= unpack_int (pkt
, &tag
); /* tag */
1591 pkt
= unpack_byte (pkt
, &length
); /* length */
1592 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1594 warning (_("ERROR RMT: threadinfo tag mismatch."));
1598 if (tag
== TAG_THREADID
)
1602 warning (_("ERROR RMT: length of threadid is not 16."));
1606 pkt
= unpack_threadid (pkt
, &ref
);
1607 mask
= mask
& ~TAG_THREADID
;
1610 if (tag
== TAG_EXISTS
)
1612 info
->active
= stub_unpack_int (pkt
, length
);
1614 mask
= mask
& ~(TAG_EXISTS
);
1617 warning (_("ERROR RMT: 'exists' length too long."));
1623 if (tag
== TAG_THREADNAME
)
1625 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1626 mask
= mask
& ~TAG_THREADNAME
;
1629 if (tag
== TAG_DISPLAY
)
1631 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1632 mask
= mask
& ~TAG_DISPLAY
;
1635 if (tag
== TAG_MOREDISPLAY
)
1637 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1638 mask
= mask
& ~TAG_MOREDISPLAY
;
1641 warning (_("ERROR RMT: unknown thread info tag."));
1642 break; /* Not a tag we know about. */
1648 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1649 struct gdb_ext_thread_info
*info
)
1651 struct remote_state
*rs
= get_remote_state ();
1654 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1656 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1657 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1662 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1665 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1666 threadref
*nextthread
)
1668 *pkt
++ = 'q'; /* info query packet */
1669 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1670 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1671 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1672 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1677 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1680 parse_threadlist_response (char *pkt
, int result_limit
,
1681 threadref
*original_echo
, threadref
*resultlist
,
1684 struct remote_state
*rs
= get_remote_state ();
1686 int count
, resultcount
, done
;
1689 /* Assume the 'q' and 'M chars have been stripped. */
1690 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1691 /* done parse past here */
1692 pkt
= unpack_byte (pkt
, &count
); /* count field */
1693 pkt
= unpack_nibble (pkt
, &done
);
1694 /* The first threadid is the argument threadid. */
1695 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1696 while ((count
-- > 0) && (pkt
< limit
))
1698 pkt
= unpack_threadid (pkt
, resultlist
++);
1699 if (resultcount
++ >= result_limit
)
1708 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1709 int *done
, int *result_count
, threadref
*threadlist
)
1711 struct remote_state
*rs
= get_remote_state ();
1712 static threadref echo_nextthread
;
1715 /* Trancate result limit to be smaller than the packet size. */
1716 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1717 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1719 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1721 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1724 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1727 if (!threadmatch (&echo_nextthread
, nextthread
))
1729 /* FIXME: This is a good reason to drop the packet. */
1730 /* Possably, there is a duplicate response. */
1732 retransmit immediatly - race conditions
1733 retransmit after timeout - yes
1735 wait for packet, then exit
1737 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1738 return 0; /* I choose simply exiting. */
1740 if (*result_count
<= 0)
1744 warning (_("RMT ERROR : failed to get remote thread list."));
1747 return result
; /* break; */
1749 if (*result_count
> result_limit
)
1752 warning (_("RMT ERROR: threadlist response longer than requested."));
1758 /* This is the interface between remote and threads, remotes upper
1761 /* remote_find_new_threads retrieves the thread list and for each
1762 thread in the list, looks up the thread in GDB's internal list,
1763 ading the thread if it does not already exist. This involves
1764 getting partial thread lists from the remote target so, polling the
1765 quit_flag is required. */
1768 /* About this many threadisds fit in a packet. */
1770 #define MAXTHREADLISTRESULTS 32
1773 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1776 int done
, i
, result_count
;
1780 static threadref nextthread
;
1781 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1786 if (loopcount
++ > looplimit
)
1789 warning (_("Remote fetch threadlist -infinite loop-."));
1792 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1793 &done
, &result_count
, resultthreadlist
))
1798 /* Clear for later iterations. */
1800 /* Setup to resume next batch of thread references, set nextthread. */
1801 if (result_count
>= 1)
1802 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1804 while (result_count
--)
1805 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1812 remote_newthread_step (threadref
*ref
, void *context
)
1816 ptid
= pid_to_ptid (threadref_to_int (ref
));
1818 if (!in_thread_list (ptid
))
1820 return 1; /* continue iterator */
1823 #define CRAZY_MAX_THREADS 1000
1826 remote_current_thread (ptid_t oldpid
)
1828 struct remote_state
*rs
= get_remote_state ();
1831 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1832 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1833 /* Use strtoul here, so we'll correctly parse values whose highest
1834 bit is set. The protocol carries them as a simple series of
1835 hex digits; in the absence of a sign, strtol will see such
1836 values as positive numbers out of range for signed 'long', and
1837 return LONG_MAX to indicate an overflow. */
1838 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1843 /* Find new threads for info threads command.
1844 * Original version, using John Metzler's thread protocol.
1848 remote_find_new_threads (void)
1850 remote_threadlist_iterator (remote_newthread_step
, 0,
1852 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1853 inferior_ptid
= remote_current_thread (inferior_ptid
);
1857 * Find all threads for info threads command.
1858 * Uses new thread protocol contributed by Cisco.
1859 * Falls back and attempts to use the older method (above)
1860 * if the target doesn't respond to the new method.
1864 remote_threads_info (void)
1866 struct remote_state
*rs
= get_remote_state ();
1870 if (remote_desc
== 0) /* paranoia */
1871 error (_("Command can only be used when connected to the remote target."));
1873 if (use_threadinfo_query
)
1875 putpkt ("qfThreadInfo");
1876 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1878 if (bufp
[0] != '\0') /* q packet recognized */
1880 while (*bufp
++ == 'm') /* reply contains one or more TID */
1884 /* Use strtoul here, so we'll correctly parse values
1885 whose highest bit is set. The protocol carries
1886 them as a simple series of hex digits; in the
1887 absence of a sign, strtol will see such values as
1888 positive numbers out of range for signed 'long',
1889 and return LONG_MAX to indicate an overflow. */
1890 tid
= strtoul (bufp
, &bufp
, 16);
1891 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1892 add_thread (pid_to_ptid (tid
));
1894 while (*bufp
++ == ','); /* comma-separated list */
1895 putpkt ("qsThreadInfo");
1896 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1903 /* Else fall back to old method based on jmetzler protocol. */
1904 use_threadinfo_query
= 0;
1905 remote_find_new_threads ();
1910 * Collect a descriptive string about the given thread.
1911 * The target may say anything it wants to about the thread
1912 * (typically info about its blocked / runnable state, name, etc.).
1913 * This string will appear in the info threads display.
1915 * Optional: targets are not required to implement this function.
1919 remote_threads_extra_info (struct thread_info
*tp
)
1921 struct remote_state
*rs
= get_remote_state ();
1925 struct gdb_ext_thread_info threadinfo
;
1926 static char display_buf
[100]; /* arbitrary... */
1927 int n
= 0; /* position in display_buf */
1929 if (remote_desc
== 0) /* paranoia */
1930 internal_error (__FILE__
, __LINE__
,
1931 _("remote_threads_extra_info"));
1933 if (use_threadextra_query
)
1935 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1938 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1939 if (rs
->buf
[0] != 0)
1941 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1942 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1943 display_buf
[result
] = '\0';
1948 /* If the above query fails, fall back to the old method. */
1949 use_threadextra_query
= 0;
1950 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1951 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1952 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1953 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1954 if (threadinfo
.active
)
1956 if (*threadinfo
.shortname
)
1957 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1958 " Name: %s,", threadinfo
.shortname
);
1959 if (*threadinfo
.display
)
1960 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1961 " State: %s,", threadinfo
.display
);
1962 if (*threadinfo
.more_display
)
1963 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1964 " Priority: %s", threadinfo
.more_display
);
1968 /* For purely cosmetic reasons, clear up trailing commas. */
1969 if (',' == display_buf
[n
-1])
1970 display_buf
[n
-1] = ' ';
1978 /* Restart the remote side; this is an extended protocol operation. */
1981 extended_remote_restart (void)
1983 struct remote_state
*rs
= get_remote_state ();
1985 /* Send the restart command; for reasons I don't understand the
1986 remote side really expects a number after the "R". */
1987 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1990 remote_fileio_reset ();
1992 /* Now query for status so this looks just like we restarted
1993 gdbserver from scratch. */
1995 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1998 /* Clean up connection to a remote debugger. */
2001 remote_close (int quitting
)
2004 serial_close (remote_desc
);
2008 /* Query the remote side for the text, data and bss offsets. */
2013 struct remote_state
*rs
= get_remote_state ();
2016 int lose
, num_segments
= 0, do_sections
, do_segments
;
2017 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
2018 struct section_offsets
*offs
;
2019 struct symfile_segment_data
*data
;
2021 if (symfile_objfile
== NULL
)
2024 putpkt ("qOffsets");
2025 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2028 if (buf
[0] == '\000')
2029 return; /* Return silently. Stub doesn't support
2033 warning (_("Remote failure reply: %s"), buf
);
2037 /* Pick up each field in turn. This used to be done with scanf, but
2038 scanf will make trouble if CORE_ADDR size doesn't match
2039 conversion directives correctly. The following code will work
2040 with any size of CORE_ADDR. */
2041 text_addr
= data_addr
= bss_addr
= 0;
2045 if (strncmp (ptr
, "Text=", 5) == 0)
2048 /* Don't use strtol, could lose on big values. */
2049 while (*ptr
&& *ptr
!= ';')
2050 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2052 if (strncmp (ptr
, ";Data=", 6) == 0)
2055 while (*ptr
&& *ptr
!= ';')
2056 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2061 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2064 while (*ptr
&& *ptr
!= ';')
2065 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2067 if (bss_addr
!= data_addr
)
2068 warning (_("Target reported unsupported offsets: %s"), buf
);
2073 else if (strncmp (ptr
, "TextSeg=", 8) == 0)
2076 /* Don't use strtol, could lose on big values. */
2077 while (*ptr
&& *ptr
!= ';')
2078 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2081 if (strncmp (ptr
, ";DataSeg=", 9) == 0)
2084 while (*ptr
&& *ptr
!= ';')
2085 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2093 error (_("Malformed response to offset query, %s"), buf
);
2094 else if (*ptr
!= '\0')
2095 warning (_("Target reported unsupported offsets: %s"), buf
);
2097 offs
= ((struct section_offsets
*)
2098 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2099 memcpy (offs
, symfile_objfile
->section_offsets
,
2100 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2102 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
2103 do_segments
= (data
!= NULL
);
2104 do_sections
= num_segments
== 0;
2106 if (num_segments
> 0)
2108 segments
[0] = text_addr
;
2109 segments
[1] = data_addr
;
2111 /* If we have two segments, we can still try to relocate everything
2112 by assuming that the .text and .data offsets apply to the whole
2113 text and data segments. Convert the offsets given in the packet
2114 to base addresses for symfile_map_offsets_to_segments. */
2115 else if (data
&& data
->num_segments
== 2)
2117 segments
[0] = data
->segment_bases
[0] + text_addr
;
2118 segments
[1] = data
->segment_bases
[1] + data_addr
;
2121 /* There's no way to relocate by segment. */
2127 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
2128 offs
, num_segments
, segments
);
2130 if (ret
== 0 && !do_sections
)
2131 error (_("Can not handle qOffsets TextSeg response with this symbol file"));
2138 free_symfile_segment_data (data
);
2142 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2144 /* This is a temporary kludge to force data and bss to use the same offsets
2145 because that's what nlmconv does now. The real solution requires changes
2146 to the stub and remote.c that I don't have time to do right now. */
2148 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2149 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2152 objfile_relocate (symfile_objfile
, offs
);
2155 /* Stub for catch_exception. */
2158 remote_start_remote (struct ui_out
*uiout
, void *from_tty_p
)
2160 int from_tty
= * (int *) from_tty_p
;
2162 immediate_quit
++; /* Allow user to interrupt it. */
2164 /* Ack any packet which the remote side has already sent. */
2165 serial_write (remote_desc
, "+", 1);
2167 /* Let the stub know that we want it to return the thread. */
2170 inferior_ptid
= remote_current_thread (inferior_ptid
);
2172 get_offsets (); /* Get text, data & bss offsets. */
2174 putpkt ("?"); /* Initiate a query from remote machine. */
2177 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
2180 /* Open a connection to a remote debugger.
2181 NAME is the filename used for communication. */
2184 remote_open (char *name
, int from_tty
)
2186 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2189 /* Just like remote_open, but with asynchronous support. */
2191 remote_async_open (char *name
, int from_tty
)
2193 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2196 /* Open a connection to a remote debugger using the extended
2197 remote gdb protocol. NAME is the filename used for communication. */
2200 extended_remote_open (char *name
, int from_tty
)
2202 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2206 /* Just like extended_remote_open, but with asynchronous support. */
2208 extended_remote_async_open (char *name
, int from_tty
)
2210 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2211 1 /*extended_p */, 1 /* async_p */);
2214 /* Generic code for opening a connection to a remote target. */
2217 init_all_packet_configs (void)
2220 for (i
= 0; i
< PACKET_MAX
; i
++)
2221 update_packet_config (&remote_protocol_packets
[i
]);
2224 /* Symbol look-up. */
2227 remote_check_symbols (struct objfile
*objfile
)
2229 struct remote_state
*rs
= get_remote_state ();
2230 char *msg
, *reply
, *tmp
;
2231 struct minimal_symbol
*sym
;
2234 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2237 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2238 because we need both at the same time. */
2239 msg
= alloca (get_remote_packet_size ());
2241 /* Invite target to request symbol lookups. */
2243 putpkt ("qSymbol::");
2244 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2245 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2248 while (strncmp (reply
, "qSymbol:", 8) == 0)
2251 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2253 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2255 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2258 CORE_ADDR sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
2260 /* If this is a function address, return the start of code
2261 instead of any data function descriptor. */
2262 sym_addr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
2266 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2267 paddr_nz (sym_addr
), &reply
[8]);
2271 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2276 static struct serial
*
2277 remote_serial_open (char *name
)
2279 static int udp_warning
= 0;
2281 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2282 of in ser-tcp.c, because it is the remote protocol assuming that the
2283 serial connection is reliable and not the serial connection promising
2285 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2288 The remote protocol may be unreliable over UDP.\n\
2289 Some events may be lost, rendering further debugging impossible."));
2293 return serial_open (name
);
2296 /* This type describes each known response to the qSupported
2298 struct protocol_feature
2300 /* The name of this protocol feature. */
2303 /* The default for this protocol feature. */
2304 enum packet_support default_support
;
2306 /* The function to call when this feature is reported, or after
2307 qSupported processing if the feature is not supported.
2308 The first argument points to this structure. The second
2309 argument indicates whether the packet requested support be
2310 enabled, disabled, or probed (or the default, if this function
2311 is being called at the end of processing and this feature was
2312 not reported). The third argument may be NULL; if not NULL, it
2313 is a NUL-terminated string taken from the packet following
2314 this feature's name and an equals sign. */
2315 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2318 /* The corresponding packet for this feature. Only used if
2319 FUNC is remote_supported_packet. */
2324 remote_supported_packet (const struct protocol_feature
*feature
,
2325 enum packet_support support
,
2326 const char *argument
)
2330 warning (_("Remote qSupported response supplied an unexpected value for"
2331 " \"%s\"."), feature
->name
);
2335 if (remote_protocol_packets
[feature
->packet
].support
2336 == PACKET_SUPPORT_UNKNOWN
)
2337 remote_protocol_packets
[feature
->packet
].support
= support
;
2341 remote_packet_size (const struct protocol_feature
*feature
,
2342 enum packet_support support
, const char *value
)
2344 struct remote_state
*rs
= get_remote_state ();
2349 if (support
!= PACKET_ENABLE
)
2352 if (value
== NULL
|| *value
== '\0')
2354 warning (_("Remote target reported \"%s\" without a size."),
2360 packet_size
= strtol (value
, &value_end
, 16);
2361 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2363 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2364 feature
->name
, value
);
2368 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2370 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2371 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2372 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2375 /* Record the new maximum packet size. */
2376 rs
->explicit_packet_size
= packet_size
;
2379 static struct protocol_feature remote_protocol_features
[] = {
2380 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2381 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2382 PACKET_qXfer_auxv
},
2383 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2384 PACKET_qXfer_features
},
2385 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
2386 PACKET_qXfer_libraries
},
2387 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2388 PACKET_qXfer_memory_map
},
2389 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
2390 PACKET_qXfer_spu_read
},
2391 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
2392 PACKET_qXfer_spu_write
},
2393 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2394 PACKET_QPassSignals
},
2398 remote_query_supported (void)
2400 struct remote_state
*rs
= get_remote_state ();
2403 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2405 /* The packet support flags are handled differently for this packet
2406 than for most others. We treat an error, a disabled packet, and
2407 an empty response identically: any features which must be reported
2408 to be used will be automatically disabled. An empty buffer
2409 accomplishes this, since that is also the representation for a list
2410 containing no features. */
2413 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2415 putpkt ("qSupported");
2416 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2418 /* If an error occured, warn, but do not return - just reset the
2419 buffer to empty and go on to disable features. */
2420 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2423 warning (_("Remote failure reply: %s"), rs
->buf
);
2428 memset (seen
, 0, sizeof (seen
));
2433 enum packet_support is_supported
;
2434 char *p
, *end
, *name_end
, *value
;
2436 /* First separate out this item from the rest of the packet. If
2437 there's another item after this, we overwrite the separator
2438 (terminated strings are much easier to work with). */
2440 end
= strchr (p
, ';');
2443 end
= p
+ strlen (p
);
2453 warning (_("empty item in \"qSupported\" response"));
2458 name_end
= strchr (p
, '=');
2461 /* This is a name=value entry. */
2462 is_supported
= PACKET_ENABLE
;
2463 value
= name_end
+ 1;
2472 is_supported
= PACKET_ENABLE
;
2476 is_supported
= PACKET_DISABLE
;
2480 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2484 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2490 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2491 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2493 const struct protocol_feature
*feature
;
2496 feature
= &remote_protocol_features
[i
];
2497 feature
->func (feature
, is_supported
, value
);
2502 /* If we increased the packet size, make sure to increase the global
2503 buffer size also. We delay this until after parsing the entire
2504 qSupported packet, because this is the same buffer we were
2506 if (rs
->buf_size
< rs
->explicit_packet_size
)
2508 rs
->buf_size
= rs
->explicit_packet_size
;
2509 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2512 /* Handle the defaults for unmentioned features. */
2513 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2516 const struct protocol_feature
*feature
;
2518 feature
= &remote_protocol_features
[i
];
2519 feature
->func (feature
, feature
->default_support
, NULL
);
2525 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2526 int extended_p
, int async_p
)
2528 struct remote_state
*rs
= get_remote_state ();
2530 error (_("To open a remote debug connection, you need to specify what\n"
2531 "serial device is attached to the remote system\n"
2532 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2534 /* See FIXME above. */
2536 wait_forever_enabled_p
= 1;
2538 target_preopen (from_tty
);
2540 unpush_target (target
);
2542 /* Make sure we send the passed signals list the next time we resume. */
2543 xfree (last_pass_packet
);
2544 last_pass_packet
= NULL
;
2546 remote_fileio_reset ();
2547 reopen_exec_file ();
2550 remote_desc
= remote_serial_open (name
);
2552 perror_with_name (name
);
2554 if (baud_rate
!= -1)
2556 if (serial_setbaudrate (remote_desc
, baud_rate
))
2558 /* The requested speed could not be set. Error out to
2559 top level after closing remote_desc. Take care to
2560 set remote_desc to NULL to avoid closing remote_desc
2562 serial_close (remote_desc
);
2564 perror_with_name (name
);
2568 serial_raw (remote_desc
);
2570 /* If there is something sitting in the buffer we might take it as a
2571 response to a command, which would be bad. */
2572 serial_flush_input (remote_desc
);
2576 puts_filtered ("Remote debugging using ");
2577 puts_filtered (name
);
2578 puts_filtered ("\n");
2580 push_target (target
); /* Switch to using remote target now. */
2582 /* Reset the target state; these things will be queried either by
2583 remote_query_supported or as they are needed. */
2584 init_all_packet_configs ();
2585 rs
->explicit_packet_size
= 0;
2587 general_thread
= -2;
2588 continue_thread
= -2;
2590 /* Probe for ability to use "ThreadInfo" query, as required. */
2591 use_threadinfo_query
= 1;
2592 use_threadextra_query
= 1;
2594 /* The first packet we send to the target is the optional "supported
2595 packets" request. If the target can answer this, it will tell us
2596 which later probes to skip. */
2597 remote_query_supported ();
2599 /* Next, if the target can specify a description, read it. We do
2600 this before anything involving memory or registers. */
2601 target_find_description ();
2603 /* Without this, some commands which require an active target (such
2604 as kill) won't work. This variable serves (at least) double duty
2605 as both the pid of the target process (if it has such), and as a
2606 flag indicating that a target is active. These functions should
2607 be split out into seperate variables, especially since GDB will
2608 someday have a notion of debugging several processes. */
2610 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2614 /* With this target we start out by owning the terminal. */
2615 remote_async_terminal_ours_p
= 1;
2617 /* FIXME: cagney/1999-09-23: During the initial connection it is
2618 assumed that the target is already ready and able to respond to
2619 requests. Unfortunately remote_start_remote() eventually calls
2620 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2621 around this. Eventually a mechanism that allows
2622 wait_for_inferior() to expect/get timeouts will be
2624 wait_forever_enabled_p
= 0;
2627 /* First delete any symbols previously loaded from shared libraries. */
2628 no_shared_libraries (NULL
, 0);
2630 /* Start the remote connection. If error() or QUIT, discard this
2631 target (we'd otherwise be in an inconsistent state) and then
2632 propogate the error on up the exception chain. This ensures that
2633 the caller doesn't stumble along blindly assuming that the
2634 function succeeded. The CLI doesn't have this problem but other
2635 UI's, such as MI do.
2637 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2638 this function should return an error indication letting the
2639 caller restore the previous state. Unfortunately the command
2640 ``target remote'' is directly wired to this function making that
2641 impossible. On a positive note, the CLI side of this problem has
2642 been fixed - the function set_cmd_context() makes it possible for
2643 all the ``target ....'' commands to share a common callback
2644 function. See cli-dump.c. */
2646 struct gdb_exception ex
2647 = catch_exception (uiout
, remote_start_remote
, &from_tty
,
2653 wait_forever_enabled_p
= 1;
2654 throw_exception (ex
);
2659 wait_forever_enabled_p
= 1;
2663 /* Tell the remote that we are using the extended protocol. */
2665 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2668 if (exec_bfd
) /* No use without an exec file. */
2669 remote_check_symbols (symfile_objfile
);
2672 /* This takes a program previously attached to and detaches it. After
2673 this is done, GDB can be used to debug some other program. We
2674 better not have left any breakpoints in the target program or it'll
2675 die when it hits one. */
2678 remote_detach (char *args
, int from_tty
)
2680 struct remote_state
*rs
= get_remote_state ();
2683 error (_("Argument given to \"detach\" when remotely debugging."));
2685 /* Tell the remote target to detach. */
2686 strcpy (rs
->buf
, "D");
2688 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2690 if (rs
->buf
[0] == 'E')
2691 error (_("Can't detach process."));
2693 /* Unregister the file descriptor from the event loop. */
2694 if (target_is_async_p ())
2695 serial_async (remote_desc
, NULL
, 0);
2697 target_mourn_inferior ();
2699 puts_filtered ("Ending remote debugging.\n");
2702 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2705 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2708 error (_("Argument given to \"detach\" when remotely debugging."));
2710 /* Unregister the file descriptor from the event loop. */
2711 if (target_is_async_p ())
2712 serial_async (remote_desc
, NULL
, 0);
2714 target_mourn_inferior ();
2716 puts_filtered ("Ending remote debugging.\n");
2719 /* Convert hex digit A to a number. */
2724 if (a
>= '0' && a
<= '9')
2726 else if (a
>= 'a' && a
<= 'f')
2727 return a
- 'a' + 10;
2728 else if (a
>= 'A' && a
<= 'F')
2729 return a
- 'A' + 10;
2731 error (_("Reply contains invalid hex digit %d"), a
);
2735 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2739 for (i
= 0; i
< count
; i
++)
2741 if (hex
[0] == 0 || hex
[1] == 0)
2743 /* Hex string is short, or of uneven length.
2744 Return the count that has been converted so far. */
2747 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2753 /* Convert number NIB to a hex digit. */
2761 return 'a' + nib
- 10;
2765 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2768 /* May use a length, or a nul-terminated string as input. */
2770 count
= strlen ((char *) bin
);
2772 for (i
= 0; i
< count
; i
++)
2774 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2775 *hex
++ = tohex (*bin
++ & 0xf);
2781 /* Check for the availability of vCont. This function should also check
2785 remote_vcont_probe (struct remote_state
*rs
)
2789 strcpy (rs
->buf
, "vCont?");
2791 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2794 /* Make sure that the features we assume are supported. */
2795 if (strncmp (buf
, "vCont", 5) == 0)
2798 int support_s
, support_S
, support_c
, support_C
;
2804 while (p
&& *p
== ';')
2807 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2809 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2811 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2813 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2816 p
= strchr (p
, ';');
2819 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2820 BUF will make packet_ok disable the packet. */
2821 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2825 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2828 /* Resume the remote inferior by using a "vCont" packet. The thread
2829 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2830 resumed thread should be single-stepped and/or signalled. If PTID's
2831 PID is -1, then all threads are resumed; the thread to be stepped and/or
2832 signalled is given in the global INFERIOR_PTID. This function returns
2833 non-zero iff it resumes the inferior.
2835 This function issues a strict subset of all possible vCont commands at the
2839 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2841 struct remote_state
*rs
= get_remote_state ();
2842 int pid
= PIDGET (ptid
);
2843 char *buf
= NULL
, *outbuf
;
2844 struct cleanup
*old_cleanup
;
2846 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2847 remote_vcont_probe (rs
);
2849 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2852 /* If we could generate a wider range of packets, we'd have to worry
2853 about overflowing BUF. Should there be a generic
2854 "multi-part-packet" packet? */
2856 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2858 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2859 don't have any PID numbers the inferior will understand. Make sure
2860 to only send forms that do not specify a PID. */
2861 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2862 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2864 outbuf
= xstrprintf ("vCont;s");
2865 else if (siggnal
!= TARGET_SIGNAL_0
)
2866 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2868 outbuf
= xstrprintf ("vCont;c");
2872 /* Resume all threads, with preference for INFERIOR_PTID. */
2873 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2874 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2875 PIDGET (inferior_ptid
));
2877 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2878 else if (siggnal
!= TARGET_SIGNAL_0
)
2879 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2880 PIDGET (inferior_ptid
));
2882 outbuf
= xstrprintf ("vCont;c");
2886 /* Scheduler locking; resume only PTID. */
2887 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2888 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2890 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2891 else if (siggnal
!= TARGET_SIGNAL_0
)
2892 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2894 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2897 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2898 old_cleanup
= make_cleanup (xfree
, outbuf
);
2902 do_cleanups (old_cleanup
);
2907 /* Tell the remote machine to resume. */
2909 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2911 static int last_sent_step
;
2914 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2916 struct remote_state
*rs
= get_remote_state ();
2918 int pid
= PIDGET (ptid
);
2920 last_sent_signal
= siggnal
;
2921 last_sent_step
= step
;
2923 /* A hook for when we need to do something at the last moment before
2925 if (deprecated_target_resume_hook
)
2926 (*deprecated_target_resume_hook
) ();
2928 /* Update the inferior on signals to silently pass, if they've changed. */
2929 remote_pass_signals ();
2931 /* The vCont packet doesn't need to specify threads via Hc. */
2932 if (remote_vcont_resume (ptid
, step
, siggnal
))
2935 /* All other supported resume packets do use Hc, so call set_thread. */
2937 set_thread (0, 0); /* Run any thread. */
2939 set_thread (pid
, 0); /* Run this thread. */
2942 if (siggnal
!= TARGET_SIGNAL_0
)
2944 buf
[0] = step
? 'S' : 'C';
2945 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2946 buf
[2] = tohex (((int) siggnal
) & 0xf);
2950 strcpy (buf
, step
? "s" : "c");
2955 /* Same as remote_resume, but with async support. */
2957 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2959 remote_resume (ptid
, step
, siggnal
);
2961 /* We are about to start executing the inferior, let's register it
2962 with the event loop. NOTE: this is the one place where all the
2963 execution commands end up. We could alternatively do this in each
2964 of the execution commands in infcmd.c. */
2965 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2966 into infcmd.c in order to allow inferior function calls to work
2967 NOT asynchronously. */
2968 if (target_can_async_p ())
2969 target_async (inferior_event_handler
, 0);
2970 /* Tell the world that the target is now executing. */
2971 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2972 this? Instead, should the client of target just assume (for
2973 async targets) that the target is going to start executing? Is
2974 this information already found in the continuation block? */
2975 if (target_is_async_p ())
2976 target_executing
= 1;
2980 /* Set up the signal handler for SIGINT, while the target is
2981 executing, ovewriting the 'regular' SIGINT signal handler. */
2983 initialize_sigint_signal_handler (void)
2985 sigint_remote_token
=
2986 create_async_signal_handler (async_remote_interrupt
, NULL
);
2987 signal (SIGINT
, handle_remote_sigint
);
2990 /* Signal handler for SIGINT, while the target is executing. */
2992 handle_remote_sigint (int sig
)
2994 signal (sig
, handle_remote_sigint_twice
);
2995 sigint_remote_twice_token
=
2996 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2997 mark_async_signal_handler_wrapper (sigint_remote_token
);
3000 /* Signal handler for SIGINT, installed after SIGINT has already been
3001 sent once. It will take effect the second time that the user sends
3004 handle_remote_sigint_twice (int sig
)
3006 signal (sig
, handle_sigint
);
3007 sigint_remote_twice_token
=
3008 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
3009 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
3012 /* Perform the real interruption of the target execution, in response
3015 async_remote_interrupt (gdb_client_data arg
)
3018 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3023 /* Perform interrupt, if the first attempt did not succeed. Just give
3024 up on the target alltogether. */
3026 async_remote_interrupt_twice (gdb_client_data arg
)
3029 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
3030 /* Do something only if the target was not killed by the previous
3032 if (target_executing
)
3035 signal (SIGINT
, handle_remote_sigint
);
3039 /* Reinstall the usual SIGINT handlers, after the target has
3042 cleanup_sigint_signal_handler (void *dummy
)
3044 signal (SIGINT
, handle_sigint
);
3045 if (sigint_remote_twice_token
)
3046 delete_async_signal_handler (&sigint_remote_twice_token
);
3047 if (sigint_remote_token
)
3048 delete_async_signal_handler (&sigint_remote_token
);
3051 /* Send ^C to target to halt it. Target will respond, and send us a
3053 static void (*ofunc
) (int);
3055 /* The command line interface's stop routine. This function is installed
3056 as a signal handler for SIGINT. The first time a user requests a
3057 stop, we call remote_stop to send a break or ^C. If there is no
3058 response from the target (it didn't stop when the user requested it),
3059 we ask the user if he'd like to detach from the target. */
3061 remote_interrupt (int signo
)
3063 /* If this doesn't work, try more severe steps. */
3064 signal (signo
, remote_interrupt_twice
);
3067 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3072 /* The user typed ^C twice. */
3075 remote_interrupt_twice (int signo
)
3077 signal (signo
, ofunc
);
3079 signal (signo
, remote_interrupt
);
3082 /* This is the generic stop called via the target vector. When a target
3083 interrupt is requested, either by the command line or the GUI, we
3084 will eventually end up here. */
3088 /* Send a break or a ^C, depending on user preference. */
3090 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
3093 serial_send_break (remote_desc
);
3095 serial_write (remote_desc
, "\003", 1);
3098 /* Ask the user what to do when an interrupt is received. */
3101 interrupt_query (void)
3103 target_terminal_ours ();
3105 if (query ("Interrupted while waiting for the program.\n\
3106 Give up (and stop debugging it)? "))
3108 target_mourn_inferior ();
3109 deprecated_throw_reason (RETURN_QUIT
);
3112 target_terminal_inferior ();
3115 /* Enable/disable target terminal ownership. Most targets can use
3116 terminal groups to control terminal ownership. Remote targets are
3117 different in that explicit transfer of ownership to/from GDB/target
3121 remote_async_terminal_inferior (void)
3123 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3124 sync_execution here. This function should only be called when
3125 GDB is resuming the inferior in the forground. A background
3126 resume (``run&'') should leave GDB in control of the terminal and
3127 consequently should not call this code. */
3128 if (!sync_execution
)
3130 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3131 calls target_terminal_*() idenpotent. The event-loop GDB talking
3132 to an asynchronous target with a synchronous command calls this
3133 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3134 stops trying to transfer the terminal to the target when it
3135 shouldn't this guard can go away. */
3136 if (!remote_async_terminal_ours_p
)
3138 delete_file_handler (input_fd
);
3139 remote_async_terminal_ours_p
= 0;
3140 initialize_sigint_signal_handler ();
3141 /* NOTE: At this point we could also register our selves as the
3142 recipient of all input. Any characters typed could then be
3143 passed on down to the target. */
3147 remote_async_terminal_ours (void)
3149 /* See FIXME in remote_async_terminal_inferior. */
3150 if (!sync_execution
)
3152 /* See FIXME in remote_async_terminal_inferior. */
3153 if (remote_async_terminal_ours_p
)
3155 cleanup_sigint_signal_handler (NULL
);
3156 add_file_handler (input_fd
, stdin_event_handler
, 0);
3157 remote_async_terminal_ours_p
= 1;
3160 /* If nonzero, ignore the next kill. */
3165 remote_console_output (char *msg
)
3169 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3172 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3175 fputs_unfiltered (tb
, gdb_stdtarg
);
3177 gdb_flush (gdb_stdtarg
);
3180 /* Wait until the remote machine stops, then return,
3181 storing status in STATUS just as `wait' would.
3182 Returns "pid", which in the case of a multi-threaded
3183 remote OS, is the thread-id. */
3186 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3188 struct remote_state
*rs
= get_remote_state ();
3189 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3190 ULONGEST thread_num
= -1;
3192 int solibs_changed
= 0;
3194 status
->kind
= TARGET_WAITKIND_EXITED
;
3195 status
->value
.integer
= 0;
3201 ofunc
= signal (SIGINT
, remote_interrupt
);
3202 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3203 signal (SIGINT
, ofunc
);
3207 /* This is a hook for when we need to do something (perhaps the
3208 collection of trace data) every time the target stops. */
3209 if (deprecated_target_wait_loop_hook
)
3210 (*deprecated_target_wait_loop_hook
) ();
3212 remote_stopped_by_watchpoint_p
= 0;
3216 case 'E': /* Error of some sort. */
3217 warning (_("Remote failure reply: %s"), buf
);
3219 case 'F': /* File-I/O request. */
3220 remote_fileio_request (buf
);
3222 case 'T': /* Status with PC, SP, FP, ... */
3224 gdb_byte regs
[MAX_REGISTER_SIZE
];
3226 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3227 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3229 n... = register number
3230 r... = register contents
3232 p
= &buf
[3]; /* after Txx */
3241 /* If the packet contains a register number save it in
3242 pnum and set p1 to point to the character following
3243 it. Otherwise p1 points to p. */
3245 /* If this packet is an awatch packet, don't parse the
3246 'a' as a register number. */
3248 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3250 /* Read the ``P'' register number. */
3251 pnum
= strtol (p
, &p_temp
, 16);
3257 if (p1
== p
) /* No register number present here. */
3259 p1
= strchr (p
, ':');
3261 error (_("Malformed packet(a) (missing colon): %s\n\
3264 if (strncmp (p
, "thread", p1
- p
) == 0)
3266 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3267 record_currthread (thread_num
);
3270 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3271 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3272 || (strncmp (p
, "awatch", p1
- p
) == 0))
3274 remote_stopped_by_watchpoint_p
= 1;
3275 p
= unpack_varlen_hex (++p1
, &addr
);
3276 remote_watch_data_address
= (CORE_ADDR
)addr
;
3278 else if (strncmp (p
, "library", p1
- p
) == 0)
3282 while (*p_temp
&& *p_temp
!= ';')
3290 /* Silently skip unknown optional info. */
3291 p_temp
= strchr (p1
+ 1, ';');
3298 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3302 error (_("Malformed packet(b) (missing colon): %s\n\
3307 error (_("Remote sent bad register number %s: %s\n\
3309 phex_nz (pnum
, 0), p
, buf
);
3311 fieldsize
= hex2bin (p
, regs
,
3312 register_size (current_gdbarch
,
3315 if (fieldsize
< register_size (current_gdbarch
,
3317 warning (_("Remote reply is too short: %s"), buf
);
3318 regcache_raw_supply (get_current_regcache (),
3323 error (_("Remote register badly formatted: %s\nhere: %s"),
3328 case 'S': /* Old style status, just signal only. */
3330 status
->kind
= TARGET_WAITKIND_LOADED
;
3333 status
->kind
= TARGET_WAITKIND_STOPPED
;
3334 status
->value
.sig
= (enum target_signal
)
3335 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3340 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3341 record_currthread (thread_num
);
3344 case 'W': /* Target exited. */
3346 /* The remote process exited. */
3347 status
->kind
= TARGET_WAITKIND_EXITED
;
3348 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3352 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3353 status
->value
.sig
= (enum target_signal
)
3354 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3358 case 'O': /* Console output. */
3359 remote_console_output (buf
+ 1);
3362 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3364 /* Zero length reply means that we tried 'S' or 'C' and
3365 the remote system doesn't support it. */
3366 target_terminal_ours_for_output ();
3368 ("Can't send signals to this remote system. %s not sent.\n",
3369 target_signal_to_name (last_sent_signal
));
3370 last_sent_signal
= TARGET_SIGNAL_0
;
3371 target_terminal_inferior ();
3373 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3374 putpkt ((char *) buf
);
3377 /* else fallthrough */
3379 warning (_("Invalid remote reply: %s"), buf
);
3384 if (thread_num
!= -1)
3386 return pid_to_ptid (thread_num
);
3388 return inferior_ptid
;
3391 /* Async version of remote_wait. */
3393 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3395 struct remote_state
*rs
= get_remote_state ();
3396 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3397 ULONGEST thread_num
= -1;
3399 int solibs_changed
= 0;
3401 status
->kind
= TARGET_WAITKIND_EXITED
;
3402 status
->value
.integer
= 0;
3404 remote_stopped_by_watchpoint_p
= 0;
3410 if (!target_is_async_p ())
3411 ofunc
= signal (SIGINT
, remote_interrupt
);
3412 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3413 _never_ wait for ever -> test on target_is_async_p().
3414 However, before we do that we need to ensure that the caller
3415 knows how to take the target into/out of async mode. */
3416 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3417 if (!target_is_async_p ())
3418 signal (SIGINT
, ofunc
);
3422 /* This is a hook for when we need to do something (perhaps the
3423 collection of trace data) every time the target stops. */
3424 if (deprecated_target_wait_loop_hook
)
3425 (*deprecated_target_wait_loop_hook
) ();
3429 case 'E': /* Error of some sort. */
3430 warning (_("Remote failure reply: %s"), buf
);
3432 case 'F': /* File-I/O request. */
3433 remote_fileio_request (buf
);
3435 case 'T': /* Status with PC, SP, FP, ... */
3437 gdb_byte regs
[MAX_REGISTER_SIZE
];
3439 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3440 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3442 n... = register number
3443 r... = register contents
3445 p
= &buf
[3]; /* after Txx */
3454 /* If the packet contains a register number, save it
3455 in pnum and set p1 to point to the character
3456 following it. Otherwise p1 points to p. */
3458 /* If this packet is an awatch packet, don't parse the 'a'
3459 as a register number. */
3461 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3463 /* Read the register number. */
3464 pnum
= strtol (p
, &p_temp
, 16);
3470 if (p1
== p
) /* No register number present here. */
3472 p1
= strchr (p
, ':');
3474 error (_("Malformed packet(a) (missing colon): %s\n\
3477 if (strncmp (p
, "thread", p1
- p
) == 0)
3479 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3480 record_currthread (thread_num
);
3483 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3484 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3485 || (strncmp (p
, "awatch", p1
- p
) == 0))
3487 remote_stopped_by_watchpoint_p
= 1;
3488 p
= unpack_varlen_hex (++p1
, &addr
);
3489 remote_watch_data_address
= (CORE_ADDR
)addr
;
3491 else if (strncmp (p
, "library", p1
- p
) == 0)
3495 while (*p_temp
&& *p_temp
!= ';')
3503 /* Silently skip unknown optional info. */
3504 p_temp
= strchr (p1
+ 1, ';');
3512 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3515 error (_("Malformed packet(b) (missing colon): %s\n\
3520 error (_("Remote sent bad register number %ld: %s\n\
3524 fieldsize
= hex2bin (p
, regs
,
3525 register_size (current_gdbarch
,
3528 if (fieldsize
< register_size (current_gdbarch
,
3530 warning (_("Remote reply is too short: %s"), buf
);
3531 regcache_raw_supply (get_current_regcache (),
3536 error (_("Remote register badly formatted: %s\nhere: %s"),
3541 case 'S': /* Old style status, just signal only. */
3543 status
->kind
= TARGET_WAITKIND_LOADED
;
3546 status
->kind
= TARGET_WAITKIND_STOPPED
;
3547 status
->value
.sig
= (enum target_signal
)
3548 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3553 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3554 record_currthread (thread_num
);
3557 case 'W': /* Target exited. */
3559 /* The remote process exited. */
3560 status
->kind
= TARGET_WAITKIND_EXITED
;
3561 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3565 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3566 status
->value
.sig
= (enum target_signal
)
3567 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3571 case 'O': /* Console output. */
3572 remote_console_output (buf
+ 1);
3573 /* Return immediately to the event loop. The event loop will
3574 still be waiting on the inferior afterwards. */
3575 status
->kind
= TARGET_WAITKIND_IGNORE
;
3578 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3580 /* Zero length reply means that we tried 'S' or 'C' and
3581 the remote system doesn't support it. */
3582 target_terminal_ours_for_output ();
3584 ("Can't send signals to this remote system. %s not sent.\n",
3585 target_signal_to_name (last_sent_signal
));
3586 last_sent_signal
= TARGET_SIGNAL_0
;
3587 target_terminal_inferior ();
3589 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3590 putpkt ((char *) buf
);
3593 /* else fallthrough */
3595 warning (_("Invalid remote reply: %s"), buf
);
3600 if (thread_num
!= -1)
3602 return pid_to_ptid (thread_num
);
3604 return inferior_ptid
;
3607 /* Fetch a single register using a 'p' packet. */
3610 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3612 struct remote_state
*rs
= get_remote_state ();
3614 char regp
[MAX_REGISTER_SIZE
];
3617 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3620 if (reg
->pnum
== -1)
3625 p
+= hexnumstr (p
, reg
->pnum
);
3627 remote_send (&rs
->buf
, &rs
->buf_size
);
3631 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3635 case PACKET_UNKNOWN
:
3638 error (_("Could not fetch register \"%s\""),
3639 gdbarch_register_name (get_regcache_arch (regcache
), reg
->regnum
));
3642 /* If this register is unfetchable, tell the regcache. */
3645 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3649 /* Otherwise, parse and supply the value. */
3655 error (_("fetch_register_using_p: early buf termination"));
3657 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3660 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3664 /* Fetch the registers included in the target's 'g' packet. */
3667 send_g_packet (void)
3669 struct remote_state
*rs
= get_remote_state ();
3674 sprintf (rs
->buf
, "g");
3675 remote_send (&rs
->buf
, &rs
->buf_size
);
3677 /* We can get out of synch in various cases. If the first character
3678 in the buffer is not a hex character, assume that has happened
3679 and try to fetch another packet to read. */
3680 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3681 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3682 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3683 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3686 fprintf_unfiltered (gdb_stdlog
,
3687 "Bad register packet; fetching a new packet\n");
3688 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3691 buf_len
= strlen (rs
->buf
);
3693 /* Sanity check the received packet. */
3694 if (buf_len
% 2 != 0)
3695 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3701 process_g_packet (struct regcache
*regcache
)
3703 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3704 struct remote_state
*rs
= get_remote_state ();
3705 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3710 buf_len
= strlen (rs
->buf
);
3712 /* Further sanity checks, with knowledge of the architecture. */
3713 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3714 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3716 /* Save the size of the packet sent to us by the target. It is used
3717 as a heuristic when determining the max size of packets that the
3718 target can safely receive. */
3719 if (rsa
->actual_register_packet_size
== 0)
3720 rsa
->actual_register_packet_size
= buf_len
;
3722 /* If this is smaller than we guessed the 'g' packet would be,
3723 update our records. A 'g' reply that doesn't include a register's
3724 value implies either that the register is not available, or that
3725 the 'p' packet must be used. */
3726 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3728 rsa
->sizeof_g_packet
= buf_len
/ 2;
3730 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
3732 if (rsa
->regs
[i
].pnum
== -1)
3735 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3736 rsa
->regs
[i
].in_g_packet
= 0;
3738 rsa
->regs
[i
].in_g_packet
= 1;
3742 regs
= alloca (rsa
->sizeof_g_packet
);
3744 /* Unimplemented registers read as all bits zero. */
3745 memset (regs
, 0, rsa
->sizeof_g_packet
);
3747 /* Reply describes registers byte by byte, each byte encoded as two
3748 hex characters. Suck them all up, then supply them to the
3749 register cacheing/storage mechanism. */
3752 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3754 if (p
[0] == 0 || p
[1] == 0)
3755 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3756 internal_error (__FILE__
, __LINE__
,
3757 "unexpected end of 'g' packet reply");
3759 if (p
[0] == 'x' && p
[1] == 'x')
3760 regs
[i
] = 0; /* 'x' */
3762 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3768 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
3770 struct packet_reg
*r
= &rsa
->regs
[i
];
3773 if (r
->offset
* 2 >= strlen (rs
->buf
))
3774 /* This shouldn't happen - we adjusted in_g_packet above. */
3775 internal_error (__FILE__
, __LINE__
,
3776 "unexpected end of 'g' packet reply");
3777 else if (rs
->buf
[r
->offset
* 2] == 'x')
3779 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3780 /* The register isn't available, mark it as such (at
3781 the same time setting the value to zero). */
3782 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3785 regcache_raw_supply (regcache
, r
->regnum
,
3793 fetch_registers_using_g (struct regcache
*regcache
)
3796 process_g_packet (regcache
);
3800 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3802 struct remote_state
*rs
= get_remote_state ();
3803 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3806 set_thread (PIDGET (inferior_ptid
), 1);
3810 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3811 gdb_assert (reg
!= NULL
);
3813 /* If this register might be in the 'g' packet, try that first -
3814 we are likely to read more than one register. If this is the
3815 first 'g' packet, we might be overly optimistic about its
3816 contents, so fall back to 'p'. */
3817 if (reg
->in_g_packet
)
3819 fetch_registers_using_g (regcache
);
3820 if (reg
->in_g_packet
)
3824 if (fetch_register_using_p (regcache
, reg
))
3827 /* This register is not available. */
3828 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3833 fetch_registers_using_g (regcache
);
3835 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3836 if (!rsa
->regs
[i
].in_g_packet
)
3837 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3839 /* This register is not available. */
3840 regcache_raw_supply (regcache
, i
, NULL
);
3844 /* Prepare to store registers. Since we may send them all (using a
3845 'G' request), we have to read out the ones we don't want to change
3849 remote_prepare_to_store (struct regcache
*regcache
)
3851 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3853 gdb_byte buf
[MAX_REGISTER_SIZE
];
3855 /* Make sure the entire registers array is valid. */
3856 switch (remote_protocol_packets
[PACKET_P
].support
)
3858 case PACKET_DISABLE
:
3859 case PACKET_SUPPORT_UNKNOWN
:
3860 /* Make sure all the necessary registers are cached. */
3861 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3862 if (rsa
->regs
[i
].in_g_packet
)
3863 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3870 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3871 packet was not recognized. */
3874 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3876 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3877 struct remote_state
*rs
= get_remote_state ();
3878 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3879 /* Try storing a single register. */
3880 char *buf
= rs
->buf
;
3881 gdb_byte regp
[MAX_REGISTER_SIZE
];
3884 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3887 if (reg
->pnum
== -1)
3890 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3891 p
= buf
+ strlen (buf
);
3892 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3893 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
3894 remote_send (&rs
->buf
, &rs
->buf_size
);
3896 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3901 error (_("Could not write register \"%s\""),
3902 gdbarch_register_name (gdbarch
, reg
->regnum
));
3903 case PACKET_UNKNOWN
:
3906 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3910 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3911 contents of the register cache buffer. FIXME: ignores errors. */
3914 store_registers_using_G (const struct regcache
*regcache
)
3916 struct remote_state
*rs
= get_remote_state ();
3917 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3921 /* Extract all the registers in the regcache copying them into a
3925 regs
= alloca (rsa
->sizeof_g_packet
);
3926 memset (regs
, 0, rsa
->sizeof_g_packet
);
3927 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3929 struct packet_reg
*r
= &rsa
->regs
[i
];
3931 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3935 /* Command describes registers byte by byte,
3936 each byte encoded as two hex characters. */
3939 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3941 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3942 remote_send (&rs
->buf
, &rs
->buf_size
);
3945 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3946 of the register cache buffer. FIXME: ignores errors. */
3949 remote_store_registers (struct regcache
*regcache
, int regnum
)
3951 struct remote_state
*rs
= get_remote_state ();
3952 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3955 set_thread (PIDGET (inferior_ptid
), 1);
3959 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3960 gdb_assert (reg
!= NULL
);
3962 /* Always prefer to store registers using the 'P' packet if
3963 possible; we often change only a small number of registers.
3964 Sometimes we change a larger number; we'd need help from a
3965 higher layer to know to use 'G'. */
3966 if (store_register_using_P (regcache
, reg
))
3969 /* For now, don't complain if we have no way to write the
3970 register. GDB loses track of unavailable registers too
3971 easily. Some day, this may be an error. We don't have
3972 any way to read the register, either... */
3973 if (!reg
->in_g_packet
)
3976 store_registers_using_G (regcache
);
3980 store_registers_using_G (regcache
);
3982 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3983 if (!rsa
->regs
[i
].in_g_packet
)
3984 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
3985 /* See above for why we do not issue an error here. */
3990 /* Return the number of hex digits in num. */
3993 hexnumlen (ULONGEST num
)
3997 for (i
= 0; num
!= 0; i
++)
4003 /* Set BUF to the minimum number of hex digits representing NUM. */
4006 hexnumstr (char *buf
, ULONGEST num
)
4008 int len
= hexnumlen (num
);
4009 return hexnumnstr (buf
, num
, len
);
4013 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
4016 hexnumnstr (char *buf
, ULONGEST num
, int width
)
4022 for (i
= width
- 1; i
>= 0; i
--)
4024 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
4031 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
4034 remote_address_masked (CORE_ADDR addr
)
4036 int address_size
= remote_address_size
;
4037 /* If "remoteaddresssize" was not set, default to target address size. */
4039 address_size
= gdbarch_addr_bit (current_gdbarch
);
4041 if (address_size
> 0
4042 && address_size
< (sizeof (ULONGEST
) * 8))
4044 /* Only create a mask when that mask can safely be constructed
4045 in a ULONGEST variable. */
4047 mask
= (mask
<< address_size
) - 1;
4053 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
4054 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
4055 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
4056 (which may be more than *OUT_LEN due to escape characters). The
4057 total number of bytes in the output buffer will be at most
4061 remote_escape_output (const gdb_byte
*buffer
, int len
,
4062 gdb_byte
*out_buf
, int *out_len
,
4065 int input_index
, output_index
;
4068 for (input_index
= 0; input_index
< len
; input_index
++)
4070 gdb_byte b
= buffer
[input_index
];
4072 if (b
== '$' || b
== '#' || b
== '}')
4074 /* These must be escaped. */
4075 if (output_index
+ 2 > out_maxlen
)
4077 out_buf
[output_index
++] = '}';
4078 out_buf
[output_index
++] = b
^ 0x20;
4082 if (output_index
+ 1 > out_maxlen
)
4084 out_buf
[output_index
++] = b
;
4088 *out_len
= input_index
;
4089 return output_index
;
4092 /* Convert BUFFER, escaped data LEN bytes long, into binary data
4093 in OUT_BUF. Return the number of bytes written to OUT_BUF.
4094 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
4096 This function reverses remote_escape_output. It allows more
4097 escaped characters than that function does, in particular because
4098 '*' must be escaped to avoid the run-length encoding processing
4099 in reading packets. */
4102 remote_unescape_input (const gdb_byte
*buffer
, int len
,
4103 gdb_byte
*out_buf
, int out_maxlen
)
4105 int input_index
, output_index
;
4110 for (input_index
= 0; input_index
< len
; input_index
++)
4112 gdb_byte b
= buffer
[input_index
];
4114 if (output_index
+ 1 > out_maxlen
)
4116 warning (_("Received too much data from remote target;"
4117 " ignoring overflow."));
4118 return output_index
;
4123 out_buf
[output_index
++] = b
^ 0x20;
4129 out_buf
[output_index
++] = b
;
4133 error (_("Unmatched escape character in target response."));
4135 return output_index
;
4138 /* Determine whether the remote target supports binary downloading.
4139 This is accomplished by sending a no-op memory write of zero length
4140 to the target at the specified address. It does not suffice to send
4141 the whole packet, since many stubs strip the eighth bit and
4142 subsequently compute a wrong checksum, which causes real havoc with
4145 NOTE: This can still lose if the serial line is not eight-bit
4146 clean. In cases like this, the user should clear "remote
4150 check_binary_download (CORE_ADDR addr
)
4152 struct remote_state
*rs
= get_remote_state ();
4154 switch (remote_protocol_packets
[PACKET_X
].support
)
4156 case PACKET_DISABLE
:
4160 case PACKET_SUPPORT_UNKNOWN
:
4166 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4168 p
+= hexnumstr (p
, (ULONGEST
) 0);
4172 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4173 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4175 if (rs
->buf
[0] == '\0')
4178 fprintf_unfiltered (gdb_stdlog
,
4179 "binary downloading NOT suppported by target\n");
4180 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4185 fprintf_unfiltered (gdb_stdlog
,
4186 "binary downloading suppported by target\n");
4187 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4194 /* Write memory data directly to the remote machine.
4195 This does not inform the data cache; the data cache uses this.
4196 HEADER is the starting part of the packet.
4197 MEMADDR is the address in the remote memory space.
4198 MYADDR is the address of the buffer in our space.
4199 LEN is the number of bytes.
4200 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4201 should send data as binary ('X'), or hex-encoded ('M').
4203 The function creates packet of the form
4204 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4206 where encoding of <DATA> is termined by PACKET_FORMAT.
4208 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4211 Returns the number of bytes transferred, or 0 (setting errno) for
4212 error. Only transfer a single packet. */
4215 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4216 const gdb_byte
*myaddr
, int len
,
4217 char packet_format
, int use_length
)
4219 struct remote_state
*rs
= get_remote_state ();
4229 if (packet_format
!= 'X' && packet_format
!= 'M')
4230 internal_error (__FILE__
, __LINE__
,
4231 "remote_write_bytes_aux: bad packet format");
4236 payload_size
= get_memory_write_packet_size ();
4238 /* The packet buffer will be large enough for the payload;
4239 get_memory_packet_size ensures this. */
4242 /* Compute the size of the actual payload by subtracting out the
4243 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4245 payload_size
-= strlen ("$,:#NN");
4247 /* The comma won't be used. */
4249 header_length
= strlen (header
);
4250 payload_size
-= header_length
;
4251 payload_size
-= hexnumlen (memaddr
);
4253 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4255 strcat (rs
->buf
, header
);
4256 p
= rs
->buf
+ strlen (header
);
4258 /* Compute a best guess of the number of bytes actually transfered. */
4259 if (packet_format
== 'X')
4261 /* Best guess at number of bytes that will fit. */
4262 todo
= min (len
, payload_size
);
4264 payload_size
-= hexnumlen (todo
);
4265 todo
= min (todo
, payload_size
);
4269 /* Num bytes that will fit. */
4270 todo
= min (len
, payload_size
/ 2);
4272 payload_size
-= hexnumlen (todo
);
4273 todo
= min (todo
, payload_size
/ 2);
4277 internal_error (__FILE__
, __LINE__
,
4278 _("minumum packet size too small to write data"));
4280 /* If we already need another packet, then try to align the end
4281 of this packet to a useful boundary. */
4282 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4283 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4285 /* Append "<memaddr>". */
4286 memaddr
= remote_address_masked (memaddr
);
4287 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4294 /* Append <len>. Retain the location/size of <len>. It may need to
4295 be adjusted once the packet body has been created. */
4297 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4305 /* Append the packet body. */
4306 if (packet_format
== 'X')
4308 /* Binary mode. Send target system values byte by byte, in
4309 increasing byte addresses. Only escape certain critical
4311 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4314 /* If not all TODO bytes fit, then we'll need another packet. Make
4315 a second try to keep the end of the packet aligned. Don't do
4316 this if the packet is tiny. */
4317 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4321 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4323 if (new_nr_bytes
!= nr_bytes
)
4324 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4329 p
+= payload_length
;
4330 if (use_length
&& nr_bytes
< todo
)
4332 /* Escape chars have filled up the buffer prematurely,
4333 and we have actually sent fewer bytes than planned.
4334 Fix-up the length field of the packet. Use the same
4335 number of characters as before. */
4336 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4337 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4342 /* Normal mode: Send target system values byte by byte, in
4343 increasing byte addresses. Each byte is encoded as a two hex
4345 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4349 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4350 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4352 if (rs
->buf
[0] == 'E')
4354 /* There is no correspondance between what the remote protocol
4355 uses for errors and errno codes. We would like a cleaner way
4356 of representing errors (big enough to include errno codes,
4357 bfd_error codes, and others). But for now just return EIO. */
4362 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4363 fewer bytes than we'd planned. */
4367 /* Write memory data directly to the remote machine.
4368 This does not inform the data cache; the data cache uses this.
4369 MEMADDR is the address in the remote memory space.
4370 MYADDR is the address of the buffer in our space.
4371 LEN is the number of bytes.
4373 Returns number of bytes transferred, or 0 (setting errno) for
4374 error. Only transfer a single packet. */
4377 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4379 char *packet_format
= 0;
4381 /* Check whether the target supports binary download. */
4382 check_binary_download (memaddr
);
4384 switch (remote_protocol_packets
[PACKET_X
].support
)
4387 packet_format
= "X";
4389 case PACKET_DISABLE
:
4390 packet_format
= "M";
4392 case PACKET_SUPPORT_UNKNOWN
:
4393 internal_error (__FILE__
, __LINE__
,
4394 _("remote_write_bytes: bad internal state"));
4396 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4399 return remote_write_bytes_aux (packet_format
,
4400 memaddr
, myaddr
, len
, packet_format
[0], 1);
4403 /* Read memory data directly from the remote machine.
4404 This does not use the data cache; the data cache uses this.
4405 MEMADDR is the address in the remote memory space.
4406 MYADDR is the address of the buffer in our space.
4407 LEN is the number of bytes.
4409 Returns number of bytes transferred, or 0 for error. */
4411 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4412 remote targets) shouldn't attempt to read the entire buffer.
4413 Instead it should read a single packet worth of data and then
4414 return the byte size of that packet to the caller. The caller (its
4415 caller and its callers caller ;-) already contains code for
4416 handling partial reads. */
4419 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4421 struct remote_state
*rs
= get_remote_state ();
4422 int max_buf_size
; /* Max size of packet output buffer. */
4428 max_buf_size
= get_memory_read_packet_size ();
4429 /* The packet buffer will be large enough for the payload;
4430 get_memory_packet_size ensures this. */
4439 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4441 /* construct "m"<memaddr>","<len>" */
4442 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4443 memaddr
= remote_address_masked (memaddr
);
4446 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4448 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4452 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4454 if (rs
->buf
[0] == 'E'
4455 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4456 && rs
->buf
[3] == '\0')
4458 /* There is no correspondance between what the remote
4459 protocol uses for errors and errno codes. We would like
4460 a cleaner way of representing errors (big enough to
4461 include errno codes, bfd_error codes, and others). But
4462 for now just return EIO. */
4467 /* Reply describes memory byte by byte,
4468 each byte encoded as two hex characters. */
4471 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4473 /* Reply is short. This means that we were able to read
4474 only part of what we wanted to. */
4475 return i
+ (origlen
- len
);
4484 /* Read or write LEN bytes from inferior memory at MEMADDR,
4485 transferring to or from debugger address BUFFER. Write to inferior
4486 if SHOULD_WRITE is nonzero. Returns length of data written or
4487 read; 0 for error. TARGET is unused. */
4490 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4491 int should_write
, struct mem_attrib
*attrib
,
4492 struct target_ops
*target
)
4497 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4499 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4504 /* Sends a packet with content determined by the printf format string
4505 FORMAT and the remaining arguments, then gets the reply. Returns
4506 whether the packet was a success, a failure, or unknown. */
4509 remote_send_printf (const char *format
, ...)
4511 struct remote_state
*rs
= get_remote_state ();
4512 int max_size
= get_remote_packet_size ();
4515 va_start (ap
, format
);
4518 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4519 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4521 if (putpkt (rs
->buf
) < 0)
4522 error (_("Communication problem with target."));
4525 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4527 return packet_check_result (rs
->buf
);
4531 restore_remote_timeout (void *p
)
4533 int value
= *(int *)p
;
4534 remote_timeout
= value
;
4537 /* Flash writing can take quite some time. We'll set
4538 effectively infinite timeout for flash operations.
4539 In future, we'll need to decide on a better approach. */
4540 static const int remote_flash_timeout
= 1000;
4543 remote_flash_erase (struct target_ops
*ops
,
4544 ULONGEST address
, LONGEST length
)
4546 int saved_remote_timeout
= remote_timeout
;
4547 enum packet_result ret
;
4549 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4550 &saved_remote_timeout
);
4551 remote_timeout
= remote_flash_timeout
;
4553 ret
= remote_send_printf ("vFlashErase:%s,%s",
4558 case PACKET_UNKNOWN
:
4559 error (_("Remote target does not support flash erase"));
4561 error (_("Error erasing flash with vFlashErase packet"));
4566 do_cleanups (back_to
);
4570 remote_flash_write (struct target_ops
*ops
,
4571 ULONGEST address
, LONGEST length
,
4572 const gdb_byte
*data
)
4574 int saved_remote_timeout
= remote_timeout
;
4576 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4577 &saved_remote_timeout
);
4579 remote_timeout
= remote_flash_timeout
;
4580 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4581 do_cleanups (back_to
);
4587 remote_flash_done (struct target_ops
*ops
)
4589 int saved_remote_timeout
= remote_timeout
;
4591 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4592 &saved_remote_timeout
);
4594 remote_timeout
= remote_flash_timeout
;
4595 ret
= remote_send_printf ("vFlashDone");
4596 do_cleanups (back_to
);
4600 case PACKET_UNKNOWN
:
4601 error (_("Remote target does not support vFlashDone"));
4603 error (_("Error finishing flash operation"));
4610 remote_files_info (struct target_ops
*ignore
)
4612 puts_filtered ("Debugging a target over a serial line.\n");
4615 /* Stuff for dealing with the packets which are part of this protocol.
4616 See comment at top of file for details. */
4618 /* Read a single character from the remote end. */
4621 readchar (int timeout
)
4625 ch
= serial_readchar (remote_desc
, timeout
);
4630 switch ((enum serial_rc
) ch
)
4633 target_mourn_inferior ();
4634 error (_("Remote connection closed"));
4637 perror_with_name (_("Remote communication error"));
4639 case SERIAL_TIMEOUT
:
4645 /* Send the command in *BUF to the remote machine, and read the reply
4646 into *BUF. Report an error if we get an error reply. Resize
4647 *BUF using xrealloc if necessary to hold the result, and update
4651 remote_send (char **buf
,
4655 getpkt (buf
, sizeof_buf
, 0);
4657 if ((*buf
)[0] == 'E')
4658 error (_("Remote failure reply: %s"), *buf
);
4661 /* Display a null-terminated packet on stdout, for debugging, using C
4665 print_packet (char *buf
)
4667 puts_filtered ("\"");
4668 fputstr_filtered (buf
, '"', gdb_stdout
);
4669 puts_filtered ("\"");
4675 return putpkt_binary (buf
, strlen (buf
));
4678 /* Send a packet to the remote machine, with error checking. The data
4679 of the packet is in BUF. The string in BUF can be at most
4680 get_remote_packet_size () - 5 to account for the $, # and checksum,
4681 and for a possible /0 if we are debugging (remote_debug) and want
4682 to print the sent packet as a string. */
4685 putpkt_binary (char *buf
, int cnt
)
4688 unsigned char csum
= 0;
4689 char *buf2
= alloca (cnt
+ 6);
4695 /* Copy the packet into buffer BUF2, encapsulating it
4696 and giving it a checksum. */
4701 for (i
= 0; i
< cnt
; i
++)
4707 *p
++ = tohex ((csum
>> 4) & 0xf);
4708 *p
++ = tohex (csum
& 0xf);
4710 /* Send it over and over until we get a positive ack. */
4714 int started_error_output
= 0;
4719 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4720 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4721 fprintf_unfiltered (gdb_stdlog
, "...");
4722 gdb_flush (gdb_stdlog
);
4724 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4725 perror_with_name (_("putpkt: write failed"));
4727 /* Read until either a timeout occurs (-2) or '+' is read. */
4730 ch
= readchar (remote_timeout
);
4738 case SERIAL_TIMEOUT
:
4740 if (started_error_output
)
4742 putchar_unfiltered ('\n');
4743 started_error_output
= 0;
4752 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4756 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4757 case SERIAL_TIMEOUT
:
4761 break; /* Retransmit buffer. */
4765 fprintf_unfiltered (gdb_stdlog
,
4766 "Packet instead of Ack, ignoring it\n");
4767 /* It's probably an old response sent because an ACK
4768 was lost. Gobble up the packet and ack it so it
4769 doesn't get retransmitted when we resend this
4772 serial_write (remote_desc
, "+", 1);
4773 continue; /* Now, go look for +. */
4778 if (!started_error_output
)
4780 started_error_output
= 1;
4781 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4783 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4787 break; /* Here to retransmit. */
4791 /* This is wrong. If doing a long backtrace, the user should be
4792 able to get out next time we call QUIT, without anything as
4793 violent as interrupt_query. If we want to provide a way out of
4794 here without getting to the next QUIT, it should be based on
4795 hitting ^C twice as in remote_wait. */
4805 /* Come here after finding the start of a frame when we expected an
4806 ack. Do our best to discard the rest of this packet. */
4815 c
= readchar (remote_timeout
);
4818 case SERIAL_TIMEOUT
:
4819 /* Nothing we can do. */
4822 /* Discard the two bytes of checksum and stop. */
4823 c
= readchar (remote_timeout
);
4825 c
= readchar (remote_timeout
);
4828 case '*': /* Run length encoding. */
4829 /* Discard the repeat count. */
4830 c
= readchar (remote_timeout
);
4835 /* A regular character. */
4841 /* Come here after finding the start of the frame. Collect the rest
4842 into *BUF, verifying the checksum, length, and handling run-length
4843 compression. NUL terminate the buffer. If there is not enough room,
4844 expand *BUF using xrealloc.
4846 Returns -1 on error, number of characters in buffer (ignoring the
4847 trailing NULL) on success. (could be extended to return one of the
4848 SERIAL status indications). */
4851 read_frame (char **buf_p
,
4864 c
= readchar (remote_timeout
);
4867 case SERIAL_TIMEOUT
:
4869 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4873 fputs_filtered ("Saw new packet start in middle of old one\n",
4875 return -1; /* Start a new packet, count retries. */
4878 unsigned char pktcsum
;
4884 check_0
= readchar (remote_timeout
);
4886 check_1
= readchar (remote_timeout
);
4888 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4891 fputs_filtered ("Timeout in checksum, retrying\n",
4895 else if (check_0
< 0 || check_1
< 0)
4898 fputs_filtered ("Communication error in checksum\n",
4903 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4904 if (csum
== pktcsum
)
4909 fprintf_filtered (gdb_stdlog
,
4910 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4912 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4913 fputs_filtered ("\n", gdb_stdlog
);
4915 /* Number of characters in buffer ignoring trailing
4919 case '*': /* Run length encoding. */
4924 c
= readchar (remote_timeout
);
4926 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4928 /* The character before ``*'' is repeated. */
4930 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4932 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4934 /* Make some more room in the buffer. */
4935 *sizeof_buf
+= repeat
;
4936 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4940 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4946 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4950 if (bc
>= *sizeof_buf
- 1)
4952 /* Make some more room in the buffer. */
4954 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4965 /* Read a packet from the remote machine, with error checking, and
4966 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4967 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4968 rather than timing out; this is used (in synchronous mode) to wait
4969 for a target that is is executing user code to stop. */
4970 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4971 don't have to change all the calls to getpkt to deal with the
4972 return value, because at the moment I don't know what the right
4973 thing to do it for those. */
4981 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4985 /* Read a packet from the remote machine, with error checking, and
4986 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4987 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4988 rather than timing out; this is used (in synchronous mode) to wait
4989 for a target that is is executing user code to stop. If FOREVER ==
4990 0, this function is allowed to time out gracefully and return an
4991 indication of this to the caller. Otherwise return the number
4994 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
5001 strcpy (*buf
, "timeout");
5005 timeout
= watchdog
> 0 ? watchdog
: -1;
5009 timeout
= remote_timeout
;
5013 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
5015 /* This can loop forever if the remote side sends us characters
5016 continuously, but if it pauses, we'll get a zero from
5017 readchar because of timeout. Then we'll count that as a
5020 /* Note that we will only wait forever prior to the start of a
5021 packet. After that, we expect characters to arrive at a
5022 brisk pace. They should show up within remote_timeout
5027 c
= readchar (timeout
);
5029 if (c
== SERIAL_TIMEOUT
)
5031 if (forever
) /* Watchdog went off? Kill the target. */
5034 target_mourn_inferior ();
5035 error (_("Watchdog timeout has expired. Target detached."));
5038 fputs_filtered ("Timed out.\n", gdb_stdlog
);
5044 /* We've found the start of a packet, now collect the data. */
5046 val
= read_frame (buf
, sizeof_buf
);
5052 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
5053 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
5054 fprintf_unfiltered (gdb_stdlog
, "\n");
5056 serial_write (remote_desc
, "+", 1);
5060 /* Try the whole thing again. */
5062 serial_write (remote_desc
, "-", 1);
5065 /* We have tried hard enough, and just can't receive the packet.
5068 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
5069 serial_write (remote_desc
, "+", 1);
5076 /* For some mysterious reason, wait_for_inferior calls kill instead of
5077 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5081 target_mourn_inferior ();
5085 /* Use catch_errors so the user can quit from gdb even when we aren't on
5086 speaking terms with the remote system. */
5087 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5089 /* Don't wait for it to die. I'm not really sure it matters whether
5090 we do or not. For the existing stubs, kill is a noop. */
5091 target_mourn_inferior ();
5094 /* Async version of remote_kill. */
5096 remote_async_kill (void)
5098 /* Unregister the file descriptor from the event loop. */
5099 if (target_is_async_p ())
5100 serial_async (remote_desc
, NULL
, 0);
5102 /* For some mysterious reason, wait_for_inferior calls kill instead of
5103 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5107 target_mourn_inferior ();
5111 /* Use catch_errors so the user can quit from gdb even when we
5112 aren't on speaking terms with the remote system. */
5113 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5115 /* Don't wait for it to die. I'm not really sure it matters whether
5116 we do or not. For the existing stubs, kill is a noop. */
5117 target_mourn_inferior ();
5123 remote_mourn_1 (&remote_ops
);
5127 remote_async_mourn (void)
5129 remote_mourn_1 (&remote_async_ops
);
5133 extended_remote_mourn (void)
5135 /* We do _not_ want to mourn the target like this; this will
5136 remove the extended remote target from the target stack,
5137 and the next time the user says "run" it'll fail.
5139 FIXME: What is the right thing to do here? */
5141 remote_mourn_1 (&extended_remote_ops
);
5145 /* Worker function for remote_mourn. */
5147 remote_mourn_1 (struct target_ops
*target
)
5149 unpush_target (target
);
5150 generic_mourn_inferior ();
5153 /* In the extended protocol we want to be able to do things like
5154 "run" and have them basically work as expected. So we need
5155 a special create_inferior function.
5157 FIXME: One day add support for changing the exec file
5158 we're debugging, arguments and an environment. */
5161 extended_remote_create_inferior (char *exec_file
, char *args
,
5162 char **env
, int from_tty
)
5164 /* Rip out the breakpoints; we'll reinsert them after restarting
5165 the remote server. */
5166 remove_breakpoints ();
5168 /* Now restart the remote server. */
5169 extended_remote_restart ();
5171 /* NOTE: We don't need to recheck for a target description here; but
5172 if we gain the ability to switch the remote executable we may
5173 need to, if for instance we are running a process which requested
5174 different emulated hardware from the operating system. A
5175 concrete example of this is ARM GNU/Linux, where some binaries
5176 will have a legacy FPA coprocessor emulated and others may have
5177 access to a hardware VFP unit. */
5179 /* Now put the breakpoints back in. This way we're safe if the
5180 restart function works via a unix fork on the remote side. */
5181 insert_breakpoints ();
5183 /* Clean up from the last time we were running. */
5184 clear_proceed_status ();
5187 /* Async version of extended_remote_create_inferior. */
5189 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5190 char **env
, int from_tty
)
5192 /* Rip out the breakpoints; we'll reinsert them after restarting
5193 the remote server. */
5194 remove_breakpoints ();
5196 /* If running asynchronously, register the target file descriptor
5197 with the event loop. */
5198 if (target_can_async_p ())
5199 target_async (inferior_event_handler
, 0);
5201 /* Now restart the remote server. */
5202 extended_remote_restart ();
5204 /* NOTE: We don't need to recheck for a target description here; but
5205 if we gain the ability to switch the remote executable we may
5206 need to, if for instance we are running a process which requested
5207 different emulated hardware from the operating system. A
5208 concrete example of this is ARM GNU/Linux, where some binaries
5209 will have a legacy FPA coprocessor emulated and others may have
5210 access to a hardware VFP unit. */
5212 /* Now put the breakpoints back in. This way we're safe if the
5213 restart function works via a unix fork on the remote side. */
5214 insert_breakpoints ();
5216 /* Clean up from the last time we were running. */
5217 clear_proceed_status ();
5221 /* Insert a breakpoint. On targets that have software breakpoint
5222 support, we ask the remote target to do the work; on targets
5223 which don't, we insert a traditional memory breakpoint. */
5226 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5228 CORE_ADDR addr
= bp_tgt
->placed_address
;
5229 struct remote_state
*rs
= get_remote_state ();
5231 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5232 If it succeeds, then set the support to PACKET_ENABLE. If it
5233 fails, and the user has explicitly requested the Z support then
5234 report an error, otherwise, mark it disabled and go on. */
5236 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5243 gdbarch_breakpoint_from_pc
5244 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5245 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5246 p
+= hexnumstr (p
, addr
);
5247 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5250 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5252 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5258 case PACKET_UNKNOWN
:
5263 return memory_insert_breakpoint (bp_tgt
);
5267 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5269 CORE_ADDR addr
= bp_tgt
->placed_address
;
5270 struct remote_state
*rs
= get_remote_state ();
5273 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5281 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5282 p
+= hexnumstr (p
, addr
);
5283 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5286 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5288 return (rs
->buf
[0] == 'E');
5291 return memory_remove_breakpoint (bp_tgt
);
5295 watchpoint_to_Z_packet (int type
)
5300 return Z_PACKET_WRITE_WP
;
5303 return Z_PACKET_READ_WP
;
5306 return Z_PACKET_ACCESS_WP
;
5309 internal_error (__FILE__
, __LINE__
,
5310 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5315 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5317 struct remote_state
*rs
= get_remote_state ();
5319 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5321 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5324 sprintf (rs
->buf
, "Z%x,", packet
);
5325 p
= strchr (rs
->buf
, '\0');
5326 addr
= remote_address_masked (addr
);
5327 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5328 sprintf (p
, ",%x", len
);
5331 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5333 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5336 case PACKET_UNKNOWN
:
5341 internal_error (__FILE__
, __LINE__
,
5342 _("remote_insert_watchpoint: reached end of function"));
5347 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5349 struct remote_state
*rs
= get_remote_state ();
5351 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5353 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5356 sprintf (rs
->buf
, "z%x,", packet
);
5357 p
= strchr (rs
->buf
, '\0');
5358 addr
= remote_address_masked (addr
);
5359 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5360 sprintf (p
, ",%x", len
);
5362 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5364 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5367 case PACKET_UNKNOWN
:
5372 internal_error (__FILE__
, __LINE__
,
5373 _("remote_remove_watchpoint: reached end of function"));
5377 int remote_hw_watchpoint_limit
= -1;
5378 int remote_hw_breakpoint_limit
= -1;
5381 remote_check_watch_resources (int type
, int cnt
, int ot
)
5383 if (type
== bp_hardware_breakpoint
)
5385 if (remote_hw_breakpoint_limit
== 0)
5387 else if (remote_hw_breakpoint_limit
< 0)
5389 else if (cnt
<= remote_hw_breakpoint_limit
)
5394 if (remote_hw_watchpoint_limit
== 0)
5396 else if (remote_hw_watchpoint_limit
< 0)
5400 else if (cnt
<= remote_hw_watchpoint_limit
)
5407 remote_stopped_by_watchpoint (void)
5409 return remote_stopped_by_watchpoint_p
;
5413 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5416 if (remote_stopped_by_watchpoint ())
5418 *addr_p
= remote_watch_data_address
;
5427 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5430 struct remote_state
*rs
= get_remote_state ();
5433 /* The length field should be set to the size of a breakpoint
5434 instruction, even though we aren't inserting one ourselves. */
5436 gdbarch_breakpoint_from_pc
5437 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5439 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5446 addr
= remote_address_masked (bp_tgt
->placed_address
);
5447 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5448 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5451 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5453 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5456 case PACKET_UNKNOWN
:
5461 internal_error (__FILE__
, __LINE__
,
5462 _("remote_insert_hw_breakpoint: reached end of function"));
5467 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5470 struct remote_state
*rs
= get_remote_state ();
5473 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5480 addr
= remote_address_masked (bp_tgt
->placed_address
);
5481 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5482 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5485 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5487 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5490 case PACKET_UNKNOWN
:
5495 internal_error (__FILE__
, __LINE__
,
5496 _("remote_remove_hw_breakpoint: reached end of function"));
5499 /* Some targets are only capable of doing downloads, and afterwards
5500 they switch to the remote serial protocol. This function provides
5501 a clean way to get from the download target to the remote target.
5502 It's basically just a wrapper so that we don't have to expose any
5503 of the internal workings of remote.c.
5505 Prior to calling this routine, you should shutdown the current
5506 target code, else you will get the "A program is being debugged
5507 already..." message. Usually a call to pop_target() suffices. */
5510 push_remote_target (char *name
, int from_tty
)
5512 printf_filtered (_("Switching to remote protocol\n"));
5513 remote_open (name
, from_tty
);
5516 /* Table used by the crc32 function to calcuate the checksum. */
5518 static unsigned long crc32_table
[256] =
5521 static unsigned long
5522 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5524 if (!crc32_table
[1])
5526 /* Initialize the CRC table and the decoding table. */
5530 for (i
= 0; i
< 256; i
++)
5532 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5533 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5540 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5546 /* compare-sections command
5548 With no arguments, compares each loadable section in the exec bfd
5549 with the same memory range on the target, and reports mismatches.
5550 Useful for verifying the image on the target against the exec file.
5551 Depends on the target understanding the new "qCRC:" request. */
5553 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5554 target method (target verify memory) and generic version of the
5555 actual command. This will allow other high-level code (especially
5556 generic_load()) to make use of this target functionality. */
5559 compare_sections_command (char *args
, int from_tty
)
5561 struct remote_state
*rs
= get_remote_state ();
5563 unsigned long host_crc
, target_crc
;
5564 extern bfd
*exec_bfd
;
5565 struct cleanup
*old_chain
;
5568 const char *sectname
;
5575 error (_("command cannot be used without an exec file"));
5576 if (!current_target
.to_shortname
||
5577 strcmp (current_target
.to_shortname
, "remote") != 0)
5578 error (_("command can only be used with remote target"));
5580 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5582 if (!(s
->flags
& SEC_LOAD
))
5583 continue; /* skip non-loadable section */
5585 size
= bfd_get_section_size (s
);
5587 continue; /* skip zero-length section */
5589 sectname
= bfd_get_section_name (exec_bfd
, s
);
5590 if (args
&& strcmp (args
, sectname
) != 0)
5591 continue; /* not the section selected by user */
5593 matched
= 1; /* do this section */
5595 /* FIXME: assumes lma can fit into long. */
5596 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5597 (long) lma
, (long) size
);
5600 /* Be clever; compute the host_crc before waiting for target
5602 sectdata
= xmalloc (size
);
5603 old_chain
= make_cleanup (xfree
, sectdata
);
5604 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5605 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5607 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5608 if (rs
->buf
[0] == 'E')
5609 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5610 sectname
, paddr (lma
), paddr (lma
+ size
));
5611 if (rs
->buf
[0] != 'C')
5612 error (_("remote target does not support this operation"));
5614 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5615 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5617 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5618 sectname
, paddr (lma
), paddr (lma
+ size
));
5619 if (host_crc
== target_crc
)
5620 printf_filtered ("matched.\n");
5623 printf_filtered ("MIS-MATCHED!\n");
5627 do_cleanups (old_chain
);
5630 warning (_("One or more sections of the remote executable does not match\n\
5631 the loaded file\n"));
5632 if (args
&& !matched
)
5633 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5636 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5637 into remote target. The number of bytes written to the remote
5638 target is returned, or -1 for error. */
5641 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
5642 const char *annex
, const gdb_byte
*writebuf
,
5643 ULONGEST offset
, LONGEST len
,
5644 struct packet_config
*packet
)
5649 struct remote_state
*rs
= get_remote_state ();
5650 int max_size
= get_memory_write_packet_size ();
5652 if (packet
->support
== PACKET_DISABLE
)
5655 /* Insert header. */
5656 i
= snprintf (rs
->buf
, max_size
,
5657 "qXfer:%s:write:%s:%s:",
5658 object_name
, annex
? annex
: "",
5659 phex_nz (offset
, sizeof offset
));
5660 max_size
-= (i
+ 1);
5662 /* Escape as much data as fits into rs->buf. */
5663 buf_len
= remote_escape_output
5664 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
5666 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
5667 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
5668 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5671 unpack_varlen_hex (rs
->buf
, &n
);
5675 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5676 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5677 number of bytes read is returned, or 0 for EOF, or -1 for error.
5678 The number of bytes read may be less than LEN without indicating an
5679 EOF. PACKET is checked and updated to indicate whether the remote
5680 target supports this object. */
5683 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5685 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5686 struct packet_config
*packet
)
5688 static char *finished_object
;
5689 static char *finished_annex
;
5690 static ULONGEST finished_offset
;
5692 struct remote_state
*rs
= get_remote_state ();
5693 unsigned int total
= 0;
5694 LONGEST i
, n
, packet_len
;
5696 if (packet
->support
== PACKET_DISABLE
)
5699 /* Check whether we've cached an end-of-object packet that matches
5701 if (finished_object
)
5703 if (strcmp (object_name
, finished_object
) == 0
5704 && strcmp (annex
? annex
: "", finished_annex
) == 0
5705 && offset
== finished_offset
)
5708 /* Otherwise, we're now reading something different. Discard
5710 xfree (finished_object
);
5711 xfree (finished_annex
);
5712 finished_object
= NULL
;
5713 finished_annex
= NULL
;
5716 /* Request only enough to fit in a single packet. The actual data
5717 may not, since we don't know how much of it will need to be escaped;
5718 the target is free to respond with slightly less data. We subtract
5719 five to account for the response type and the protocol frame. */
5720 n
= min (get_remote_packet_size () - 5, len
);
5721 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5722 object_name
, annex
? annex
: "",
5723 phex_nz (offset
, sizeof offset
),
5724 phex_nz (n
, sizeof n
));
5725 i
= putpkt (rs
->buf
);
5730 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5731 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5734 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5735 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5737 /* 'm' means there is (or at least might be) more data after this
5738 batch. That does not make sense unless there's at least one byte
5739 of data in this reply. */
5740 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5741 error (_("Remote qXfer reply contained no data."));
5743 /* Got some data. */
5744 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5746 /* 'l' is an EOF marker, possibly including a final block of data,
5747 or possibly empty. If we have the final block of a non-empty
5748 object, record this fact to bypass a subsequent partial read. */
5749 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
5751 finished_object
= xstrdup (object_name
);
5752 finished_annex
= xstrdup (annex
? annex
: "");
5753 finished_offset
= offset
+ i
;
5760 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5761 const char *annex
, gdb_byte
*readbuf
,
5762 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5764 struct remote_state
*rs
= get_remote_state ();
5769 /* Handle memory using the standard memory routines. */
5770 if (object
== TARGET_OBJECT_MEMORY
)
5775 if (writebuf
!= NULL
)
5776 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5778 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5782 else if (xfered
== 0 && errno
== 0)
5788 /* Handle SPU memory using qxfer packets. */
5789 if (object
== TARGET_OBJECT_SPU
)
5792 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
5793 &remote_protocol_packets
5794 [PACKET_qXfer_spu_read
]);
5796 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
5797 &remote_protocol_packets
5798 [PACKET_qXfer_spu_write
]);
5801 /* Only handle flash writes. */
5802 if (writebuf
!= NULL
)
5808 case TARGET_OBJECT_FLASH
:
5809 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5813 else if (xfered
== 0 && errno
== 0)
5823 /* Map pre-existing objects onto letters. DO NOT do this for new
5824 objects!!! Instead specify new query packets. */
5827 case TARGET_OBJECT_AVR
:
5831 case TARGET_OBJECT_AUXV
:
5832 gdb_assert (annex
== NULL
);
5833 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5834 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5836 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5837 return remote_read_qxfer
5838 (ops
, "features", annex
, readbuf
, offset
, len
,
5839 &remote_protocol_packets
[PACKET_qXfer_features
]);
5841 case TARGET_OBJECT_LIBRARIES
:
5842 return remote_read_qxfer
5843 (ops
, "libraries", annex
, readbuf
, offset
, len
,
5844 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
5846 case TARGET_OBJECT_MEMORY_MAP
:
5847 gdb_assert (annex
== NULL
);
5848 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5849 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5855 /* Note: a zero OFFSET and LEN can be used to query the minimum
5857 if (offset
== 0 && len
== 0)
5858 return (get_remote_packet_size ());
5859 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5860 large enough let the caller deal with it. */
5861 if (len
< get_remote_packet_size ())
5863 len
= get_remote_packet_size ();
5865 /* Except for querying the minimum buffer size, target must be open. */
5867 error (_("remote query is only available after target open"));
5869 gdb_assert (annex
!= NULL
);
5870 gdb_assert (readbuf
!= NULL
);
5876 /* We used one buffer char for the remote protocol q command and
5877 another for the query type. As the remote protocol encapsulation
5878 uses 4 chars plus one extra in case we are debugging
5879 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5882 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5884 /* Bad caller may have sent forbidden characters. */
5885 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5890 gdb_assert (annex
[i
] == '\0');
5892 i
= putpkt (rs
->buf
);
5896 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5897 strcpy ((char *) readbuf
, rs
->buf
);
5899 return strlen ((char *) readbuf
);
5903 remote_rcmd (char *command
,
5904 struct ui_file
*outbuf
)
5906 struct remote_state
*rs
= get_remote_state ();
5910 error (_("remote rcmd is only available after target open"));
5912 /* Send a NULL command across as an empty command. */
5913 if (command
== NULL
)
5916 /* The query prefix. */
5917 strcpy (rs
->buf
, "qRcmd,");
5918 p
= strchr (rs
->buf
, '\0');
5920 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5921 error (_("\"monitor\" command ``%s'' is too long."), command
);
5923 /* Encode the actual command. */
5924 bin2hex ((gdb_byte
*) command
, p
, 0);
5926 if (putpkt (rs
->buf
) < 0)
5927 error (_("Communication problem with target."));
5929 /* get/display the response */
5934 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5936 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5939 error (_("Target does not support this command."));
5940 if (buf
[0] == 'O' && buf
[1] != 'K')
5942 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5945 if (strcmp (buf
, "OK") == 0)
5947 if (strlen (buf
) == 3 && buf
[0] == 'E'
5948 && isdigit (buf
[1]) && isdigit (buf
[2]))
5950 error (_("Protocol error with Rcmd"));
5952 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5954 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5955 fputc_unfiltered (c
, outbuf
);
5961 static VEC(mem_region_s
) *
5962 remote_memory_map (struct target_ops
*ops
)
5964 VEC(mem_region_s
) *result
= NULL
;
5965 char *text
= target_read_stralloc (¤t_target
,
5966 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5970 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5971 result
= parse_memory_map (text
);
5972 do_cleanups (back_to
);
5979 packet_command (char *args
, int from_tty
)
5981 struct remote_state
*rs
= get_remote_state ();
5984 error (_("command can only be used with remote target"));
5987 error (_("remote-packet command requires packet text as argument"));
5989 puts_filtered ("sending: ");
5990 print_packet (args
);
5991 puts_filtered ("\n");
5994 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5995 puts_filtered ("received: ");
5996 print_packet (rs
->buf
);
5997 puts_filtered ("\n");
6001 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
6003 static void display_thread_info (struct gdb_ext_thread_info
*info
);
6005 static void threadset_test_cmd (char *cmd
, int tty
);
6007 static void threadalive_test (char *cmd
, int tty
);
6009 static void threadlist_test_cmd (char *cmd
, int tty
);
6011 int get_and_display_threadinfo (threadref
*ref
);
6013 static void threadinfo_test_cmd (char *cmd
, int tty
);
6015 static int thread_display_step (threadref
*ref
, void *context
);
6017 static void threadlist_update_test_cmd (char *cmd
, int tty
);
6019 static void init_remote_threadtests (void);
6021 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
6024 threadset_test_cmd (char *cmd
, int tty
)
6026 int sample_thread
= SAMPLE_THREAD
;
6028 printf_filtered (_("Remote threadset test\n"));
6029 set_thread (sample_thread
, 1);
6034 threadalive_test (char *cmd
, int tty
)
6036 int sample_thread
= SAMPLE_THREAD
;
6038 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
6039 printf_filtered ("PASS: Thread alive test\n");
6041 printf_filtered ("FAIL: Thread alive test\n");
6044 void output_threadid (char *title
, threadref
*ref
);
6047 output_threadid (char *title
, threadref
*ref
)
6051 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
6053 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
6057 threadlist_test_cmd (char *cmd
, int tty
)
6060 threadref nextthread
;
6061 int done
, result_count
;
6062 threadref threadlist
[3];
6064 printf_filtered ("Remote Threadlist test\n");
6065 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
6066 &result_count
, &threadlist
[0]))
6067 printf_filtered ("FAIL: threadlist test\n");
6070 threadref
*scan
= threadlist
;
6071 threadref
*limit
= scan
+ result_count
;
6073 while (scan
< limit
)
6074 output_threadid (" thread ", scan
++);
6079 display_thread_info (struct gdb_ext_thread_info
*info
)
6081 output_threadid ("Threadid: ", &info
->threadid
);
6082 printf_filtered ("Name: %s\n ", info
->shortname
);
6083 printf_filtered ("State: %s\n", info
->display
);
6084 printf_filtered ("other: %s\n\n", info
->more_display
);
6088 get_and_display_threadinfo (threadref
*ref
)
6092 struct gdb_ext_thread_info threadinfo
;
6094 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
6095 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
6096 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
6097 display_thread_info (&threadinfo
);
6102 threadinfo_test_cmd (char *cmd
, int tty
)
6104 int athread
= SAMPLE_THREAD
;
6108 int_to_threadref (&thread
, athread
);
6109 printf_filtered ("Remote Threadinfo test\n");
6110 if (!get_and_display_threadinfo (&thread
))
6111 printf_filtered ("FAIL cannot get thread info\n");
6115 thread_display_step (threadref
*ref
, void *context
)
6117 /* output_threadid(" threadstep ",ref); *//* simple test */
6118 return get_and_display_threadinfo (ref
);
6122 threadlist_update_test_cmd (char *cmd
, int tty
)
6124 printf_filtered ("Remote Threadlist update test\n");
6125 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
6129 init_remote_threadtests (void)
6131 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
6132 Fetch and print the remote list of thread identifiers, one pkt only"));
6133 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
6134 _("Fetch and display info about one thread"));
6135 add_com ("tset", class_obscure
, threadset_test_cmd
,
6136 _("Test setting to a different thread"));
6137 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
6138 _("Iterate through updating all remote thread info"));
6139 add_com ("talive", class_obscure
, threadalive_test
,
6140 _(" Remote thread alive test "));
6145 /* Convert a thread ID to a string. Returns the string in a static
6149 remote_pid_to_str (ptid_t ptid
)
6151 static char buf
[32];
6153 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
6157 /* Get the address of the thread local variable in OBJFILE which is
6158 stored at OFFSET within the thread local storage for thread PTID. */
6161 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
6163 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
6165 struct remote_state
*rs
= get_remote_state ();
6167 enum packet_result result
;
6169 strcpy (p
, "qGetTLSAddr:");
6171 p
+= hexnumstr (p
, PIDGET (ptid
));
6173 p
+= hexnumstr (p
, offset
);
6175 p
+= hexnumstr (p
, lm
);
6179 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6180 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6181 if (result
== PACKET_OK
)
6185 unpack_varlen_hex (rs
->buf
, &result
);
6188 else if (result
== PACKET_UNKNOWN
)
6189 throw_error (TLS_GENERIC_ERROR
,
6190 _("Remote target doesn't support qGetTLSAddr packet"));
6192 throw_error (TLS_GENERIC_ERROR
,
6193 _("Remote target failed to process qGetTLSAddr request"));
6196 throw_error (TLS_GENERIC_ERROR
,
6197 _("TLS not supported or disabled on this target"));
6202 /* Support for inferring a target description based on the current
6203 architecture and the size of a 'g' packet. While the 'g' packet
6204 can have any size (since optional registers can be left off the
6205 end), some sizes are easily recognizable given knowledge of the
6206 approximate architecture. */
6208 struct remote_g_packet_guess
6211 const struct target_desc
*tdesc
;
6213 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6214 DEF_VEC_O(remote_g_packet_guess_s
);
6216 struct remote_g_packet_data
6218 VEC(remote_g_packet_guess_s
) *guesses
;
6221 static struct gdbarch_data
*remote_g_packet_data_handle
;
6224 remote_g_packet_data_init (struct obstack
*obstack
)
6226 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6230 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6231 const struct target_desc
*tdesc
)
6233 struct remote_g_packet_data
*data
6234 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6235 struct remote_g_packet_guess new_guess
, *guess
;
6238 gdb_assert (tdesc
!= NULL
);
6241 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6243 if (guess
->bytes
== bytes
)
6244 internal_error (__FILE__
, __LINE__
,
6245 "Duplicate g packet description added for size %d",
6248 new_guess
.bytes
= bytes
;
6249 new_guess
.tdesc
= tdesc
;
6250 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6253 static const struct target_desc
*
6254 remote_read_description (struct target_ops
*target
)
6256 struct remote_g_packet_data
*data
6257 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6259 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6261 struct remote_g_packet_guess
*guess
;
6263 int bytes
= send_g_packet ();
6266 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6268 if (guess
->bytes
== bytes
)
6269 return guess
->tdesc
;
6271 /* We discard the g packet. A minor optimization would be to
6272 hold on to it, and fill the register cache once we have selected
6273 an architecture, but it's too tricky to do safely. */
6280 init_remote_ops (void)
6282 remote_ops
.to_shortname
= "remote";
6283 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6285 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6286 Specify the serial device it is connected to\n\
6287 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6288 remote_ops
.to_open
= remote_open
;
6289 remote_ops
.to_close
= remote_close
;
6290 remote_ops
.to_detach
= remote_detach
;
6291 remote_ops
.to_disconnect
= remote_disconnect
;
6292 remote_ops
.to_resume
= remote_resume
;
6293 remote_ops
.to_wait
= remote_wait
;
6294 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6295 remote_ops
.to_store_registers
= remote_store_registers
;
6296 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6297 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6298 remote_ops
.to_files_info
= remote_files_info
;
6299 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6300 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6301 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6302 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6303 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6304 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6305 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6306 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6307 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6308 remote_ops
.to_kill
= remote_kill
;
6309 remote_ops
.to_load
= generic_load
;
6310 remote_ops
.to_mourn_inferior
= remote_mourn
;
6311 remote_ops
.to_thread_alive
= remote_thread_alive
;
6312 remote_ops
.to_find_new_threads
= remote_threads_info
;
6313 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6314 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6315 remote_ops
.to_stop
= remote_stop
;
6316 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6317 remote_ops
.to_rcmd
= remote_rcmd
;
6318 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6319 remote_ops
.to_stratum
= process_stratum
;
6320 remote_ops
.to_has_all_memory
= 1;
6321 remote_ops
.to_has_memory
= 1;
6322 remote_ops
.to_has_stack
= 1;
6323 remote_ops
.to_has_registers
= 1;
6324 remote_ops
.to_has_execution
= 1;
6325 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6326 remote_ops
.to_magic
= OPS_MAGIC
;
6327 remote_ops
.to_memory_map
= remote_memory_map
;
6328 remote_ops
.to_flash_erase
= remote_flash_erase
;
6329 remote_ops
.to_flash_done
= remote_flash_done
;
6330 remote_ops
.to_read_description
= remote_read_description
;
6333 /* Set up the extended remote vector by making a copy of the standard
6334 remote vector and adding to it. */
6337 init_extended_remote_ops (void)
6339 extended_remote_ops
= remote_ops
;
6341 extended_remote_ops
.to_shortname
= "extended-remote";
6342 extended_remote_ops
.to_longname
=
6343 "Extended remote serial target in gdb-specific protocol";
6344 extended_remote_ops
.to_doc
=
6345 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6346 Specify the serial device it is connected to (e.g. /dev/ttya).",
6347 extended_remote_ops
.to_open
= extended_remote_open
;
6348 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6349 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6353 remote_can_async_p (void)
6355 /* We're async whenever the serial device is. */
6356 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6360 remote_is_async_p (void)
6362 /* We're async whenever the serial device is. */
6363 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6366 /* Pass the SERIAL event on and up to the client. One day this code
6367 will be able to delay notifying the client of an event until the
6368 point where an entire packet has been received. */
6370 static void (*async_client_callback
) (enum inferior_event_type event_type
,
6372 static void *async_client_context
;
6373 static serial_event_ftype remote_async_serial_handler
;
6376 remote_async_serial_handler (struct serial
*scb
, void *context
)
6378 /* Don't propogate error information up to the client. Instead let
6379 the client find out about the error by querying the target. */
6380 async_client_callback (INF_REG_EVENT
, async_client_context
);
6384 remote_async (void (*callback
) (enum inferior_event_type event_type
,
6385 void *context
), void *context
)
6387 if (current_target
.to_async_mask_value
== 0)
6388 internal_error (__FILE__
, __LINE__
,
6389 _("Calling remote_async when async is masked"));
6391 if (callback
!= NULL
)
6393 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
6394 async_client_callback
= callback
;
6395 async_client_context
= context
;
6398 serial_async (remote_desc
, NULL
, NULL
);
6401 /* Target async and target extended-async.
6403 This are temporary targets, until it is all tested. Eventually
6404 async support will be incorporated int the usual 'remote'
6408 init_remote_async_ops (void)
6410 remote_async_ops
.to_shortname
= "async";
6411 remote_async_ops
.to_longname
=
6412 "Remote serial target in async version of the gdb-specific protocol";
6413 remote_async_ops
.to_doc
=
6414 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6415 Specify the serial device it is connected to (e.g. /dev/ttya).";
6416 remote_async_ops
.to_open
= remote_async_open
;
6417 remote_async_ops
.to_close
= remote_close
;
6418 remote_async_ops
.to_detach
= remote_detach
;
6419 remote_async_ops
.to_disconnect
= remote_disconnect
;
6420 remote_async_ops
.to_resume
= remote_async_resume
;
6421 remote_async_ops
.to_wait
= remote_async_wait
;
6422 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
6423 remote_async_ops
.to_store_registers
= remote_store_registers
;
6424 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6425 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6426 remote_async_ops
.to_files_info
= remote_files_info
;
6427 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6428 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6429 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6430 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6431 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6432 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6433 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6434 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6435 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6436 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
6437 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
6438 remote_async_ops
.to_kill
= remote_async_kill
;
6439 remote_async_ops
.to_load
= generic_load
;
6440 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
6441 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
6442 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
6443 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
6444 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6445 remote_async_ops
.to_stop
= remote_stop
;
6446 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
6447 remote_async_ops
.to_rcmd
= remote_rcmd
;
6448 remote_async_ops
.to_stratum
= process_stratum
;
6449 remote_async_ops
.to_has_all_memory
= 1;
6450 remote_async_ops
.to_has_memory
= 1;
6451 remote_async_ops
.to_has_stack
= 1;
6452 remote_async_ops
.to_has_registers
= 1;
6453 remote_async_ops
.to_has_execution
= 1;
6454 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6455 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
6456 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
6457 remote_async_ops
.to_async
= remote_async
;
6458 remote_async_ops
.to_async_mask_value
= 1;
6459 remote_async_ops
.to_magic
= OPS_MAGIC
;
6460 remote_async_ops
.to_memory_map
= remote_memory_map
;
6461 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
6462 remote_async_ops
.to_flash_done
= remote_flash_done
;
6463 remote_async_ops
.to_read_description
= remote_read_description
;
6466 /* Set up the async extended remote vector by making a copy of the standard
6467 remote vector and adding to it. */
6470 init_extended_async_remote_ops (void)
6472 extended_async_remote_ops
= remote_async_ops
;
6474 extended_async_remote_ops
.to_shortname
= "extended-async";
6475 extended_async_remote_ops
.to_longname
=
6476 "Extended remote serial target in async gdb-specific protocol";
6477 extended_async_remote_ops
.to_doc
=
6478 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6479 Specify the serial device it is connected to (e.g. /dev/ttya).",
6480 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
6481 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
6482 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6486 set_remote_cmd (char *args
, int from_tty
)
6488 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
6492 show_remote_cmd (char *args
, int from_tty
)
6494 /* We can't just use cmd_show_list here, because we want to skip
6495 the redundant "show remote Z-packet" and the legacy aliases. */
6496 struct cleanup
*showlist_chain
;
6497 struct cmd_list_element
*list
= remote_show_cmdlist
;
6499 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
6500 for (; list
!= NULL
; list
= list
->next
)
6501 if (strcmp (list
->name
, "Z-packet") == 0)
6503 else if (list
->type
== not_set_cmd
)
6504 /* Alias commands are exactly like the original, except they
6505 don't have the normal type. */
6509 struct cleanup
*option_chain
6510 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
6511 ui_out_field_string (uiout
, "name", list
->name
);
6512 ui_out_text (uiout
, ": ");
6513 if (list
->type
== show_cmd
)
6514 do_setshow_command ((char *) NULL
, from_tty
, list
);
6516 cmd_func (list
, NULL
, from_tty
);
6517 /* Close the tuple. */
6518 do_cleanups (option_chain
);
6521 /* Close the tuple. */
6522 do_cleanups (showlist_chain
);
6526 /* Function to be called whenever a new objfile (shlib) is detected. */
6528 remote_new_objfile (struct objfile
*objfile
)
6530 if (remote_desc
!= 0) /* Have a remote connection. */
6531 remote_check_symbols (objfile
);
6535 _initialize_remote (void)
6537 struct remote_state
*rs
;
6539 /* architecture specific data */
6540 remote_gdbarch_data_handle
=
6541 gdbarch_data_register_post_init (init_remote_state
);
6542 remote_g_packet_data_handle
=
6543 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
6545 /* Initialize the per-target state. At the moment there is only one
6546 of these, not one per target. Only one target is active at a
6547 time. The default buffer size is unimportant; it will be expanded
6548 whenever a larger buffer is needed. */
6549 rs
= get_remote_state_raw ();
6551 rs
->buf
= xmalloc (rs
->buf_size
);
6554 add_target (&remote_ops
);
6556 init_extended_remote_ops ();
6557 add_target (&extended_remote_ops
);
6559 init_remote_async_ops ();
6560 add_target (&remote_async_ops
);
6562 init_extended_async_remote_ops ();
6563 add_target (&extended_async_remote_ops
);
6565 /* Hook into new objfile notification. */
6566 observer_attach_new_objfile (remote_new_objfile
);
6569 init_remote_threadtests ();
6572 /* set/show remote ... */
6574 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
6575 Remote protocol specific variables\n\
6576 Configure various remote-protocol specific variables such as\n\
6577 the packets being used"),
6578 &remote_set_cmdlist
, "set remote ",
6579 0 /* allow-unknown */, &setlist
);
6580 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
6581 Remote protocol specific variables\n\
6582 Configure various remote-protocol specific variables such as\n\
6583 the packets being used"),
6584 &remote_show_cmdlist
, "show remote ",
6585 0 /* allow-unknown */, &showlist
);
6587 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
6588 Compare section data on target to the exec file.\n\
6589 Argument is a single section name (default: all loaded sections)."),
6592 add_cmd ("packet", class_maintenance
, packet_command
, _("\
6593 Send an arbitrary packet to a remote target.\n\
6594 maintenance packet TEXT\n\
6595 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6596 this command sends the string TEXT to the inferior, and displays the\n\
6597 response packet. GDB supplies the initial `$' character, and the\n\
6598 terminating `#' character and checksum."),
6601 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
6602 Set whether to send break if interrupted."), _("\
6603 Show whether to send break if interrupted."), _("\
6604 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6605 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6606 &setlist
, &showlist
);
6608 /* Install commands for configuring memory read/write packets. */
6610 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
6611 Set the maximum number of bytes per memory write packet (deprecated)."),
6613 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
6614 Show the maximum number of bytes per memory write packet (deprecated)."),
6616 add_cmd ("memory-write-packet-size", no_class
,
6617 set_memory_write_packet_size
, _("\
6618 Set the maximum number of bytes per memory-write packet.\n\
6619 Specify the number of bytes in a packet or 0 (zero) for the\n\
6620 default packet size. The actual limit is further reduced\n\
6621 dependent on the target. Specify ``fixed'' to disable the\n\
6622 further restriction and ``limit'' to enable that restriction."),
6623 &remote_set_cmdlist
);
6624 add_cmd ("memory-read-packet-size", no_class
,
6625 set_memory_read_packet_size
, _("\
6626 Set the maximum number of bytes per memory-read packet.\n\
6627 Specify the number of bytes in a packet or 0 (zero) for the\n\
6628 default packet size. The actual limit is further reduced\n\
6629 dependent on the target. Specify ``fixed'' to disable the\n\
6630 further restriction and ``limit'' to enable that restriction."),
6631 &remote_set_cmdlist
);
6632 add_cmd ("memory-write-packet-size", no_class
,
6633 show_memory_write_packet_size
,
6634 _("Show the maximum number of bytes per memory-write packet."),
6635 &remote_show_cmdlist
);
6636 add_cmd ("memory-read-packet-size", no_class
,
6637 show_memory_read_packet_size
,
6638 _("Show the maximum number of bytes per memory-read packet."),
6639 &remote_show_cmdlist
);
6641 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6642 &remote_hw_watchpoint_limit
, _("\
6643 Set the maximum number of target hardware watchpoints."), _("\
6644 Show the maximum number of target hardware watchpoints."), _("\
6645 Specify a negative limit for unlimited."),
6646 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6647 &remote_set_cmdlist
, &remote_show_cmdlist
);
6648 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6649 &remote_hw_breakpoint_limit
, _("\
6650 Set the maximum number of target hardware breakpoints."), _("\
6651 Show the maximum number of target hardware breakpoints."), _("\
6652 Specify a negative limit for unlimited."),
6653 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6654 &remote_set_cmdlist
, &remote_show_cmdlist
);
6656 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6657 &remote_address_size
, _("\
6658 Set the maximum size of the address (in bits) in a memory packet."), _("\
6659 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6661 NULL
, /* FIXME: i18n: */
6662 &setlist
, &showlist
);
6664 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6665 "X", "binary-download", 1);
6667 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6668 "vCont", "verbose-resume", 0);
6670 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
6671 "QPassSignals", "pass-signals", 0);
6673 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6674 "qSymbol", "symbol-lookup", 0);
6676 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6677 "P", "set-register", 1);
6679 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6680 "p", "fetch-register", 1);
6682 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6683 "Z0", "software-breakpoint", 0);
6685 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6686 "Z1", "hardware-breakpoint", 0);
6688 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6689 "Z2", "write-watchpoint", 0);
6691 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6692 "Z3", "read-watchpoint", 0);
6694 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6695 "Z4", "access-watchpoint", 0);
6697 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6698 "qXfer:auxv:read", "read-aux-vector", 0);
6700 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
6701 "qXfer:features:read", "target-features", 0);
6703 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
6704 "qXfer:libraries:read", "library-info", 0);
6706 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
6707 "qXfer:memory-map:read", "memory-map", 0);
6709 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
6710 "qXfer:spu:read", "read-spu-object", 0);
6712 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
6713 "qXfer:spu:write", "write-spu-object", 0);
6715 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6716 "qGetTLSAddr", "get-thread-local-storage-address",
6719 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6720 "qSupported", "supported-packets", 0);
6722 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6723 Z sub-packet has its own set and show commands, but users may
6724 have sets to this variable in their .gdbinit files (or in their
6726 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6727 &remote_Z_packet_detect
, _("\
6728 Set use of remote protocol `Z' packets"), _("\
6729 Show use of remote protocol `Z' packets "), _("\
6730 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6732 set_remote_protocol_Z_packet_cmd
,
6733 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6734 &remote_set_cmdlist
, &remote_show_cmdlist
);
6736 /* Eventually initialize fileio. See fileio.c */
6737 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);