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 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* See the GDB User Guide for details of the GDB remote protocol. */
27 #include "gdb_string.h"
33 #include "exceptions.h"
35 /*#include "terminal.h" */
38 #include "gdb-stabs.h"
39 #include "gdbthread.h"
43 #include "gdb_assert.h"
46 #include "cli/cli-decode.h"
47 #include "cli/cli-setshow.h"
48 #include "target-descriptions.h"
53 #include "event-loop.h"
54 #include "event-top.h"
60 #include "gdbcore.h" /* for exec_bfd */
62 #include "remote-fileio.h"
64 #include "memory-map.h"
66 /* The size to align memory write packets, when practical. The protocol
67 does not guarantee any alignment, and gdb will generate short
68 writes and unaligned writes, but even as a best-effort attempt this
69 can improve bulk transfers. For instance, if a write is misaligned
70 relative to the target's data bus, the stub may need to make an extra
71 round trip fetching data from the target. This doesn't make a
72 huge difference, but it's easy to do, so we try to be helpful.
74 The alignment chosen is arbitrary; usually data bus width is
75 important here, not the possibly larger cache line size. */
76 enum { REMOTE_ALIGN_WRITES
= 16 };
78 /* Prototypes for local functions. */
79 static void cleanup_sigint_signal_handler (void *dummy
);
80 static void initialize_sigint_signal_handler (void);
81 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
83 static void handle_remote_sigint (int);
84 static void handle_remote_sigint_twice (int);
85 static void async_remote_interrupt (gdb_client_data
);
86 void async_remote_interrupt_twice (gdb_client_data
);
88 static void remote_files_info (struct target_ops
*ignore
);
90 static void remote_prepare_to_store (struct regcache
*regcache
);
92 static void remote_fetch_registers (struct regcache
*regcache
, int regno
);
94 static void remote_resume (ptid_t ptid
, int step
,
95 enum target_signal siggnal
);
96 static void remote_async_resume (ptid_t ptid
, int step
,
97 enum target_signal siggnal
);
98 static void remote_open (char *name
, int from_tty
);
99 static void remote_async_open (char *name
, int from_tty
);
101 static void extended_remote_open (char *name
, int from_tty
);
102 static void extended_remote_async_open (char *name
, int from_tty
);
104 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
,
107 static void remote_close (int quitting
);
109 static void remote_store_registers (struct regcache
*regcache
, int regno
);
111 static void remote_mourn (void);
112 static void remote_async_mourn (void);
114 static void extended_remote_restart (void);
116 static void extended_remote_mourn (void);
118 static void remote_mourn_1 (struct target_ops
*);
120 static void remote_send (char **buf
, long *sizeof_buf_p
);
122 static int readchar (int timeout
);
124 static ptid_t
remote_wait (ptid_t ptid
,
125 struct target_waitstatus
*status
);
126 static ptid_t
remote_async_wait (ptid_t ptid
,
127 struct target_waitstatus
*status
);
129 static void remote_kill (void);
130 static void remote_async_kill (void);
132 static int tohex (int nib
);
134 static void remote_detach (char *args
, int from_tty
);
136 static void remote_interrupt (int signo
);
138 static void remote_interrupt_twice (int signo
);
140 static void interrupt_query (void);
142 static void set_thread (int, int);
144 static int remote_thread_alive (ptid_t
);
146 static void get_offsets (void);
148 static void skip_frame (void);
150 static long read_frame (char **buf_p
, long *sizeof_buf
);
152 static int hexnumlen (ULONGEST num
);
154 static void init_remote_ops (void);
156 static void init_extended_remote_ops (void);
158 static void remote_stop (void);
160 static int ishex (int ch
, int *val
);
162 static int stubhex (int ch
);
164 static int hexnumstr (char *, ULONGEST
);
166 static int hexnumnstr (char *, ULONGEST
, int);
168 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
170 static void print_packet (char *);
172 static unsigned long crc32 (unsigned char *, int, unsigned int);
174 static void compare_sections_command (char *, int);
176 static void packet_command (char *, int);
178 static int stub_unpack_int (char *buff
, int fieldlength
);
180 static ptid_t
remote_current_thread (ptid_t oldptid
);
182 static void remote_find_new_threads (void);
184 static void record_currthread (int currthread
);
186 static int fromhex (int a
);
188 static int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
190 static int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
192 static int putpkt_binary (char *buf
, int cnt
);
194 static void check_binary_download (CORE_ADDR addr
);
196 struct packet_config
;
198 static void show_packet_config_cmd (struct packet_config
*config
);
200 static void update_packet_config (struct packet_config
*config
);
202 static void set_remote_protocol_packet_cmd (char *args
, int from_tty
,
203 struct cmd_list_element
*c
);
205 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
207 struct cmd_list_element
*c
,
210 void _initialize_remote (void);
212 /* For "set remote" and "show remote". */
214 static struct cmd_list_element
*remote_set_cmdlist
;
215 static struct cmd_list_element
*remote_show_cmdlist
;
217 /* Description of the remote protocol state for the currently
218 connected target. This is per-target state, and independent of the
219 selected architecture. */
223 /* A buffer to use for incoming packets, and its current size. The
224 buffer is grown dynamically for larger incoming packets.
225 Outgoing packets may also be constructed in this buffer.
226 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
227 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
232 /* If we negotiated packet size explicitly (and thus can bypass
233 heuristics for the largest packet size that will not overflow
234 a buffer in the stub), this will be set to that packet size.
235 Otherwise zero, meaning to use the guessed size. */
236 long explicit_packet_size
;
239 /* This data could be associated with a target, but we do not always
240 have access to the current target when we need it, so for now it is
241 static. This will be fine for as long as only one target is in use
243 static struct remote_state remote_state
;
245 static struct remote_state
*
246 get_remote_state_raw (void)
248 return &remote_state
;
251 /* Description of the remote protocol for a given architecture. */
255 long offset
; /* Offset into G packet. */
256 long regnum
; /* GDB's internal register number. */
257 LONGEST pnum
; /* Remote protocol register number. */
258 int in_g_packet
; /* Always part of G packet. */
259 /* long size in bytes; == register_size (current_gdbarch, regnum);
261 /* char *name; == gdbarch_register_name (current_gdbarch, regnum);
265 struct remote_arch_state
267 /* Description of the remote protocol registers. */
268 long sizeof_g_packet
;
270 /* Description of the remote protocol registers indexed by REGNUM
271 (making an array gdbarch_num_regs in size). */
272 struct packet_reg
*regs
;
274 /* This is the size (in chars) of the first response to the ``g''
275 packet. It is used as a heuristic when determining the maximum
276 size of memory-read and memory-write packets. A target will
277 typically only reserve a buffer large enough to hold the ``g''
278 packet. The size does not include packet overhead (headers and
280 long actual_register_packet_size
;
282 /* This is the maximum size (in chars) of a non read/write packet.
283 It is also used as a cap on the size of read/write packets. */
284 long remote_packet_size
;
288 /* Handle for retreving the remote protocol data from gdbarch. */
289 static struct gdbarch_data
*remote_gdbarch_data_handle
;
291 static struct remote_arch_state
*
292 get_remote_arch_state (void)
294 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
297 /* Fetch the global remote target state. */
299 static struct remote_state
*
300 get_remote_state (void)
302 /* Make sure that the remote architecture state has been
303 initialized, because doing so might reallocate rs->buf. Any
304 function which calls getpkt also needs to be mindful of changes
305 to rs->buf, but this call limits the number of places which run
307 get_remote_arch_state ();
309 return get_remote_state_raw ();
313 compare_pnums (const void *lhs_
, const void *rhs_
)
315 const struct packet_reg
* const *lhs
= lhs_
;
316 const struct packet_reg
* const *rhs
= rhs_
;
318 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
320 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
327 init_remote_state (struct gdbarch
*gdbarch
)
329 int regnum
, num_remote_regs
, offset
;
330 struct remote_state
*rs
= get_remote_state_raw ();
331 struct remote_arch_state
*rsa
;
332 struct packet_reg
**remote_regs
;
334 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
336 /* Use the architecture to build a regnum<->pnum table, which will be
337 1:1 unless a feature set specifies otherwise. */
338 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
339 gdbarch_num_regs (current_gdbarch
),
341 for (regnum
= 0; regnum
< gdbarch_num_regs (current_gdbarch
); regnum
++)
343 struct packet_reg
*r
= &rsa
->regs
[regnum
];
345 if (register_size (current_gdbarch
, regnum
) == 0)
346 /* Do not try to fetch zero-sized (placeholder) registers. */
349 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
354 /* Define the g/G packet format as the contents of each register
355 with a remote protocol number, in order of ascending protocol
358 remote_regs
= alloca (gdbarch_num_regs (current_gdbarch
)
359 * sizeof (struct packet_reg
*));
360 for (num_remote_regs
= 0, regnum
= 0;
361 regnum
< gdbarch_num_regs (current_gdbarch
);
363 if (rsa
->regs
[regnum
].pnum
!= -1)
364 remote_regs
[num_remote_regs
++] = &rsa
->regs
[regnum
];
366 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
369 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
371 remote_regs
[regnum
]->in_g_packet
= 1;
372 remote_regs
[regnum
]->offset
= offset
;
373 offset
+= register_size (current_gdbarch
, remote_regs
[regnum
]->regnum
);
376 /* Record the maximum possible size of the g packet - it may turn out
378 rsa
->sizeof_g_packet
= offset
;
380 /* Default maximum number of characters in a packet body. Many
381 remote stubs have a hardwired buffer size of 400 bytes
382 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
383 as the maximum packet-size to ensure that the packet and an extra
384 NUL character can always fit in the buffer. This stops GDB
385 trashing stubs that try to squeeze an extra NUL into what is
386 already a full buffer (As of 1999-12-04 that was most stubs). */
387 rsa
->remote_packet_size
= 400 - 1;
389 /* This one is filled in when a ``g'' packet is received. */
390 rsa
->actual_register_packet_size
= 0;
392 /* Should rsa->sizeof_g_packet needs more space than the
393 default, adjust the size accordingly. Remember that each byte is
394 encoded as two characters. 32 is the overhead for the packet
395 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
396 (``$NN:G...#NN'') is a better guess, the below has been padded a
398 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
399 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
401 /* Make sure that the packet buffer is plenty big enough for
402 this architecture. */
403 if (rs
->buf_size
< rsa
->remote_packet_size
)
405 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
406 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
412 /* Return the current allowed size of a remote packet. This is
413 inferred from the current architecture, and should be used to
414 limit the length of outgoing packets. */
416 get_remote_packet_size (void)
418 struct remote_state
*rs
= get_remote_state ();
419 struct remote_arch_state
*rsa
= get_remote_arch_state ();
421 if (rs
->explicit_packet_size
)
422 return rs
->explicit_packet_size
;
424 return rsa
->remote_packet_size
;
427 static struct packet_reg
*
428 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
430 if (regnum
< 0 && regnum
>= gdbarch_num_regs (current_gdbarch
))
434 struct packet_reg
*r
= &rsa
->regs
[regnum
];
435 gdb_assert (r
->regnum
== regnum
);
440 static struct packet_reg
*
441 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
444 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
446 struct packet_reg
*r
= &rsa
->regs
[i
];
453 /* FIXME: graces/2002-08-08: These variables should eventually be
454 bound to an instance of the target object (as in gdbarch-tdep()),
455 when such a thing exists. */
457 /* This is set to the data address of the access causing the target
458 to stop for a watchpoint. */
459 static CORE_ADDR remote_watch_data_address
;
461 /* This is non-zero if target stopped for a watchpoint. */
462 static int remote_stopped_by_watchpoint_p
;
464 static struct target_ops remote_ops
;
466 static struct target_ops extended_remote_ops
;
468 /* Temporary target ops. Just like the remote_ops and
469 extended_remote_ops, but with asynchronous support. */
470 static struct target_ops remote_async_ops
;
472 static struct target_ops extended_async_remote_ops
;
474 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
475 ``forever'' still use the normal timeout mechanism. This is
476 currently used by the ASYNC code to guarentee that target reads
477 during the initial connect always time-out. Once getpkt has been
478 modified to return a timeout indication and, in turn
479 remote_wait()/wait_for_inferior() have gained a timeout parameter
481 static int wait_forever_enabled_p
= 1;
484 /* This variable chooses whether to send a ^C or a break when the user
485 requests program interruption. Although ^C is usually what remote
486 systems expect, and that is the default here, sometimes a break is
487 preferable instead. */
489 static int remote_break
;
491 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
492 remote_open knows that we don't have a file open when the program
494 static struct serial
*remote_desc
= NULL
;
496 /* This variable sets the number of bits in an address that are to be
497 sent in a memory ("M" or "m") packet. Normally, after stripping
498 leading zeros, the entire address would be sent. This variable
499 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
500 initial implementation of remote.c restricted the address sent in
501 memory packets to ``host::sizeof long'' bytes - (typically 32
502 bits). Consequently, for 64 bit targets, the upper 32 bits of an
503 address was never sent. Since fixing this bug may cause a break in
504 some remote targets this variable is principly provided to
505 facilitate backward compatibility. */
507 static int remote_address_size
;
509 /* Tempoary to track who currently owns the terminal. See
510 target_async_terminal_* for more details. */
512 static int remote_async_terminal_ours_p
;
515 /* User configurable variables for the number of characters in a
516 memory read/write packet. MIN (rsa->remote_packet_size,
517 rsa->sizeof_g_packet) is the default. Some targets need smaller
518 values (fifo overruns, et.al.) and some users need larger values
519 (speed up transfers). The variables ``preferred_*'' (the user
520 request), ``current_*'' (what was actually set) and ``forced_*''
521 (Positive - a soft limit, negative - a hard limit). */
523 struct memory_packet_config
530 /* Compute the current size of a read/write packet. Since this makes
531 use of ``actual_register_packet_size'' the computation is dynamic. */
534 get_memory_packet_size (struct memory_packet_config
*config
)
536 struct remote_state
*rs
= get_remote_state ();
537 struct remote_arch_state
*rsa
= get_remote_arch_state ();
539 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
540 law?) that some hosts don't cope very well with large alloca()
541 calls. Eventually the alloca() code will be replaced by calls to
542 xmalloc() and make_cleanups() allowing this restriction to either
543 be lifted or removed. */
544 #ifndef MAX_REMOTE_PACKET_SIZE
545 #define MAX_REMOTE_PACKET_SIZE 16384
547 /* NOTE: 20 ensures we can write at least one byte. */
548 #ifndef MIN_REMOTE_PACKET_SIZE
549 #define MIN_REMOTE_PACKET_SIZE 20
554 if (config
->size
<= 0)
555 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
557 what_they_get
= config
->size
;
561 what_they_get
= get_remote_packet_size ();
562 /* Limit the packet to the size specified by the user. */
564 && what_they_get
> config
->size
)
565 what_they_get
= config
->size
;
567 /* Limit it to the size of the targets ``g'' response unless we have
568 permission from the stub to use a larger packet size. */
569 if (rs
->explicit_packet_size
== 0
570 && rsa
->actual_register_packet_size
> 0
571 && what_they_get
> rsa
->actual_register_packet_size
)
572 what_they_get
= rsa
->actual_register_packet_size
;
574 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
575 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
576 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
577 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
579 /* Make sure there is room in the global buffer for this packet
580 (including its trailing NUL byte). */
581 if (rs
->buf_size
< what_they_get
+ 1)
583 rs
->buf_size
= 2 * what_they_get
;
584 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
587 return what_they_get
;
590 /* Update the size of a read/write packet. If they user wants
591 something really big then do a sanity check. */
594 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
596 int fixed_p
= config
->fixed_p
;
597 long size
= config
->size
;
599 error (_("Argument required (integer, `fixed' or `limited')."));
600 else if (strcmp (args
, "hard") == 0
601 || strcmp (args
, "fixed") == 0)
603 else if (strcmp (args
, "soft") == 0
604 || strcmp (args
, "limit") == 0)
609 size
= strtoul (args
, &end
, 0);
611 error (_("Invalid %s (bad syntax)."), config
->name
);
613 /* Instead of explicitly capping the size of a packet to
614 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
615 instead allowed to set the size to something arbitrarily
617 if (size
> MAX_REMOTE_PACKET_SIZE
)
618 error (_("Invalid %s (too large)."), config
->name
);
622 if (fixed_p
&& !config
->fixed_p
)
624 if (! query (_("The target may not be able to correctly handle a %s\n"
625 "of %ld bytes. Change the packet size? "),
627 error (_("Packet size not changed."));
629 /* Update the config. */
630 config
->fixed_p
= fixed_p
;
635 show_memory_packet_size (struct memory_packet_config
*config
)
637 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
639 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
640 get_memory_packet_size (config
));
642 printf_filtered (_("Packets are limited to %ld bytes.\n"),
643 get_memory_packet_size (config
));
646 static struct memory_packet_config memory_write_packet_config
=
648 "memory-write-packet-size",
652 set_memory_write_packet_size (char *args
, int from_tty
)
654 set_memory_packet_size (args
, &memory_write_packet_config
);
658 show_memory_write_packet_size (char *args
, int from_tty
)
660 show_memory_packet_size (&memory_write_packet_config
);
664 get_memory_write_packet_size (void)
666 return get_memory_packet_size (&memory_write_packet_config
);
669 static struct memory_packet_config memory_read_packet_config
=
671 "memory-read-packet-size",
675 set_memory_read_packet_size (char *args
, int from_tty
)
677 set_memory_packet_size (args
, &memory_read_packet_config
);
681 show_memory_read_packet_size (char *args
, int from_tty
)
683 show_memory_packet_size (&memory_read_packet_config
);
687 get_memory_read_packet_size (void)
689 long size
= get_memory_packet_size (&memory_read_packet_config
);
690 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
691 extra buffer size argument before the memory read size can be
692 increased beyond this. */
693 if (size
> get_remote_packet_size ())
694 size
= get_remote_packet_size ();
699 /* Generic configuration support for packets the stub optionally
700 supports. Allows the user to specify the use of the packet as well
701 as allowing GDB to auto-detect support in the remote stub. */
705 PACKET_SUPPORT_UNKNOWN
= 0,
714 enum auto_boolean detect
;
715 enum packet_support support
;
718 /* Analyze a packet's return value and update the packet config
729 update_packet_config (struct packet_config
*config
)
731 switch (config
->detect
)
733 case AUTO_BOOLEAN_TRUE
:
734 config
->support
= PACKET_ENABLE
;
736 case AUTO_BOOLEAN_FALSE
:
737 config
->support
= PACKET_DISABLE
;
739 case AUTO_BOOLEAN_AUTO
:
740 config
->support
= PACKET_SUPPORT_UNKNOWN
;
746 show_packet_config_cmd (struct packet_config
*config
)
748 char *support
= "internal-error";
749 switch (config
->support
)
755 support
= "disabled";
757 case PACKET_SUPPORT_UNKNOWN
:
761 switch (config
->detect
)
763 case AUTO_BOOLEAN_AUTO
:
764 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
765 config
->name
, support
);
767 case AUTO_BOOLEAN_TRUE
:
768 case AUTO_BOOLEAN_FALSE
:
769 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
770 config
->name
, support
);
776 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
777 const char *title
, int legacy
)
784 config
->title
= title
;
785 config
->detect
= AUTO_BOOLEAN_AUTO
;
786 config
->support
= PACKET_SUPPORT_UNKNOWN
;
787 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
789 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
791 /* set/show TITLE-packet {auto,on,off} */
792 cmd_name
= xstrprintf ("%s-packet", title
);
793 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
794 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
795 set_remote_protocol_packet_cmd
,
796 show_remote_protocol_packet_cmd
,
797 &remote_set_cmdlist
, &remote_show_cmdlist
);
798 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
802 legacy_name
= xstrprintf ("%s-packet", name
);
803 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
804 &remote_set_cmdlist
);
805 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
806 &remote_show_cmdlist
);
810 static enum packet_result
811 packet_check_result (const char *buf
)
815 /* The stub recognized the packet request. Check that the
816 operation succeeded. */
818 && isxdigit (buf
[1]) && isxdigit (buf
[2])
820 /* "Enn" - definitly an error. */
823 /* Always treat "E." as an error. This will be used for
824 more verbose error messages, such as E.memtypes. */
825 if (buf
[0] == 'E' && buf
[1] == '.')
828 /* The packet may or may not be OK. Just assume it is. */
832 /* The stub does not support the packet. */
833 return PACKET_UNKNOWN
;
836 static enum packet_result
837 packet_ok (const char *buf
, struct packet_config
*config
)
839 enum packet_result result
;
841 result
= packet_check_result (buf
);
846 /* The stub recognized the packet request. */
847 switch (config
->support
)
849 case PACKET_SUPPORT_UNKNOWN
:
851 fprintf_unfiltered (gdb_stdlog
,
852 "Packet %s (%s) is supported\n",
853 config
->name
, config
->title
);
854 config
->support
= PACKET_ENABLE
;
857 internal_error (__FILE__
, __LINE__
,
858 _("packet_ok: attempt to use a disabled packet"));
865 /* The stub does not support the packet. */
866 switch (config
->support
)
869 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
870 /* If the stub previously indicated that the packet was
871 supported then there is a protocol error.. */
872 error (_("Protocol error: %s (%s) conflicting enabled responses."),
873 config
->name
, config
->title
);
875 /* The user set it wrong. */
876 error (_("Enabled packet %s (%s) not recognized by stub"),
877 config
->name
, config
->title
);
879 case PACKET_SUPPORT_UNKNOWN
:
881 fprintf_unfiltered (gdb_stdlog
,
882 "Packet %s (%s) is NOT supported\n",
883 config
->name
, config
->title
);
884 config
->support
= PACKET_DISABLE
;
907 PACKET_qXfer_features
,
908 PACKET_qXfer_libraries
,
909 PACKET_qXfer_memory_map
,
910 PACKET_qXfer_spu_read
,
911 PACKET_qXfer_spu_write
,
918 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
921 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
922 struct cmd_list_element
*c
)
924 struct packet_config
*packet
;
926 for (packet
= remote_protocol_packets
;
927 packet
< &remote_protocol_packets
[PACKET_MAX
];
930 if (&packet
->detect
== c
->var
)
932 update_packet_config (packet
);
936 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
941 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
942 struct cmd_list_element
*c
,
945 struct packet_config
*packet
;
947 for (packet
= remote_protocol_packets
;
948 packet
< &remote_protocol_packets
[PACKET_MAX
];
951 if (&packet
->detect
== c
->var
)
953 show_packet_config_cmd (packet
);
957 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
961 /* Should we try one of the 'Z' requests? */
965 Z_PACKET_SOFTWARE_BP
,
966 Z_PACKET_HARDWARE_BP
,
973 /* For compatibility with older distributions. Provide a ``set remote
974 Z-packet ...'' command that updates all the Z packet types. */
976 static enum auto_boolean remote_Z_packet_detect
;
979 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
980 struct cmd_list_element
*c
)
983 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
985 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
986 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
991 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
992 struct cmd_list_element
*c
,
996 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
998 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1002 /* Should we try the 'ThreadInfo' query packet?
1004 This variable (NOT available to the user: auto-detect only!)
1005 determines whether GDB will use the new, simpler "ThreadInfo"
1006 query or the older, more complex syntax for thread queries.
1007 This is an auto-detect variable (set to true at each connect,
1008 and set to false when the target fails to recognize it). */
1010 static int use_threadinfo_query
;
1011 static int use_threadextra_query
;
1013 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1014 static struct async_signal_handler
*sigint_remote_twice_token
;
1015 static struct async_signal_handler
*sigint_remote_token
;
1017 /* These are pointers to hook functions that may be set in order to
1018 modify resume/wait behavior for a particular architecture. */
1020 void (*deprecated_target_resume_hook
) (void);
1021 void (*deprecated_target_wait_loop_hook
) (void);
1025 /* These are the threads which we last sent to the remote system.
1026 -1 for all or -2 for not sent yet. */
1027 static int general_thread
;
1028 static int continue_thread
;
1030 /* Call this function as a result of
1031 1) A halt indication (T packet) containing a thread id
1032 2) A direct query of currthread
1033 3) Successful execution of set thread
1037 record_currthread (int currthread
)
1039 general_thread
= currthread
;
1041 /* If this is a new thread, add it to GDB's thread list.
1042 If we leave it up to WFI to do this, bad things will happen. */
1043 if (!in_thread_list (pid_to_ptid (currthread
)))
1045 add_thread (pid_to_ptid (currthread
));
1046 ui_out_text (uiout
, "[New ");
1047 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
1048 ui_out_text (uiout
, "]\n");
1052 static char *last_pass_packet
;
1054 /* If 'QPassSignals' is supported, tell the remote stub what signals
1055 it can simply pass through to the inferior without reporting. */
1058 remote_pass_signals (void)
1060 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1062 char *pass_packet
, *p
;
1063 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1066 gdb_assert (numsigs
< 256);
1067 for (i
= 0; i
< numsigs
; i
++)
1069 if (signal_stop_state (i
) == 0
1070 && signal_print_state (i
) == 0
1071 && signal_pass_state (i
) == 1)
1074 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1075 strcpy (pass_packet
, "QPassSignals:");
1076 p
= pass_packet
+ strlen (pass_packet
);
1077 for (i
= 0; i
< numsigs
; i
++)
1079 if (signal_stop_state (i
) == 0
1080 && signal_print_state (i
) == 0
1081 && signal_pass_state (i
) == 1)
1084 *p
++ = tohex (i
>> 4);
1085 *p
++ = tohex (i
& 15);
1094 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1096 struct remote_state
*rs
= get_remote_state ();
1097 char *buf
= rs
->buf
;
1099 putpkt (pass_packet
);
1100 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1101 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1102 if (last_pass_packet
)
1103 xfree (last_pass_packet
);
1104 last_pass_packet
= pass_packet
;
1107 xfree (pass_packet
);
1111 #define MAGIC_NULL_PID 42000
1114 set_thread (int th
, int gen
)
1116 struct remote_state
*rs
= get_remote_state ();
1117 char *buf
= rs
->buf
;
1118 int state
= gen
? general_thread
: continue_thread
;
1124 buf
[1] = gen
? 'g' : 'c';
1125 if (th
== MAGIC_NULL_PID
)
1131 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
1133 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
1135 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1137 general_thread
= th
;
1139 continue_thread
= th
;
1142 /* Return nonzero if the thread TH is still alive on the remote system. */
1145 remote_thread_alive (ptid_t ptid
)
1147 struct remote_state
*rs
= get_remote_state ();
1148 int tid
= PIDGET (ptid
);
1151 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1153 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1155 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1156 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1159 /* About these extended threadlist and threadinfo packets. They are
1160 variable length packets but, the fields within them are often fixed
1161 length. They are redundent enough to send over UDP as is the
1162 remote protocol in general. There is a matching unit test module
1165 #define OPAQUETHREADBYTES 8
1167 /* a 64 bit opaque identifier */
1168 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1170 /* WARNING: This threadref data structure comes from the remote O.S.,
1171 libstub protocol encoding, and remote.c. it is not particularly
1174 /* Right now, the internal structure is int. We want it to be bigger.
1178 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1180 /* gdb_ext_thread_info is an internal GDB data structure which is
1181 equivalent to the reply of the remote threadinfo packet. */
1183 struct gdb_ext_thread_info
1185 threadref threadid
; /* External form of thread reference. */
1186 int active
; /* Has state interesting to GDB?
1188 char display
[256]; /* Brief state display, name,
1189 blocked/suspended. */
1190 char shortname
[32]; /* To be used to name threads. */
1191 char more_display
[256]; /* Long info, statistics, queue depth,
1195 /* The volume of remote transfers can be limited by submitting
1196 a mask containing bits specifying the desired information.
1197 Use a union of these values as the 'selection' parameter to
1198 get_thread_info. FIXME: Make these TAG names more thread specific.
1201 #define TAG_THREADID 1
1202 #define TAG_EXISTS 2
1203 #define TAG_DISPLAY 4
1204 #define TAG_THREADNAME 8
1205 #define TAG_MOREDISPLAY 16
1207 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1209 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1211 static char *unpack_nibble (char *buf
, int *val
);
1213 static char *pack_nibble (char *buf
, int nibble
);
1215 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1217 static char *unpack_byte (char *buf
, int *value
);
1219 static char *pack_int (char *buf
, int value
);
1221 static char *unpack_int (char *buf
, int *value
);
1223 static char *unpack_string (char *src
, char *dest
, int length
);
1225 static char *pack_threadid (char *pkt
, threadref
*id
);
1227 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1229 void int_to_threadref (threadref
*id
, int value
);
1231 static int threadref_to_int (threadref
*ref
);
1233 static void copy_threadref (threadref
*dest
, threadref
*src
);
1235 static int threadmatch (threadref
*dest
, threadref
*src
);
1237 static char *pack_threadinfo_request (char *pkt
, int mode
,
1240 static int remote_unpack_thread_info_response (char *pkt
,
1241 threadref
*expectedref
,
1242 struct gdb_ext_thread_info
1246 static int remote_get_threadinfo (threadref
*threadid
,
1247 int fieldset
, /*TAG mask */
1248 struct gdb_ext_thread_info
*info
);
1250 static char *pack_threadlist_request (char *pkt
, int startflag
,
1252 threadref
*nextthread
);
1254 static int parse_threadlist_response (char *pkt
,
1256 threadref
*original_echo
,
1257 threadref
*resultlist
,
1260 static int remote_get_threadlist (int startflag
,
1261 threadref
*nextthread
,
1265 threadref
*threadlist
);
1267 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1269 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1270 void *context
, int looplimit
);
1272 static int remote_newthread_step (threadref
*ref
, void *context
);
1274 /* Encode 64 bits in 16 chars of hex. */
1276 static const char hexchars
[] = "0123456789abcdef";
1279 ishex (int ch
, int *val
)
1281 if ((ch
>= 'a') && (ch
<= 'f'))
1283 *val
= ch
- 'a' + 10;
1286 if ((ch
>= 'A') && (ch
<= 'F'))
1288 *val
= ch
- 'A' + 10;
1291 if ((ch
>= '0') && (ch
<= '9'))
1302 if (ch
>= 'a' && ch
<= 'f')
1303 return ch
- 'a' + 10;
1304 if (ch
>= '0' && ch
<= '9')
1306 if (ch
>= 'A' && ch
<= 'F')
1307 return ch
- 'A' + 10;
1312 stub_unpack_int (char *buff
, int fieldlength
)
1319 nibble
= stubhex (*buff
++);
1323 retval
= retval
<< 4;
1329 unpack_varlen_hex (char *buff
, /* packet to parse */
1333 ULONGEST retval
= 0;
1335 while (ishex (*buff
, &nibble
))
1338 retval
= retval
<< 4;
1339 retval
|= nibble
& 0x0f;
1346 unpack_nibble (char *buf
, int *val
)
1348 ishex (*buf
++, val
);
1353 pack_nibble (char *buf
, int nibble
)
1355 *buf
++ = hexchars
[(nibble
& 0x0f)];
1360 pack_hex_byte (char *pkt
, int byte
)
1362 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1363 *pkt
++ = hexchars
[(byte
& 0xf)];
1368 unpack_byte (char *buf
, int *value
)
1370 *value
= stub_unpack_int (buf
, 2);
1375 pack_int (char *buf
, int value
)
1377 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1378 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1379 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1380 buf
= pack_hex_byte (buf
, (value
& 0xff));
1385 unpack_int (char *buf
, int *value
)
1387 *value
= stub_unpack_int (buf
, 8);
1391 #if 0 /* Currently unused, uncomment when needed. */
1392 static char *pack_string (char *pkt
, char *string
);
1395 pack_string (char *pkt
, char *string
)
1400 len
= strlen (string
);
1402 len
= 200; /* Bigger than most GDB packets, junk??? */
1403 pkt
= pack_hex_byte (pkt
, len
);
1407 if ((ch
== '\0') || (ch
== '#'))
1408 ch
= '*'; /* Protect encapsulation. */
1413 #endif /* 0 (unused) */
1416 unpack_string (char *src
, char *dest
, int length
)
1425 pack_threadid (char *pkt
, threadref
*id
)
1428 unsigned char *altid
;
1430 altid
= (unsigned char *) id
;
1431 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1433 pkt
= pack_hex_byte (pkt
, *altid
++);
1439 unpack_threadid (char *inbuf
, threadref
*id
)
1442 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1445 altref
= (char *) id
;
1447 while (inbuf
< limit
)
1449 x
= stubhex (*inbuf
++);
1450 y
= stubhex (*inbuf
++);
1451 *altref
++ = (x
<< 4) | y
;
1456 /* Externally, threadrefs are 64 bits but internally, they are still
1457 ints. This is due to a mismatch of specifications. We would like
1458 to use 64bit thread references internally. This is an adapter
1462 int_to_threadref (threadref
*id
, int value
)
1464 unsigned char *scan
;
1466 scan
= (unsigned char *) id
;
1472 *scan
++ = (value
>> 24) & 0xff;
1473 *scan
++ = (value
>> 16) & 0xff;
1474 *scan
++ = (value
>> 8) & 0xff;
1475 *scan
++ = (value
& 0xff);
1479 threadref_to_int (threadref
*ref
)
1482 unsigned char *scan
;
1488 value
= (value
<< 8) | ((*scan
++) & 0xff);
1493 copy_threadref (threadref
*dest
, threadref
*src
)
1496 unsigned char *csrc
, *cdest
;
1498 csrc
= (unsigned char *) src
;
1499 cdest
= (unsigned char *) dest
;
1506 threadmatch (threadref
*dest
, threadref
*src
)
1508 /* Things are broken right now, so just assume we got a match. */
1510 unsigned char *srcp
, *destp
;
1512 srcp
= (char *) src
;
1513 destp
= (char *) dest
;
1517 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1524 threadid:1, # always request threadid
1531 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1534 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1536 *pkt
++ = 'q'; /* Info Query */
1537 *pkt
++ = 'P'; /* process or thread info */
1538 pkt
= pack_int (pkt
, mode
); /* mode */
1539 pkt
= pack_threadid (pkt
, id
); /* threadid */
1540 *pkt
= '\0'; /* terminate */
1544 /* These values tag the fields in a thread info response packet. */
1545 /* Tagging the fields allows us to request specific fields and to
1546 add more fields as time goes by. */
1548 #define TAG_THREADID 1 /* Echo the thread identifier. */
1549 #define TAG_EXISTS 2 /* Is this process defined enough to
1550 fetch registers and its stack? */
1551 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1552 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1553 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1557 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1558 struct gdb_ext_thread_info
*info
)
1560 struct remote_state
*rs
= get_remote_state ();
1564 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1567 /* info->threadid = 0; FIXME: implement zero_threadref. */
1569 info
->display
[0] = '\0';
1570 info
->shortname
[0] = '\0';
1571 info
->more_display
[0] = '\0';
1573 /* Assume the characters indicating the packet type have been
1575 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1576 pkt
= unpack_threadid (pkt
, &ref
);
1579 warning (_("Incomplete response to threadinfo request."));
1580 if (!threadmatch (&ref
, expectedref
))
1581 { /* This is an answer to a different request. */
1582 warning (_("ERROR RMT Thread info mismatch."));
1585 copy_threadref (&info
->threadid
, &ref
);
1587 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1589 /* Packets are terminated with nulls. */
1590 while ((pkt
< limit
) && mask
&& *pkt
)
1592 pkt
= unpack_int (pkt
, &tag
); /* tag */
1593 pkt
= unpack_byte (pkt
, &length
); /* length */
1594 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1596 warning (_("ERROR RMT: threadinfo tag mismatch."));
1600 if (tag
== TAG_THREADID
)
1604 warning (_("ERROR RMT: length of threadid is not 16."));
1608 pkt
= unpack_threadid (pkt
, &ref
);
1609 mask
= mask
& ~TAG_THREADID
;
1612 if (tag
== TAG_EXISTS
)
1614 info
->active
= stub_unpack_int (pkt
, length
);
1616 mask
= mask
& ~(TAG_EXISTS
);
1619 warning (_("ERROR RMT: 'exists' length too long."));
1625 if (tag
== TAG_THREADNAME
)
1627 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1628 mask
= mask
& ~TAG_THREADNAME
;
1631 if (tag
== TAG_DISPLAY
)
1633 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1634 mask
= mask
& ~TAG_DISPLAY
;
1637 if (tag
== TAG_MOREDISPLAY
)
1639 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1640 mask
= mask
& ~TAG_MOREDISPLAY
;
1643 warning (_("ERROR RMT: unknown thread info tag."));
1644 break; /* Not a tag we know about. */
1650 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1651 struct gdb_ext_thread_info
*info
)
1653 struct remote_state
*rs
= get_remote_state ();
1656 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1658 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1659 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1664 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1667 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1668 threadref
*nextthread
)
1670 *pkt
++ = 'q'; /* info query packet */
1671 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1672 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1673 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1674 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1679 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1682 parse_threadlist_response (char *pkt
, int result_limit
,
1683 threadref
*original_echo
, threadref
*resultlist
,
1686 struct remote_state
*rs
= get_remote_state ();
1688 int count
, resultcount
, done
;
1691 /* Assume the 'q' and 'M chars have been stripped. */
1692 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1693 /* done parse past here */
1694 pkt
= unpack_byte (pkt
, &count
); /* count field */
1695 pkt
= unpack_nibble (pkt
, &done
);
1696 /* The first threadid is the argument threadid. */
1697 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1698 while ((count
-- > 0) && (pkt
< limit
))
1700 pkt
= unpack_threadid (pkt
, resultlist
++);
1701 if (resultcount
++ >= result_limit
)
1710 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1711 int *done
, int *result_count
, threadref
*threadlist
)
1713 struct remote_state
*rs
= get_remote_state ();
1714 static threadref echo_nextthread
;
1717 /* Trancate result limit to be smaller than the packet size. */
1718 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1719 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1721 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1723 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1726 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1729 if (!threadmatch (&echo_nextthread
, nextthread
))
1731 /* FIXME: This is a good reason to drop the packet. */
1732 /* Possably, there is a duplicate response. */
1734 retransmit immediatly - race conditions
1735 retransmit after timeout - yes
1737 wait for packet, then exit
1739 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1740 return 0; /* I choose simply exiting. */
1742 if (*result_count
<= 0)
1746 warning (_("RMT ERROR : failed to get remote thread list."));
1749 return result
; /* break; */
1751 if (*result_count
> result_limit
)
1754 warning (_("RMT ERROR: threadlist response longer than requested."));
1760 /* This is the interface between remote and threads, remotes upper
1763 /* remote_find_new_threads retrieves the thread list and for each
1764 thread in the list, looks up the thread in GDB's internal list,
1765 ading the thread if it does not already exist. This involves
1766 getting partial thread lists from the remote target so, polling the
1767 quit_flag is required. */
1770 /* About this many threadisds fit in a packet. */
1772 #define MAXTHREADLISTRESULTS 32
1775 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1778 int done
, i
, result_count
;
1782 static threadref nextthread
;
1783 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1788 if (loopcount
++ > looplimit
)
1791 warning (_("Remote fetch threadlist -infinite loop-."));
1794 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1795 &done
, &result_count
, resultthreadlist
))
1800 /* Clear for later iterations. */
1802 /* Setup to resume next batch of thread references, set nextthread. */
1803 if (result_count
>= 1)
1804 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1806 while (result_count
--)
1807 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1814 remote_newthread_step (threadref
*ref
, void *context
)
1818 ptid
= pid_to_ptid (threadref_to_int (ref
));
1820 if (!in_thread_list (ptid
))
1822 return 1; /* continue iterator */
1825 #define CRAZY_MAX_THREADS 1000
1828 remote_current_thread (ptid_t oldpid
)
1830 struct remote_state
*rs
= get_remote_state ();
1833 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1834 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1835 /* Use strtoul here, so we'll correctly parse values whose highest
1836 bit is set. The protocol carries them as a simple series of
1837 hex digits; in the absence of a sign, strtol will see such
1838 values as positive numbers out of range for signed 'long', and
1839 return LONG_MAX to indicate an overflow. */
1840 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1845 /* Find new threads for info threads command.
1846 * Original version, using John Metzler's thread protocol.
1850 remote_find_new_threads (void)
1852 remote_threadlist_iterator (remote_newthread_step
, 0,
1854 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1855 inferior_ptid
= remote_current_thread (inferior_ptid
);
1859 * Find all threads for info threads command.
1860 * Uses new thread protocol contributed by Cisco.
1861 * Falls back and attempts to use the older method (above)
1862 * if the target doesn't respond to the new method.
1866 remote_threads_info (void)
1868 struct remote_state
*rs
= get_remote_state ();
1872 if (remote_desc
== 0) /* paranoia */
1873 error (_("Command can only be used when connected to the remote target."));
1875 if (use_threadinfo_query
)
1877 putpkt ("qfThreadInfo");
1878 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1880 if (bufp
[0] != '\0') /* q packet recognized */
1882 while (*bufp
++ == 'm') /* reply contains one or more TID */
1886 /* Use strtoul here, so we'll correctly parse values
1887 whose highest bit is set. The protocol carries
1888 them as a simple series of hex digits; in the
1889 absence of a sign, strtol will see such values as
1890 positive numbers out of range for signed 'long',
1891 and return LONG_MAX to indicate an overflow. */
1892 tid
= strtoul (bufp
, &bufp
, 16);
1893 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1894 add_thread (pid_to_ptid (tid
));
1896 while (*bufp
++ == ','); /* comma-separated list */
1897 putpkt ("qsThreadInfo");
1898 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1905 /* Else fall back to old method based on jmetzler protocol. */
1906 use_threadinfo_query
= 0;
1907 remote_find_new_threads ();
1912 * Collect a descriptive string about the given thread.
1913 * The target may say anything it wants to about the thread
1914 * (typically info about its blocked / runnable state, name, etc.).
1915 * This string will appear in the info threads display.
1917 * Optional: targets are not required to implement this function.
1921 remote_threads_extra_info (struct thread_info
*tp
)
1923 struct remote_state
*rs
= get_remote_state ();
1927 struct gdb_ext_thread_info threadinfo
;
1928 static char display_buf
[100]; /* arbitrary... */
1929 int n
= 0; /* position in display_buf */
1931 if (remote_desc
== 0) /* paranoia */
1932 internal_error (__FILE__
, __LINE__
,
1933 _("remote_threads_extra_info"));
1935 if (use_threadextra_query
)
1937 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1940 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1941 if (rs
->buf
[0] != 0)
1943 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1944 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1945 display_buf
[result
] = '\0';
1950 /* If the above query fails, fall back to the old method. */
1951 use_threadextra_query
= 0;
1952 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1953 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1954 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1955 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1956 if (threadinfo
.active
)
1958 if (*threadinfo
.shortname
)
1959 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1960 " Name: %s,", threadinfo
.shortname
);
1961 if (*threadinfo
.display
)
1962 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1963 " State: %s,", threadinfo
.display
);
1964 if (*threadinfo
.more_display
)
1965 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1966 " Priority: %s", threadinfo
.more_display
);
1970 /* For purely cosmetic reasons, clear up trailing commas. */
1971 if (',' == display_buf
[n
-1])
1972 display_buf
[n
-1] = ' ';
1980 /* Restart the remote side; this is an extended protocol operation. */
1983 extended_remote_restart (void)
1985 struct remote_state
*rs
= get_remote_state ();
1987 /* Send the restart command; for reasons I don't understand the
1988 remote side really expects a number after the "R". */
1989 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1992 remote_fileio_reset ();
1994 /* Now query for status so this looks just like we restarted
1995 gdbserver from scratch. */
1997 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2000 /* Clean up connection to a remote debugger. */
2003 remote_close (int quitting
)
2006 serial_close (remote_desc
);
2010 /* Query the remote side for the text, data and bss offsets. */
2015 struct remote_state
*rs
= get_remote_state ();
2018 int lose
, num_segments
= 0, do_sections
, do_segments
;
2019 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
2020 struct section_offsets
*offs
;
2021 struct symfile_segment_data
*data
;
2023 if (symfile_objfile
== NULL
)
2026 putpkt ("qOffsets");
2027 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2030 if (buf
[0] == '\000')
2031 return; /* Return silently. Stub doesn't support
2035 warning (_("Remote failure reply: %s"), buf
);
2039 /* Pick up each field in turn. This used to be done with scanf, but
2040 scanf will make trouble if CORE_ADDR size doesn't match
2041 conversion directives correctly. The following code will work
2042 with any size of CORE_ADDR. */
2043 text_addr
= data_addr
= bss_addr
= 0;
2047 if (strncmp (ptr
, "Text=", 5) == 0)
2050 /* Don't use strtol, could lose on big values. */
2051 while (*ptr
&& *ptr
!= ';')
2052 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2054 if (strncmp (ptr
, ";Data=", 6) == 0)
2057 while (*ptr
&& *ptr
!= ';')
2058 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2063 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2066 while (*ptr
&& *ptr
!= ';')
2067 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2069 if (bss_addr
!= data_addr
)
2070 warning (_("Target reported unsupported offsets: %s"), buf
);
2075 else if (strncmp (ptr
, "TextSeg=", 8) == 0)
2078 /* Don't use strtol, could lose on big values. */
2079 while (*ptr
&& *ptr
!= ';')
2080 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2083 if (strncmp (ptr
, ";DataSeg=", 9) == 0)
2086 while (*ptr
&& *ptr
!= ';')
2087 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2095 error (_("Malformed response to offset query, %s"), buf
);
2096 else if (*ptr
!= '\0')
2097 warning (_("Target reported unsupported offsets: %s"), buf
);
2099 offs
= ((struct section_offsets
*)
2100 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2101 memcpy (offs
, symfile_objfile
->section_offsets
,
2102 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2104 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
2105 do_segments
= (data
!= NULL
);
2106 do_sections
= num_segments
== 0;
2108 /* Text= and Data= specify offsets for the text and data sections,
2109 but symfile_map_offsets_to_segments expects base addresses
2110 instead of offsets. If we have two segments, we can still
2111 try to relocate the whole segments instead of just ".text"
2113 if (num_segments
== 0)
2116 if (data
== NULL
|| data
->num_segments
!= 2)
2120 segments
[0] = data
->segment_bases
[0] + text_addr
;
2121 segments
[1] = data
->segment_bases
[1] + data_addr
;
2127 segments
[0] = text_addr
;
2128 segments
[1] = data_addr
;
2133 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
2134 offs
, num_segments
, segments
);
2136 if (ret
== 0 && !do_sections
)
2137 error (_("Can not handle qOffsets TextSeg response with this symbol file"));
2143 free_symfile_segment_data (data
);
2147 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2149 /* This is a temporary kludge to force data and bss to use the same offsets
2150 because that's what nlmconv does now. The real solution requires changes
2151 to the stub and remote.c that I don't have time to do right now. */
2153 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2154 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2157 objfile_relocate (symfile_objfile
, offs
);
2160 /* Stub for catch_exception. */
2163 remote_start_remote (struct ui_out
*uiout
, void *from_tty_p
)
2165 int from_tty
= * (int *) from_tty_p
;
2167 immediate_quit
++; /* Allow user to interrupt it. */
2169 /* Ack any packet which the remote side has already sent. */
2170 serial_write (remote_desc
, "+", 1);
2172 /* Let the stub know that we want it to return the thread. */
2175 inferior_ptid
= remote_current_thread (inferior_ptid
);
2177 get_offsets (); /* Get text, data & bss offsets. */
2179 putpkt ("?"); /* Initiate a query from remote machine. */
2182 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
2185 /* Open a connection to a remote debugger.
2186 NAME is the filename used for communication. */
2189 remote_open (char *name
, int from_tty
)
2191 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2194 /* Just like remote_open, but with asynchronous support. */
2196 remote_async_open (char *name
, int from_tty
)
2198 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2201 /* Open a connection to a remote debugger using the extended
2202 remote gdb protocol. NAME is the filename used for communication. */
2205 extended_remote_open (char *name
, int from_tty
)
2207 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2211 /* Just like extended_remote_open, but with asynchronous support. */
2213 extended_remote_async_open (char *name
, int from_tty
)
2215 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2216 1 /*extended_p */, 1 /* async_p */);
2219 /* Generic code for opening a connection to a remote target. */
2222 init_all_packet_configs (void)
2225 for (i
= 0; i
< PACKET_MAX
; i
++)
2226 update_packet_config (&remote_protocol_packets
[i
]);
2229 /* Symbol look-up. */
2232 remote_check_symbols (struct objfile
*objfile
)
2234 struct remote_state
*rs
= get_remote_state ();
2235 char *msg
, *reply
, *tmp
;
2236 struct minimal_symbol
*sym
;
2239 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2242 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2243 because we need both at the same time. */
2244 msg
= alloca (get_remote_packet_size ());
2246 /* Invite target to request symbol lookups. */
2248 putpkt ("qSymbol::");
2249 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2250 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2253 while (strncmp (reply
, "qSymbol:", 8) == 0)
2256 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2258 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2260 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2262 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2263 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2266 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2271 static struct serial
*
2272 remote_serial_open (char *name
)
2274 static int udp_warning
= 0;
2276 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2277 of in ser-tcp.c, because it is the remote protocol assuming that the
2278 serial connection is reliable and not the serial connection promising
2280 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2283 The remote protocol may be unreliable over UDP.\n\
2284 Some events may be lost, rendering further debugging impossible."));
2288 return serial_open (name
);
2291 /* This type describes each known response to the qSupported
2293 struct protocol_feature
2295 /* The name of this protocol feature. */
2298 /* The default for this protocol feature. */
2299 enum packet_support default_support
;
2301 /* The function to call when this feature is reported, or after
2302 qSupported processing if the feature is not supported.
2303 The first argument points to this structure. The second
2304 argument indicates whether the packet requested support be
2305 enabled, disabled, or probed (or the default, if this function
2306 is being called at the end of processing and this feature was
2307 not reported). The third argument may be NULL; if not NULL, it
2308 is a NUL-terminated string taken from the packet following
2309 this feature's name and an equals sign. */
2310 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2313 /* The corresponding packet for this feature. Only used if
2314 FUNC is remote_supported_packet. */
2319 remote_supported_packet (const struct protocol_feature
*feature
,
2320 enum packet_support support
,
2321 const char *argument
)
2325 warning (_("Remote qSupported response supplied an unexpected value for"
2326 " \"%s\"."), feature
->name
);
2330 if (remote_protocol_packets
[feature
->packet
].support
2331 == PACKET_SUPPORT_UNKNOWN
)
2332 remote_protocol_packets
[feature
->packet
].support
= support
;
2336 remote_packet_size (const struct protocol_feature
*feature
,
2337 enum packet_support support
, const char *value
)
2339 struct remote_state
*rs
= get_remote_state ();
2344 if (support
!= PACKET_ENABLE
)
2347 if (value
== NULL
|| *value
== '\0')
2349 warning (_("Remote target reported \"%s\" without a size."),
2355 packet_size
= strtol (value
, &value_end
, 16);
2356 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2358 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2359 feature
->name
, value
);
2363 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2365 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2366 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2367 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2370 /* Record the new maximum packet size. */
2371 rs
->explicit_packet_size
= packet_size
;
2374 static struct protocol_feature remote_protocol_features
[] = {
2375 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2376 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2377 PACKET_qXfer_auxv
},
2378 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2379 PACKET_qXfer_features
},
2380 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
2381 PACKET_qXfer_libraries
},
2382 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2383 PACKET_qXfer_memory_map
},
2384 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
2385 PACKET_qXfer_spu_read
},
2386 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
2387 PACKET_qXfer_spu_write
},
2388 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2389 PACKET_QPassSignals
},
2393 remote_query_supported (void)
2395 struct remote_state
*rs
= get_remote_state ();
2398 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2400 /* The packet support flags are handled differently for this packet
2401 than for most others. We treat an error, a disabled packet, and
2402 an empty response identically: any features which must be reported
2403 to be used will be automatically disabled. An empty buffer
2404 accomplishes this, since that is also the representation for a list
2405 containing no features. */
2408 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2410 putpkt ("qSupported");
2411 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2413 /* If an error occured, warn, but do not return - just reset the
2414 buffer to empty and go on to disable features. */
2415 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2418 warning (_("Remote failure reply: %s"), rs
->buf
);
2423 memset (seen
, 0, sizeof (seen
));
2428 enum packet_support is_supported
;
2429 char *p
, *end
, *name_end
, *value
;
2431 /* First separate out this item from the rest of the packet. If
2432 there's another item after this, we overwrite the separator
2433 (terminated strings are much easier to work with). */
2435 end
= strchr (p
, ';');
2438 end
= p
+ strlen (p
);
2448 warning (_("empty item in \"qSupported\" response"));
2453 name_end
= strchr (p
, '=');
2456 /* This is a name=value entry. */
2457 is_supported
= PACKET_ENABLE
;
2458 value
= name_end
+ 1;
2467 is_supported
= PACKET_ENABLE
;
2471 is_supported
= PACKET_DISABLE
;
2475 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2479 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2485 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2486 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2488 const struct protocol_feature
*feature
;
2491 feature
= &remote_protocol_features
[i
];
2492 feature
->func (feature
, is_supported
, value
);
2497 /* If we increased the packet size, make sure to increase the global
2498 buffer size also. We delay this until after parsing the entire
2499 qSupported packet, because this is the same buffer we were
2501 if (rs
->buf_size
< rs
->explicit_packet_size
)
2503 rs
->buf_size
= rs
->explicit_packet_size
;
2504 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2507 /* Handle the defaults for unmentioned features. */
2508 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2511 const struct protocol_feature
*feature
;
2513 feature
= &remote_protocol_features
[i
];
2514 feature
->func (feature
, feature
->default_support
, NULL
);
2520 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2521 int extended_p
, int async_p
)
2523 struct remote_state
*rs
= get_remote_state ();
2525 error (_("To open a remote debug connection, you need to specify what\n"
2526 "serial device is attached to the remote system\n"
2527 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2529 /* See FIXME above. */
2531 wait_forever_enabled_p
= 1;
2533 target_preopen (from_tty
);
2535 unpush_target (target
);
2537 /* Make sure we send the passed signals list the next time we resume. */
2538 xfree (last_pass_packet
);
2539 last_pass_packet
= NULL
;
2541 remote_fileio_reset ();
2542 reopen_exec_file ();
2545 remote_desc
= remote_serial_open (name
);
2547 perror_with_name (name
);
2549 if (baud_rate
!= -1)
2551 if (serial_setbaudrate (remote_desc
, baud_rate
))
2553 /* The requested speed could not be set. Error out to
2554 top level after closing remote_desc. Take care to
2555 set remote_desc to NULL to avoid closing remote_desc
2557 serial_close (remote_desc
);
2559 perror_with_name (name
);
2563 serial_raw (remote_desc
);
2565 /* If there is something sitting in the buffer we might take it as a
2566 response to a command, which would be bad. */
2567 serial_flush_input (remote_desc
);
2571 puts_filtered ("Remote debugging using ");
2572 puts_filtered (name
);
2573 puts_filtered ("\n");
2575 push_target (target
); /* Switch to using remote target now. */
2577 /* Reset the target state; these things will be queried either by
2578 remote_query_supported or as they are needed. */
2579 init_all_packet_configs ();
2580 rs
->explicit_packet_size
= 0;
2582 general_thread
= -2;
2583 continue_thread
= -2;
2585 /* Probe for ability to use "ThreadInfo" query, as required. */
2586 use_threadinfo_query
= 1;
2587 use_threadextra_query
= 1;
2589 /* The first packet we send to the target is the optional "supported
2590 packets" request. If the target can answer this, it will tell us
2591 which later probes to skip. */
2592 remote_query_supported ();
2594 /* Next, if the target can specify a description, read it. We do
2595 this before anything involving memory or registers. */
2596 target_find_description ();
2598 /* Without this, some commands which require an active target (such
2599 as kill) won't work. This variable serves (at least) double duty
2600 as both the pid of the target process (if it has such), and as a
2601 flag indicating that a target is active. These functions should
2602 be split out into seperate variables, especially since GDB will
2603 someday have a notion of debugging several processes. */
2605 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2609 /* With this target we start out by owning the terminal. */
2610 remote_async_terminal_ours_p
= 1;
2612 /* FIXME: cagney/1999-09-23: During the initial connection it is
2613 assumed that the target is already ready and able to respond to
2614 requests. Unfortunately remote_start_remote() eventually calls
2615 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2616 around this. Eventually a mechanism that allows
2617 wait_for_inferior() to expect/get timeouts will be
2619 wait_forever_enabled_p
= 0;
2622 /* First delete any symbols previously loaded from shared libraries. */
2623 no_shared_libraries (NULL
, 0);
2625 /* Start the remote connection. If error() or QUIT, discard this
2626 target (we'd otherwise be in an inconsistent state) and then
2627 propogate the error on up the exception chain. This ensures that
2628 the caller doesn't stumble along blindly assuming that the
2629 function succeeded. The CLI doesn't have this problem but other
2630 UI's, such as MI do.
2632 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2633 this function should return an error indication letting the
2634 caller restore the previous state. Unfortunately the command
2635 ``target remote'' is directly wired to this function making that
2636 impossible. On a positive note, the CLI side of this problem has
2637 been fixed - the function set_cmd_context() makes it possible for
2638 all the ``target ....'' commands to share a common callback
2639 function. See cli-dump.c. */
2641 struct gdb_exception ex
2642 = catch_exception (uiout
, remote_start_remote
, &from_tty
,
2648 wait_forever_enabled_p
= 1;
2649 throw_exception (ex
);
2654 wait_forever_enabled_p
= 1;
2658 /* Tell the remote that we are using the extended protocol. */
2660 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2663 if (exec_bfd
) /* No use without an exec file. */
2664 remote_check_symbols (symfile_objfile
);
2667 /* This takes a program previously attached to and detaches it. After
2668 this is done, GDB can be used to debug some other program. We
2669 better not have left any breakpoints in the target program or it'll
2670 die when it hits one. */
2673 remote_detach (char *args
, int from_tty
)
2675 struct remote_state
*rs
= get_remote_state ();
2678 error (_("Argument given to \"detach\" when remotely debugging."));
2680 /* Tell the remote target to detach. */
2681 strcpy (rs
->buf
, "D");
2683 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2685 if (rs
->buf
[0] == 'E')
2686 error (_("Can't detach process."));
2688 /* Unregister the file descriptor from the event loop. */
2689 if (target_is_async_p ())
2690 serial_async (remote_desc
, NULL
, 0);
2692 target_mourn_inferior ();
2694 puts_filtered ("Ending remote debugging.\n");
2697 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2700 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2703 error (_("Argument given to \"detach\" when remotely debugging."));
2705 /* Unregister the file descriptor from the event loop. */
2706 if (target_is_async_p ())
2707 serial_async (remote_desc
, NULL
, 0);
2709 target_mourn_inferior ();
2711 puts_filtered ("Ending remote debugging.\n");
2714 /* Convert hex digit A to a number. */
2719 if (a
>= '0' && a
<= '9')
2721 else if (a
>= 'a' && a
<= 'f')
2722 return a
- 'a' + 10;
2723 else if (a
>= 'A' && a
<= 'F')
2724 return a
- 'A' + 10;
2726 error (_("Reply contains invalid hex digit %d"), a
);
2730 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2734 for (i
= 0; i
< count
; i
++)
2736 if (hex
[0] == 0 || hex
[1] == 0)
2738 /* Hex string is short, or of uneven length.
2739 Return the count that has been converted so far. */
2742 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2748 /* Convert number NIB to a hex digit. */
2756 return 'a' + nib
- 10;
2760 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2763 /* May use a length, or a nul-terminated string as input. */
2765 count
= strlen ((char *) bin
);
2767 for (i
= 0; i
< count
; i
++)
2769 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2770 *hex
++ = tohex (*bin
++ & 0xf);
2776 /* Check for the availability of vCont. This function should also check
2780 remote_vcont_probe (struct remote_state
*rs
)
2784 strcpy (rs
->buf
, "vCont?");
2786 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2789 /* Make sure that the features we assume are supported. */
2790 if (strncmp (buf
, "vCont", 5) == 0)
2793 int support_s
, support_S
, support_c
, support_C
;
2799 while (p
&& *p
== ';')
2802 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2804 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2806 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2808 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2811 p
= strchr (p
, ';');
2814 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2815 BUF will make packet_ok disable the packet. */
2816 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2820 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2823 /* Resume the remote inferior by using a "vCont" packet. The thread
2824 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2825 resumed thread should be single-stepped and/or signalled. If PTID's
2826 PID is -1, then all threads are resumed; the thread to be stepped and/or
2827 signalled is given in the global INFERIOR_PTID. This function returns
2828 non-zero iff it resumes the inferior.
2830 This function issues a strict subset of all possible vCont commands at the
2834 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2836 struct remote_state
*rs
= get_remote_state ();
2837 int pid
= PIDGET (ptid
);
2838 char *buf
= NULL
, *outbuf
;
2839 struct cleanup
*old_cleanup
;
2841 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2842 remote_vcont_probe (rs
);
2844 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2847 /* If we could generate a wider range of packets, we'd have to worry
2848 about overflowing BUF. Should there be a generic
2849 "multi-part-packet" packet? */
2851 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2853 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2854 don't have any PID numbers the inferior will understand. Make sure
2855 to only send forms that do not specify a PID. */
2856 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2857 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2859 outbuf
= xstrprintf ("vCont;s");
2860 else if (siggnal
!= TARGET_SIGNAL_0
)
2861 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2863 outbuf
= xstrprintf ("vCont;c");
2867 /* Resume all threads, with preference for INFERIOR_PTID. */
2868 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2869 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2870 PIDGET (inferior_ptid
));
2872 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2873 else if (siggnal
!= TARGET_SIGNAL_0
)
2874 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2875 PIDGET (inferior_ptid
));
2877 outbuf
= xstrprintf ("vCont;c");
2881 /* Scheduler locking; resume only PTID. */
2882 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2883 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2885 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2886 else if (siggnal
!= TARGET_SIGNAL_0
)
2887 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2889 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2892 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2893 old_cleanup
= make_cleanup (xfree
, outbuf
);
2897 do_cleanups (old_cleanup
);
2902 /* Tell the remote machine to resume. */
2904 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2906 static int last_sent_step
;
2909 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2911 struct remote_state
*rs
= get_remote_state ();
2913 int pid
= PIDGET (ptid
);
2915 last_sent_signal
= siggnal
;
2916 last_sent_step
= step
;
2918 /* A hook for when we need to do something at the last moment before
2920 if (deprecated_target_resume_hook
)
2921 (*deprecated_target_resume_hook
) ();
2923 /* Update the inferior on signals to silently pass, if they've changed. */
2924 remote_pass_signals ();
2926 /* The vCont packet doesn't need to specify threads via Hc. */
2927 if (remote_vcont_resume (ptid
, step
, siggnal
))
2930 /* All other supported resume packets do use Hc, so call set_thread. */
2932 set_thread (0, 0); /* Run any thread. */
2934 set_thread (pid
, 0); /* Run this thread. */
2937 if (siggnal
!= TARGET_SIGNAL_0
)
2939 buf
[0] = step
? 'S' : 'C';
2940 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2941 buf
[2] = tohex (((int) siggnal
) & 0xf);
2945 strcpy (buf
, step
? "s" : "c");
2950 /* Same as remote_resume, but with async support. */
2952 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2954 remote_resume (ptid
, step
, siggnal
);
2956 /* We are about to start executing the inferior, let's register it
2957 with the event loop. NOTE: this is the one place where all the
2958 execution commands end up. We could alternatively do this in each
2959 of the execution commands in infcmd.c. */
2960 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2961 into infcmd.c in order to allow inferior function calls to work
2962 NOT asynchronously. */
2963 if (target_can_async_p ())
2964 target_async (inferior_event_handler
, 0);
2965 /* Tell the world that the target is now executing. */
2966 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2967 this? Instead, should the client of target just assume (for
2968 async targets) that the target is going to start executing? Is
2969 this information already found in the continuation block? */
2970 if (target_is_async_p ())
2971 target_executing
= 1;
2975 /* Set up the signal handler for SIGINT, while the target is
2976 executing, ovewriting the 'regular' SIGINT signal handler. */
2978 initialize_sigint_signal_handler (void)
2980 sigint_remote_token
=
2981 create_async_signal_handler (async_remote_interrupt
, NULL
);
2982 signal (SIGINT
, handle_remote_sigint
);
2985 /* Signal handler for SIGINT, while the target is executing. */
2987 handle_remote_sigint (int sig
)
2989 signal (sig
, handle_remote_sigint_twice
);
2990 sigint_remote_twice_token
=
2991 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2992 mark_async_signal_handler_wrapper (sigint_remote_token
);
2995 /* Signal handler for SIGINT, installed after SIGINT has already been
2996 sent once. It will take effect the second time that the user sends
2999 handle_remote_sigint_twice (int sig
)
3001 signal (sig
, handle_sigint
);
3002 sigint_remote_twice_token
=
3003 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
3004 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
3007 /* Perform the real interruption of the target execution, in response
3010 async_remote_interrupt (gdb_client_data arg
)
3013 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3018 /* Perform interrupt, if the first attempt did not succeed. Just give
3019 up on the target alltogether. */
3021 async_remote_interrupt_twice (gdb_client_data arg
)
3024 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
3025 /* Do something only if the target was not killed by the previous
3027 if (target_executing
)
3030 signal (SIGINT
, handle_remote_sigint
);
3034 /* Reinstall the usual SIGINT handlers, after the target has
3037 cleanup_sigint_signal_handler (void *dummy
)
3039 signal (SIGINT
, handle_sigint
);
3040 if (sigint_remote_twice_token
)
3041 delete_async_signal_handler (&sigint_remote_twice_token
);
3042 if (sigint_remote_token
)
3043 delete_async_signal_handler (&sigint_remote_token
);
3046 /* Send ^C to target to halt it. Target will respond, and send us a
3048 static void (*ofunc
) (int);
3050 /* The command line interface's stop routine. This function is installed
3051 as a signal handler for SIGINT. The first time a user requests a
3052 stop, we call remote_stop to send a break or ^C. If there is no
3053 response from the target (it didn't stop when the user requested it),
3054 we ask the user if he'd like to detach from the target. */
3056 remote_interrupt (int signo
)
3058 /* If this doesn't work, try more severe steps. */
3059 signal (signo
, remote_interrupt_twice
);
3062 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3067 /* The user typed ^C twice. */
3070 remote_interrupt_twice (int signo
)
3072 signal (signo
, ofunc
);
3074 signal (signo
, remote_interrupt
);
3077 /* This is the generic stop called via the target vector. When a target
3078 interrupt is requested, either by the command line or the GUI, we
3079 will eventually end up here. */
3083 /* Send a break or a ^C, depending on user preference. */
3085 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
3088 serial_send_break (remote_desc
);
3090 serial_write (remote_desc
, "\003", 1);
3093 /* Ask the user what to do when an interrupt is received. */
3096 interrupt_query (void)
3098 target_terminal_ours ();
3100 if (query ("Interrupted while waiting for the program.\n\
3101 Give up (and stop debugging it)? "))
3103 target_mourn_inferior ();
3104 deprecated_throw_reason (RETURN_QUIT
);
3107 target_terminal_inferior ();
3110 /* Enable/disable target terminal ownership. Most targets can use
3111 terminal groups to control terminal ownership. Remote targets are
3112 different in that explicit transfer of ownership to/from GDB/target
3116 remote_async_terminal_inferior (void)
3118 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3119 sync_execution here. This function should only be called when
3120 GDB is resuming the inferior in the forground. A background
3121 resume (``run&'') should leave GDB in control of the terminal and
3122 consequently should not call this code. */
3123 if (!sync_execution
)
3125 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3126 calls target_terminal_*() idenpotent. The event-loop GDB talking
3127 to an asynchronous target with a synchronous command calls this
3128 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3129 stops trying to transfer the terminal to the target when it
3130 shouldn't this guard can go away. */
3131 if (!remote_async_terminal_ours_p
)
3133 delete_file_handler (input_fd
);
3134 remote_async_terminal_ours_p
= 0;
3135 initialize_sigint_signal_handler ();
3136 /* NOTE: At this point we could also register our selves as the
3137 recipient of all input. Any characters typed could then be
3138 passed on down to the target. */
3142 remote_async_terminal_ours (void)
3144 /* See FIXME in remote_async_terminal_inferior. */
3145 if (!sync_execution
)
3147 /* See FIXME in remote_async_terminal_inferior. */
3148 if (remote_async_terminal_ours_p
)
3150 cleanup_sigint_signal_handler (NULL
);
3151 add_file_handler (input_fd
, stdin_event_handler
, 0);
3152 remote_async_terminal_ours_p
= 1;
3155 /* If nonzero, ignore the next kill. */
3160 remote_console_output (char *msg
)
3164 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3167 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3170 fputs_unfiltered (tb
, gdb_stdtarg
);
3172 gdb_flush (gdb_stdtarg
);
3175 /* Wait until the remote machine stops, then return,
3176 storing status in STATUS just as `wait' would.
3177 Returns "pid", which in the case of a multi-threaded
3178 remote OS, is the thread-id. */
3181 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3183 struct remote_state
*rs
= get_remote_state ();
3184 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3185 ULONGEST thread_num
= -1;
3187 int solibs_changed
= 0;
3189 status
->kind
= TARGET_WAITKIND_EXITED
;
3190 status
->value
.integer
= 0;
3196 ofunc
= signal (SIGINT
, remote_interrupt
);
3197 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3198 signal (SIGINT
, ofunc
);
3202 /* This is a hook for when we need to do something (perhaps the
3203 collection of trace data) every time the target stops. */
3204 if (deprecated_target_wait_loop_hook
)
3205 (*deprecated_target_wait_loop_hook
) ();
3207 remote_stopped_by_watchpoint_p
= 0;
3211 case 'E': /* Error of some sort. */
3212 warning (_("Remote failure reply: %s"), buf
);
3214 case 'F': /* File-I/O request. */
3215 remote_fileio_request (buf
);
3217 case 'T': /* Status with PC, SP, FP, ... */
3219 gdb_byte regs
[MAX_REGISTER_SIZE
];
3221 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3222 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3224 n... = register number
3225 r... = register contents
3227 p
= &buf
[3]; /* after Txx */
3236 /* If the packet contains a register number save it in
3237 pnum and set p1 to point to the character following
3238 it. Otherwise p1 points to p. */
3240 /* If this packet is an awatch packet, don't parse the
3241 'a' as a register number. */
3243 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3245 /* Read the ``P'' register number. */
3246 pnum
= strtol (p
, &p_temp
, 16);
3252 if (p1
== p
) /* No register number present here. */
3254 p1
= strchr (p
, ':');
3256 error (_("Malformed packet(a) (missing colon): %s\n\
3259 if (strncmp (p
, "thread", p1
- p
) == 0)
3261 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3262 record_currthread (thread_num
);
3265 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3266 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3267 || (strncmp (p
, "awatch", p1
- p
) == 0))
3269 remote_stopped_by_watchpoint_p
= 1;
3270 p
= unpack_varlen_hex (++p1
, &addr
);
3271 remote_watch_data_address
= (CORE_ADDR
)addr
;
3273 else if (strncmp (p
, "library", p1
- p
) == 0)
3277 while (*p_temp
&& *p_temp
!= ';')
3285 /* Silently skip unknown optional info. */
3286 p_temp
= strchr (p1
+ 1, ';');
3293 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3297 error (_("Malformed packet(b) (missing colon): %s\n\
3302 error (_("Remote sent bad register number %s: %s\n\
3304 phex_nz (pnum
, 0), p
, buf
);
3306 fieldsize
= hex2bin (p
, regs
,
3307 register_size (current_gdbarch
,
3310 if (fieldsize
< register_size (current_gdbarch
,
3312 warning (_("Remote reply is too short: %s"), buf
);
3313 regcache_raw_supply (get_current_regcache (),
3318 error (_("Remote register badly formatted: %s\nhere: %s"),
3323 case 'S': /* Old style status, just signal only. */
3325 status
->kind
= TARGET_WAITKIND_LOADED
;
3328 status
->kind
= TARGET_WAITKIND_STOPPED
;
3329 status
->value
.sig
= (enum target_signal
)
3330 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3335 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3336 record_currthread (thread_num
);
3339 case 'W': /* Target exited. */
3341 /* The remote process exited. */
3342 status
->kind
= TARGET_WAITKIND_EXITED
;
3343 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3347 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3348 status
->value
.sig
= (enum target_signal
)
3349 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3353 case 'O': /* Console output. */
3354 remote_console_output (buf
+ 1);
3357 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3359 /* Zero length reply means that we tried 'S' or 'C' and
3360 the remote system doesn't support it. */
3361 target_terminal_ours_for_output ();
3363 ("Can't send signals to this remote system. %s not sent.\n",
3364 target_signal_to_name (last_sent_signal
));
3365 last_sent_signal
= TARGET_SIGNAL_0
;
3366 target_terminal_inferior ();
3368 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3369 putpkt ((char *) buf
);
3372 /* else fallthrough */
3374 warning (_("Invalid remote reply: %s"), buf
);
3379 if (thread_num
!= -1)
3381 return pid_to_ptid (thread_num
);
3383 return inferior_ptid
;
3386 /* Async version of remote_wait. */
3388 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3390 struct remote_state
*rs
= get_remote_state ();
3391 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3392 ULONGEST thread_num
= -1;
3394 int solibs_changed
= 0;
3396 status
->kind
= TARGET_WAITKIND_EXITED
;
3397 status
->value
.integer
= 0;
3399 remote_stopped_by_watchpoint_p
= 0;
3405 if (!target_is_async_p ())
3406 ofunc
= signal (SIGINT
, remote_interrupt
);
3407 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3408 _never_ wait for ever -> test on target_is_async_p().
3409 However, before we do that we need to ensure that the caller
3410 knows how to take the target into/out of async mode. */
3411 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3412 if (!target_is_async_p ())
3413 signal (SIGINT
, ofunc
);
3417 /* This is a hook for when we need to do something (perhaps the
3418 collection of trace data) every time the target stops. */
3419 if (deprecated_target_wait_loop_hook
)
3420 (*deprecated_target_wait_loop_hook
) ();
3424 case 'E': /* Error of some sort. */
3425 warning (_("Remote failure reply: %s"), buf
);
3427 case 'F': /* File-I/O request. */
3428 remote_fileio_request (buf
);
3430 case 'T': /* Status with PC, SP, FP, ... */
3432 gdb_byte regs
[MAX_REGISTER_SIZE
];
3434 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3435 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3437 n... = register number
3438 r... = register contents
3440 p
= &buf
[3]; /* after Txx */
3449 /* If the packet contains a register number, save it
3450 in pnum and set p1 to point to the character
3451 following it. Otherwise p1 points to p. */
3453 /* If this packet is an awatch packet, don't parse the 'a'
3454 as a register number. */
3456 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3458 /* Read the register number. */
3459 pnum
= strtol (p
, &p_temp
, 16);
3465 if (p1
== p
) /* No register number present here. */
3467 p1
= strchr (p
, ':');
3469 error (_("Malformed packet(a) (missing colon): %s\n\
3472 if (strncmp (p
, "thread", p1
- p
) == 0)
3474 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3475 record_currthread (thread_num
);
3478 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3479 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3480 || (strncmp (p
, "awatch", p1
- p
) == 0))
3482 remote_stopped_by_watchpoint_p
= 1;
3483 p
= unpack_varlen_hex (++p1
, &addr
);
3484 remote_watch_data_address
= (CORE_ADDR
)addr
;
3486 else if (strncmp (p
, "library", p1
- p
) == 0)
3490 while (*p_temp
&& *p_temp
!= ';')
3498 /* Silently skip unknown optional info. */
3499 p_temp
= strchr (p1
+ 1, ';');
3507 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3510 error (_("Malformed packet(b) (missing colon): %s\n\
3515 error (_("Remote sent bad register number %ld: %s\n\
3519 fieldsize
= hex2bin (p
, regs
,
3520 register_size (current_gdbarch
,
3523 if (fieldsize
< register_size (current_gdbarch
,
3525 warning (_("Remote reply is too short: %s"), buf
);
3526 regcache_raw_supply (get_current_regcache (),
3531 error (_("Remote register badly formatted: %s\nhere: %s"),
3536 case 'S': /* Old style status, just signal only. */
3538 status
->kind
= TARGET_WAITKIND_LOADED
;
3541 status
->kind
= TARGET_WAITKIND_STOPPED
;
3542 status
->value
.sig
= (enum target_signal
)
3543 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3548 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3549 record_currthread (thread_num
);
3552 case 'W': /* Target exited. */
3554 /* The remote process exited. */
3555 status
->kind
= TARGET_WAITKIND_EXITED
;
3556 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3560 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3561 status
->value
.sig
= (enum target_signal
)
3562 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3566 case 'O': /* Console output. */
3567 remote_console_output (buf
+ 1);
3568 /* Return immediately to the event loop. The event loop will
3569 still be waiting on the inferior afterwards. */
3570 status
->kind
= TARGET_WAITKIND_IGNORE
;
3573 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3575 /* Zero length reply means that we tried 'S' or 'C' and
3576 the remote system doesn't support it. */
3577 target_terminal_ours_for_output ();
3579 ("Can't send signals to this remote system. %s not sent.\n",
3580 target_signal_to_name (last_sent_signal
));
3581 last_sent_signal
= TARGET_SIGNAL_0
;
3582 target_terminal_inferior ();
3584 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3585 putpkt ((char *) buf
);
3588 /* else fallthrough */
3590 warning (_("Invalid remote reply: %s"), buf
);
3595 if (thread_num
!= -1)
3597 return pid_to_ptid (thread_num
);
3599 return inferior_ptid
;
3602 /* Fetch a single register using a 'p' packet. */
3605 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3607 struct remote_state
*rs
= get_remote_state ();
3609 char regp
[MAX_REGISTER_SIZE
];
3612 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3615 if (reg
->pnum
== -1)
3620 p
+= hexnumstr (p
, reg
->pnum
);
3622 remote_send (&rs
->buf
, &rs
->buf_size
);
3626 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3630 case PACKET_UNKNOWN
:
3633 error (_("Could not fetch register \"%s\""),
3634 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3637 /* If this register is unfetchable, tell the regcache. */
3640 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3644 /* Otherwise, parse and supply the value. */
3650 error (_("fetch_register_using_p: early buf termination"));
3652 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3655 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3659 /* Fetch the registers included in the target's 'g' packet. */
3662 send_g_packet (void)
3664 struct remote_state
*rs
= get_remote_state ();
3669 sprintf (rs
->buf
, "g");
3670 remote_send (&rs
->buf
, &rs
->buf_size
);
3672 /* We can get out of synch in various cases. If the first character
3673 in the buffer is not a hex character, assume that has happened
3674 and try to fetch another packet to read. */
3675 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3676 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3677 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3678 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3681 fprintf_unfiltered (gdb_stdlog
,
3682 "Bad register packet; fetching a new packet\n");
3683 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3686 buf_len
= strlen (rs
->buf
);
3688 /* Sanity check the received packet. */
3689 if (buf_len
% 2 != 0)
3690 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3696 process_g_packet (struct regcache
*regcache
)
3698 struct remote_state
*rs
= get_remote_state ();
3699 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3704 buf_len
= strlen (rs
->buf
);
3706 /* Further sanity checks, with knowledge of the architecture. */
3707 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3708 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3710 /* Save the size of the packet sent to us by the target. It is used
3711 as a heuristic when determining the max size of packets that the
3712 target can safely receive. */
3713 if (rsa
->actual_register_packet_size
== 0)
3714 rsa
->actual_register_packet_size
= buf_len
;
3716 /* If this is smaller than we guessed the 'g' packet would be,
3717 update our records. A 'g' reply that doesn't include a register's
3718 value implies either that the register is not available, or that
3719 the 'p' packet must be used. */
3720 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3722 rsa
->sizeof_g_packet
= buf_len
/ 2;
3724 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3726 if (rsa
->regs
[i
].pnum
== -1)
3729 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3730 rsa
->regs
[i
].in_g_packet
= 0;
3732 rsa
->regs
[i
].in_g_packet
= 1;
3736 regs
= alloca (rsa
->sizeof_g_packet
);
3738 /* Unimplemented registers read as all bits zero. */
3739 memset (regs
, 0, rsa
->sizeof_g_packet
);
3741 /* Reply describes registers byte by byte, each byte encoded as two
3742 hex characters. Suck them all up, then supply them to the
3743 register cacheing/storage mechanism. */
3746 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3748 if (p
[0] == 0 || p
[1] == 0)
3749 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3750 internal_error (__FILE__
, __LINE__
,
3751 "unexpected end of 'g' packet reply");
3753 if (p
[0] == 'x' && p
[1] == 'x')
3754 regs
[i
] = 0; /* 'x' */
3756 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3762 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3764 struct packet_reg
*r
= &rsa
->regs
[i
];
3767 if (r
->offset
* 2 >= strlen (rs
->buf
))
3768 /* This shouldn't happen - we adjusted in_g_packet above. */
3769 internal_error (__FILE__
, __LINE__
,
3770 "unexpected end of 'g' packet reply");
3771 else if (rs
->buf
[r
->offset
* 2] == 'x')
3773 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3774 /* The register isn't available, mark it as such (at
3775 the same time setting the value to zero). */
3776 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3779 regcache_raw_supply (regcache
, r
->regnum
,
3787 fetch_registers_using_g (struct regcache
*regcache
)
3790 process_g_packet (regcache
);
3794 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3796 struct remote_state
*rs
= get_remote_state ();
3797 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3800 set_thread (PIDGET (inferior_ptid
), 1);
3804 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3805 gdb_assert (reg
!= NULL
);
3807 /* If this register might be in the 'g' packet, try that first -
3808 we are likely to read more than one register. If this is the
3809 first 'g' packet, we might be overly optimistic about its
3810 contents, so fall back to 'p'. */
3811 if (reg
->in_g_packet
)
3813 fetch_registers_using_g (regcache
);
3814 if (reg
->in_g_packet
)
3818 if (fetch_register_using_p (regcache
, reg
))
3821 /* This register is not available. */
3822 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3827 fetch_registers_using_g (regcache
);
3829 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3830 if (!rsa
->regs
[i
].in_g_packet
)
3831 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3833 /* This register is not available. */
3834 regcache_raw_supply (regcache
, i
, NULL
);
3838 /* Prepare to store registers. Since we may send them all (using a
3839 'G' request), we have to read out the ones we don't want to change
3843 remote_prepare_to_store (struct regcache
*regcache
)
3845 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3847 gdb_byte buf
[MAX_REGISTER_SIZE
];
3849 /* Make sure the entire registers array is valid. */
3850 switch (remote_protocol_packets
[PACKET_P
].support
)
3852 case PACKET_DISABLE
:
3853 case PACKET_SUPPORT_UNKNOWN
:
3854 /* Make sure all the necessary registers are cached. */
3855 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3856 if (rsa
->regs
[i
].in_g_packet
)
3857 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3864 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3865 packet was not recognized. */
3868 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3870 struct remote_state
*rs
= get_remote_state ();
3871 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3872 /* Try storing a single register. */
3873 char *buf
= rs
->buf
;
3874 gdb_byte regp
[MAX_REGISTER_SIZE
];
3877 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3880 if (reg
->pnum
== -1)
3883 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3884 p
= buf
+ strlen (buf
);
3885 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3886 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3887 remote_send (&rs
->buf
, &rs
->buf_size
);
3889 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3894 error (_("Could not write register \"%s\""),
3895 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3896 case PACKET_UNKNOWN
:
3899 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3903 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3904 contents of the register cache buffer. FIXME: ignores errors. */
3907 store_registers_using_G (const struct regcache
*regcache
)
3909 struct remote_state
*rs
= get_remote_state ();
3910 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3914 /* Extract all the registers in the regcache copying them into a
3918 regs
= alloca (rsa
->sizeof_g_packet
);
3919 memset (regs
, 0, rsa
->sizeof_g_packet
);
3920 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3922 struct packet_reg
*r
= &rsa
->regs
[i
];
3924 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3928 /* Command describes registers byte by byte,
3929 each byte encoded as two hex characters. */
3932 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3934 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3935 remote_send (&rs
->buf
, &rs
->buf_size
);
3938 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3939 of the register cache buffer. FIXME: ignores errors. */
3942 remote_store_registers (struct regcache
*regcache
, int regnum
)
3944 struct remote_state
*rs
= get_remote_state ();
3945 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3948 set_thread (PIDGET (inferior_ptid
), 1);
3952 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3953 gdb_assert (reg
!= NULL
);
3955 /* Always prefer to store registers using the 'P' packet if
3956 possible; we often change only a small number of registers.
3957 Sometimes we change a larger number; we'd need help from a
3958 higher layer to know to use 'G'. */
3959 if (store_register_using_P (regcache
, reg
))
3962 /* For now, don't complain if we have no way to write the
3963 register. GDB loses track of unavailable registers too
3964 easily. Some day, this may be an error. We don't have
3965 any way to read the register, either... */
3966 if (!reg
->in_g_packet
)
3969 store_registers_using_G (regcache
);
3973 store_registers_using_G (regcache
);
3975 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3976 if (!rsa
->regs
[i
].in_g_packet
)
3977 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
3978 /* See above for why we do not issue an error here. */
3983 /* Return the number of hex digits in num. */
3986 hexnumlen (ULONGEST num
)
3990 for (i
= 0; num
!= 0; i
++)
3996 /* Set BUF to the minimum number of hex digits representing NUM. */
3999 hexnumstr (char *buf
, ULONGEST num
)
4001 int len
= hexnumlen (num
);
4002 return hexnumnstr (buf
, num
, len
);
4006 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
4009 hexnumnstr (char *buf
, ULONGEST num
, int width
)
4015 for (i
= width
- 1; i
>= 0; i
--)
4017 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
4024 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
4027 remote_address_masked (CORE_ADDR addr
)
4029 int address_size
= remote_address_size
;
4030 /* If "remoteaddresssize" was not set, default to target address size. */
4032 address_size
= gdbarch_addr_bit (current_gdbarch
);
4034 if (address_size
> 0
4035 && address_size
< (sizeof (ULONGEST
) * 8))
4037 /* Only create a mask when that mask can safely be constructed
4038 in a ULONGEST variable. */
4040 mask
= (mask
<< address_size
) - 1;
4046 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
4047 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
4048 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
4049 (which may be more than *OUT_LEN due to escape characters). The
4050 total number of bytes in the output buffer will be at most
4054 remote_escape_output (const gdb_byte
*buffer
, int len
,
4055 gdb_byte
*out_buf
, int *out_len
,
4058 int input_index
, output_index
;
4061 for (input_index
= 0; input_index
< len
; input_index
++)
4063 gdb_byte b
= buffer
[input_index
];
4065 if (b
== '$' || b
== '#' || b
== '}')
4067 /* These must be escaped. */
4068 if (output_index
+ 2 > out_maxlen
)
4070 out_buf
[output_index
++] = '}';
4071 out_buf
[output_index
++] = b
^ 0x20;
4075 if (output_index
+ 1 > out_maxlen
)
4077 out_buf
[output_index
++] = b
;
4081 *out_len
= input_index
;
4082 return output_index
;
4085 /* Convert BUFFER, escaped data LEN bytes long, into binary data
4086 in OUT_BUF. Return the number of bytes written to OUT_BUF.
4087 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
4089 This function reverses remote_escape_output. It allows more
4090 escaped characters than that function does, in particular because
4091 '*' must be escaped to avoid the run-length encoding processing
4092 in reading packets. */
4095 remote_unescape_input (const gdb_byte
*buffer
, int len
,
4096 gdb_byte
*out_buf
, int out_maxlen
)
4098 int input_index
, output_index
;
4103 for (input_index
= 0; input_index
< len
; input_index
++)
4105 gdb_byte b
= buffer
[input_index
];
4107 if (output_index
+ 1 > out_maxlen
)
4109 warning (_("Received too much data from remote target;"
4110 " ignoring overflow."));
4111 return output_index
;
4116 out_buf
[output_index
++] = b
^ 0x20;
4122 out_buf
[output_index
++] = b
;
4126 error (_("Unmatched escape character in target response."));
4128 return output_index
;
4131 /* Determine whether the remote target supports binary downloading.
4132 This is accomplished by sending a no-op memory write of zero length
4133 to the target at the specified address. It does not suffice to send
4134 the whole packet, since many stubs strip the eighth bit and
4135 subsequently compute a wrong checksum, which causes real havoc with
4138 NOTE: This can still lose if the serial line is not eight-bit
4139 clean. In cases like this, the user should clear "remote
4143 check_binary_download (CORE_ADDR addr
)
4145 struct remote_state
*rs
= get_remote_state ();
4147 switch (remote_protocol_packets
[PACKET_X
].support
)
4149 case PACKET_DISABLE
:
4153 case PACKET_SUPPORT_UNKNOWN
:
4159 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4161 p
+= hexnumstr (p
, (ULONGEST
) 0);
4165 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4166 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4168 if (rs
->buf
[0] == '\0')
4171 fprintf_unfiltered (gdb_stdlog
,
4172 "binary downloading NOT suppported by target\n");
4173 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4178 fprintf_unfiltered (gdb_stdlog
,
4179 "binary downloading suppported by target\n");
4180 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4187 /* Write memory data directly to the remote machine.
4188 This does not inform the data cache; the data cache uses this.
4189 HEADER is the starting part of the packet.
4190 MEMADDR is the address in the remote memory space.
4191 MYADDR is the address of the buffer in our space.
4192 LEN is the number of bytes.
4193 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4194 should send data as binary ('X'), or hex-encoded ('M').
4196 The function creates packet of the form
4197 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4199 where encoding of <DATA> is termined by PACKET_FORMAT.
4201 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4204 Returns the number of bytes transferred, or 0 (setting errno) for
4205 error. Only transfer a single packet. */
4208 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4209 const gdb_byte
*myaddr
, int len
,
4210 char packet_format
, int use_length
)
4212 struct remote_state
*rs
= get_remote_state ();
4222 if (packet_format
!= 'X' && packet_format
!= 'M')
4223 internal_error (__FILE__
, __LINE__
,
4224 "remote_write_bytes_aux: bad packet format");
4229 payload_size
= get_memory_write_packet_size ();
4231 /* The packet buffer will be large enough for the payload;
4232 get_memory_packet_size ensures this. */
4235 /* Compute the size of the actual payload by subtracting out the
4236 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4238 payload_size
-= strlen ("$,:#NN");
4240 /* The comma won't be used. */
4242 header_length
= strlen (header
);
4243 payload_size
-= header_length
;
4244 payload_size
-= hexnumlen (memaddr
);
4246 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4248 strcat (rs
->buf
, header
);
4249 p
= rs
->buf
+ strlen (header
);
4251 /* Compute a best guess of the number of bytes actually transfered. */
4252 if (packet_format
== 'X')
4254 /* Best guess at number of bytes that will fit. */
4255 todo
= min (len
, payload_size
);
4257 payload_size
-= hexnumlen (todo
);
4258 todo
= min (todo
, payload_size
);
4262 /* Num bytes that will fit. */
4263 todo
= min (len
, payload_size
/ 2);
4265 payload_size
-= hexnumlen (todo
);
4266 todo
= min (todo
, payload_size
/ 2);
4270 internal_error (__FILE__
, __LINE__
,
4271 _("minumum packet size too small to write data"));
4273 /* If we already need another packet, then try to align the end
4274 of this packet to a useful boundary. */
4275 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4276 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4278 /* Append "<memaddr>". */
4279 memaddr
= remote_address_masked (memaddr
);
4280 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4287 /* Append <len>. Retain the location/size of <len>. It may need to
4288 be adjusted once the packet body has been created. */
4290 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4298 /* Append the packet body. */
4299 if (packet_format
== 'X')
4301 /* Binary mode. Send target system values byte by byte, in
4302 increasing byte addresses. Only escape certain critical
4304 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4307 /* If not all TODO bytes fit, then we'll need another packet. Make
4308 a second try to keep the end of the packet aligned. Don't do
4309 this if the packet is tiny. */
4310 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4314 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4316 if (new_nr_bytes
!= nr_bytes
)
4317 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4322 p
+= payload_length
;
4323 if (use_length
&& nr_bytes
< todo
)
4325 /* Escape chars have filled up the buffer prematurely,
4326 and we have actually sent fewer bytes than planned.
4327 Fix-up the length field of the packet. Use the same
4328 number of characters as before. */
4329 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4330 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4335 /* Normal mode: Send target system values byte by byte, in
4336 increasing byte addresses. Each byte is encoded as a two hex
4338 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4342 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4343 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4345 if (rs
->buf
[0] == 'E')
4347 /* There is no correspondance between what the remote protocol
4348 uses for errors and errno codes. We would like a cleaner way
4349 of representing errors (big enough to include errno codes,
4350 bfd_error codes, and others). But for now just return EIO. */
4355 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4356 fewer bytes than we'd planned. */
4360 /* Write memory data directly to the remote machine.
4361 This does not inform the data cache; the data cache uses this.
4362 MEMADDR is the address in the remote memory space.
4363 MYADDR is the address of the buffer in our space.
4364 LEN is the number of bytes.
4366 Returns number of bytes transferred, or 0 (setting errno) for
4367 error. Only transfer a single packet. */
4370 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4372 char *packet_format
= 0;
4374 /* Check whether the target supports binary download. */
4375 check_binary_download (memaddr
);
4377 switch (remote_protocol_packets
[PACKET_X
].support
)
4380 packet_format
= "X";
4382 case PACKET_DISABLE
:
4383 packet_format
= "M";
4385 case PACKET_SUPPORT_UNKNOWN
:
4386 internal_error (__FILE__
, __LINE__
,
4387 _("remote_write_bytes: bad internal state"));
4389 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4392 return remote_write_bytes_aux (packet_format
,
4393 memaddr
, myaddr
, len
, packet_format
[0], 1);
4396 /* Read memory data directly from the remote machine.
4397 This does not use the data cache; the data cache uses this.
4398 MEMADDR is the address in the remote memory space.
4399 MYADDR is the address of the buffer in our space.
4400 LEN is the number of bytes.
4402 Returns number of bytes transferred, or 0 for error. */
4404 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4405 remote targets) shouldn't attempt to read the entire buffer.
4406 Instead it should read a single packet worth of data and then
4407 return the byte size of that packet to the caller. The caller (its
4408 caller and its callers caller ;-) already contains code for
4409 handling partial reads. */
4412 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4414 struct remote_state
*rs
= get_remote_state ();
4415 int max_buf_size
; /* Max size of packet output buffer. */
4421 max_buf_size
= get_memory_read_packet_size ();
4422 /* The packet buffer will be large enough for the payload;
4423 get_memory_packet_size ensures this. */
4432 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4434 /* construct "m"<memaddr>","<len>" */
4435 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4436 memaddr
= remote_address_masked (memaddr
);
4439 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4441 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4445 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4447 if (rs
->buf
[0] == 'E'
4448 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4449 && rs
->buf
[3] == '\0')
4451 /* There is no correspondance between what the remote
4452 protocol uses for errors and errno codes. We would like
4453 a cleaner way of representing errors (big enough to
4454 include errno codes, bfd_error codes, and others). But
4455 for now just return EIO. */
4460 /* Reply describes memory byte by byte,
4461 each byte encoded as two hex characters. */
4464 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4466 /* Reply is short. This means that we were able to read
4467 only part of what we wanted to. */
4468 return i
+ (origlen
- len
);
4477 /* Read or write LEN bytes from inferior memory at MEMADDR,
4478 transferring to or from debugger address BUFFER. Write to inferior
4479 if SHOULD_WRITE is nonzero. Returns length of data written or
4480 read; 0 for error. TARGET is unused. */
4483 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4484 int should_write
, struct mem_attrib
*attrib
,
4485 struct target_ops
*target
)
4490 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4492 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4497 /* Sends a packet with content determined by the printf format string
4498 FORMAT and the remaining arguments, then gets the reply. Returns
4499 whether the packet was a success, a failure, or unknown. */
4502 remote_send_printf (const char *format
, ...)
4504 struct remote_state
*rs
= get_remote_state ();
4505 int max_size
= get_remote_packet_size ();
4508 va_start (ap
, format
);
4511 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4512 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4514 if (putpkt (rs
->buf
) < 0)
4515 error (_("Communication problem with target."));
4518 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4520 return packet_check_result (rs
->buf
);
4524 restore_remote_timeout (void *p
)
4526 int value
= *(int *)p
;
4527 remote_timeout
= value
;
4530 /* Flash writing can take quite some time. We'll set
4531 effectively infinite timeout for flash operations.
4532 In future, we'll need to decide on a better approach. */
4533 static const int remote_flash_timeout
= 1000;
4536 remote_flash_erase (struct target_ops
*ops
,
4537 ULONGEST address
, LONGEST length
)
4539 int saved_remote_timeout
= remote_timeout
;
4540 enum packet_result ret
;
4542 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4543 &saved_remote_timeout
);
4544 remote_timeout
= remote_flash_timeout
;
4546 ret
= remote_send_printf ("vFlashErase:%s,%s",
4551 case PACKET_UNKNOWN
:
4552 error (_("Remote target does not support flash erase"));
4554 error (_("Error erasing flash with vFlashErase packet"));
4559 do_cleanups (back_to
);
4563 remote_flash_write (struct target_ops
*ops
,
4564 ULONGEST address
, LONGEST length
,
4565 const gdb_byte
*data
)
4567 int saved_remote_timeout
= remote_timeout
;
4569 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4570 &saved_remote_timeout
);
4572 remote_timeout
= remote_flash_timeout
;
4573 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4574 do_cleanups (back_to
);
4580 remote_flash_done (struct target_ops
*ops
)
4582 int saved_remote_timeout
= remote_timeout
;
4584 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4585 &saved_remote_timeout
);
4587 remote_timeout
= remote_flash_timeout
;
4588 ret
= remote_send_printf ("vFlashDone");
4589 do_cleanups (back_to
);
4593 case PACKET_UNKNOWN
:
4594 error (_("Remote target does not support vFlashDone"));
4596 error (_("Error finishing flash operation"));
4603 remote_files_info (struct target_ops
*ignore
)
4605 puts_filtered ("Debugging a target over a serial line.\n");
4608 /* Stuff for dealing with the packets which are part of this protocol.
4609 See comment at top of file for details. */
4611 /* Read a single character from the remote end. */
4614 readchar (int timeout
)
4618 ch
= serial_readchar (remote_desc
, timeout
);
4623 switch ((enum serial_rc
) ch
)
4626 target_mourn_inferior ();
4627 error (_("Remote connection closed"));
4630 perror_with_name (_("Remote communication error"));
4632 case SERIAL_TIMEOUT
:
4638 /* Send the command in *BUF to the remote machine, and read the reply
4639 into *BUF. Report an error if we get an error reply. Resize
4640 *BUF using xrealloc if necessary to hold the result, and update
4644 remote_send (char **buf
,
4648 getpkt (buf
, sizeof_buf
, 0);
4650 if ((*buf
)[0] == 'E')
4651 error (_("Remote failure reply: %s"), *buf
);
4654 /* Display a null-terminated packet on stdout, for debugging, using C
4658 print_packet (char *buf
)
4660 puts_filtered ("\"");
4661 fputstr_filtered (buf
, '"', gdb_stdout
);
4662 puts_filtered ("\"");
4668 return putpkt_binary (buf
, strlen (buf
));
4671 /* Send a packet to the remote machine, with error checking. The data
4672 of the packet is in BUF. The string in BUF can be at most
4673 get_remote_packet_size () - 5 to account for the $, # and checksum,
4674 and for a possible /0 if we are debugging (remote_debug) and want
4675 to print the sent packet as a string. */
4678 putpkt_binary (char *buf
, int cnt
)
4681 unsigned char csum
= 0;
4682 char *buf2
= alloca (cnt
+ 6);
4688 /* Copy the packet into buffer BUF2, encapsulating it
4689 and giving it a checksum. */
4694 for (i
= 0; i
< cnt
; i
++)
4700 *p
++ = tohex ((csum
>> 4) & 0xf);
4701 *p
++ = tohex (csum
& 0xf);
4703 /* Send it over and over until we get a positive ack. */
4707 int started_error_output
= 0;
4712 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4713 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4714 fprintf_unfiltered (gdb_stdlog
, "...");
4715 gdb_flush (gdb_stdlog
);
4717 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4718 perror_with_name (_("putpkt: write failed"));
4720 /* Read until either a timeout occurs (-2) or '+' is read. */
4723 ch
= readchar (remote_timeout
);
4731 case SERIAL_TIMEOUT
:
4733 if (started_error_output
)
4735 putchar_unfiltered ('\n');
4736 started_error_output
= 0;
4745 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4749 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4750 case SERIAL_TIMEOUT
:
4754 break; /* Retransmit buffer. */
4758 fprintf_unfiltered (gdb_stdlog
,
4759 "Packet instead of Ack, ignoring it\n");
4760 /* It's probably an old response sent because an ACK
4761 was lost. Gobble up the packet and ack it so it
4762 doesn't get retransmitted when we resend this
4765 serial_write (remote_desc
, "+", 1);
4766 continue; /* Now, go look for +. */
4771 if (!started_error_output
)
4773 started_error_output
= 1;
4774 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4776 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4780 break; /* Here to retransmit. */
4784 /* This is wrong. If doing a long backtrace, the user should be
4785 able to get out next time we call QUIT, without anything as
4786 violent as interrupt_query. If we want to provide a way out of
4787 here without getting to the next QUIT, it should be based on
4788 hitting ^C twice as in remote_wait. */
4798 /* Come here after finding the start of a frame when we expected an
4799 ack. Do our best to discard the rest of this packet. */
4808 c
= readchar (remote_timeout
);
4811 case SERIAL_TIMEOUT
:
4812 /* Nothing we can do. */
4815 /* Discard the two bytes of checksum and stop. */
4816 c
= readchar (remote_timeout
);
4818 c
= readchar (remote_timeout
);
4821 case '*': /* Run length encoding. */
4822 /* Discard the repeat count. */
4823 c
= readchar (remote_timeout
);
4828 /* A regular character. */
4834 /* Come here after finding the start of the frame. Collect the rest
4835 into *BUF, verifying the checksum, length, and handling run-length
4836 compression. NUL terminate the buffer. If there is not enough room,
4837 expand *BUF using xrealloc.
4839 Returns -1 on error, number of characters in buffer (ignoring the
4840 trailing NULL) on success. (could be extended to return one of the
4841 SERIAL status indications). */
4844 read_frame (char **buf_p
,
4857 c
= readchar (remote_timeout
);
4860 case SERIAL_TIMEOUT
:
4862 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4866 fputs_filtered ("Saw new packet start in middle of old one\n",
4868 return -1; /* Start a new packet, count retries. */
4871 unsigned char pktcsum
;
4877 check_0
= readchar (remote_timeout
);
4879 check_1
= readchar (remote_timeout
);
4881 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4884 fputs_filtered ("Timeout in checksum, retrying\n",
4888 else if (check_0
< 0 || check_1
< 0)
4891 fputs_filtered ("Communication error in checksum\n",
4896 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4897 if (csum
== pktcsum
)
4902 fprintf_filtered (gdb_stdlog
,
4903 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4905 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4906 fputs_filtered ("\n", gdb_stdlog
);
4908 /* Number of characters in buffer ignoring trailing
4912 case '*': /* Run length encoding. */
4917 c
= readchar (remote_timeout
);
4919 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4921 /* The character before ``*'' is repeated. */
4923 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4925 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4927 /* Make some more room in the buffer. */
4928 *sizeof_buf
+= repeat
;
4929 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4933 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4939 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4943 if (bc
>= *sizeof_buf
- 1)
4945 /* Make some more room in the buffer. */
4947 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4958 /* Read a packet from the remote machine, with error checking, and
4959 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4960 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4961 rather than timing out; this is used (in synchronous mode) to wait
4962 for a target that is is executing user code to stop. */
4963 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4964 don't have to change all the calls to getpkt to deal with the
4965 return value, because at the moment I don't know what the right
4966 thing to do it for those. */
4974 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4978 /* Read a packet from the remote machine, with error checking, and
4979 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4980 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4981 rather than timing out; this is used (in synchronous mode) to wait
4982 for a target that is is executing user code to stop. If FOREVER ==
4983 0, this function is allowed to time out gracefully and return an
4984 indication of this to the caller. Otherwise return the number
4987 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4994 strcpy (*buf
, "timeout");
4998 timeout
= watchdog
> 0 ? watchdog
: -1;
5002 timeout
= remote_timeout
;
5006 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
5008 /* This can loop forever if the remote side sends us characters
5009 continuously, but if it pauses, we'll get a zero from
5010 readchar because of timeout. Then we'll count that as a
5013 /* Note that we will only wait forever prior to the start of a
5014 packet. After that, we expect characters to arrive at a
5015 brisk pace. They should show up within remote_timeout
5020 c
= readchar (timeout
);
5022 if (c
== SERIAL_TIMEOUT
)
5024 if (forever
) /* Watchdog went off? Kill the target. */
5027 target_mourn_inferior ();
5028 error (_("Watchdog has expired. Target detached."));
5031 fputs_filtered ("Timed out.\n", gdb_stdlog
);
5037 /* We've found the start of a packet, now collect the data. */
5039 val
= read_frame (buf
, sizeof_buf
);
5045 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
5046 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
5047 fprintf_unfiltered (gdb_stdlog
, "\n");
5049 serial_write (remote_desc
, "+", 1);
5053 /* Try the whole thing again. */
5055 serial_write (remote_desc
, "-", 1);
5058 /* We have tried hard enough, and just can't receive the packet.
5061 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
5062 serial_write (remote_desc
, "+", 1);
5069 /* For some mysterious reason, wait_for_inferior calls kill instead of
5070 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5074 target_mourn_inferior ();
5078 /* Use catch_errors so the user can quit from gdb even when we aren't on
5079 speaking terms with the remote system. */
5080 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5082 /* Don't wait for it to die. I'm not really sure it matters whether
5083 we do or not. For the existing stubs, kill is a noop. */
5084 target_mourn_inferior ();
5087 /* Async version of remote_kill. */
5089 remote_async_kill (void)
5091 /* Unregister the file descriptor from the event loop. */
5092 if (target_is_async_p ())
5093 serial_async (remote_desc
, NULL
, 0);
5095 /* For some mysterious reason, wait_for_inferior calls kill instead of
5096 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5100 target_mourn_inferior ();
5104 /* Use catch_errors so the user can quit from gdb even when we
5105 aren't on speaking terms with the remote system. */
5106 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5108 /* Don't wait for it to die. I'm not really sure it matters whether
5109 we do or not. For the existing stubs, kill is a noop. */
5110 target_mourn_inferior ();
5116 remote_mourn_1 (&remote_ops
);
5120 remote_async_mourn (void)
5122 remote_mourn_1 (&remote_async_ops
);
5126 extended_remote_mourn (void)
5128 /* We do _not_ want to mourn the target like this; this will
5129 remove the extended remote target from the target stack,
5130 and the next time the user says "run" it'll fail.
5132 FIXME: What is the right thing to do here? */
5134 remote_mourn_1 (&extended_remote_ops
);
5138 /* Worker function for remote_mourn. */
5140 remote_mourn_1 (struct target_ops
*target
)
5142 unpush_target (target
);
5143 generic_mourn_inferior ();
5146 /* In the extended protocol we want to be able to do things like
5147 "run" and have them basically work as expected. So we need
5148 a special create_inferior function.
5150 FIXME: One day add support for changing the exec file
5151 we're debugging, arguments and an environment. */
5154 extended_remote_create_inferior (char *exec_file
, char *args
,
5155 char **env
, int from_tty
)
5157 /* Rip out the breakpoints; we'll reinsert them after restarting
5158 the remote server. */
5159 remove_breakpoints ();
5161 /* Now restart the remote server. */
5162 extended_remote_restart ();
5164 /* NOTE: We don't need to recheck for a target description here; but
5165 if we gain the ability to switch the remote executable we may
5166 need to, if for instance we are running a process which requested
5167 different emulated hardware from the operating system. A
5168 concrete example of this is ARM GNU/Linux, where some binaries
5169 will have a legacy FPA coprocessor emulated and others may have
5170 access to a hardware VFP unit. */
5172 /* Now put the breakpoints back in. This way we're safe if the
5173 restart function works via a unix fork on the remote side. */
5174 insert_breakpoints ();
5176 /* Clean up from the last time we were running. */
5177 clear_proceed_status ();
5180 /* Async version of extended_remote_create_inferior. */
5182 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5183 char **env
, int from_tty
)
5185 /* Rip out the breakpoints; we'll reinsert them after restarting
5186 the remote server. */
5187 remove_breakpoints ();
5189 /* If running asynchronously, register the target file descriptor
5190 with the event loop. */
5191 if (target_can_async_p ())
5192 target_async (inferior_event_handler
, 0);
5194 /* Now restart the remote server. */
5195 extended_remote_restart ();
5197 /* NOTE: We don't need to recheck for a target description here; but
5198 if we gain the ability to switch the remote executable we may
5199 need to, if for instance we are running a process which requested
5200 different emulated hardware from the operating system. A
5201 concrete example of this is ARM GNU/Linux, where some binaries
5202 will have a legacy FPA coprocessor emulated and others may have
5203 access to a hardware VFP unit. */
5205 /* Now put the breakpoints back in. This way we're safe if the
5206 restart function works via a unix fork on the remote side. */
5207 insert_breakpoints ();
5209 /* Clean up from the last time we were running. */
5210 clear_proceed_status ();
5214 /* Insert a breakpoint. On targets that have software breakpoint
5215 support, we ask the remote target to do the work; on targets
5216 which don't, we insert a traditional memory breakpoint. */
5219 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5221 CORE_ADDR addr
= bp_tgt
->placed_address
;
5222 struct remote_state
*rs
= get_remote_state ();
5224 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5225 If it succeeds, then set the support to PACKET_ENABLE. If it
5226 fails, and the user has explicitly requested the Z support then
5227 report an error, otherwise, mark it disabled and go on. */
5229 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5236 gdbarch_breakpoint_from_pc
5237 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5238 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5239 p
+= hexnumstr (p
, addr
);
5240 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5243 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5245 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5251 case PACKET_UNKNOWN
:
5256 return memory_insert_breakpoint (bp_tgt
);
5260 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5262 CORE_ADDR addr
= bp_tgt
->placed_address
;
5263 struct remote_state
*rs
= get_remote_state ();
5266 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5274 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5275 p
+= hexnumstr (p
, addr
);
5276 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5279 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5281 return (rs
->buf
[0] == 'E');
5284 return memory_remove_breakpoint (bp_tgt
);
5288 watchpoint_to_Z_packet (int type
)
5293 return Z_PACKET_WRITE_WP
;
5296 return Z_PACKET_READ_WP
;
5299 return Z_PACKET_ACCESS_WP
;
5302 internal_error (__FILE__
, __LINE__
,
5303 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5308 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5310 struct remote_state
*rs
= get_remote_state ();
5312 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5314 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5317 sprintf (rs
->buf
, "Z%x,", packet
);
5318 p
= strchr (rs
->buf
, '\0');
5319 addr
= remote_address_masked (addr
);
5320 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5321 sprintf (p
, ",%x", len
);
5324 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5326 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5329 case PACKET_UNKNOWN
:
5334 internal_error (__FILE__
, __LINE__
,
5335 _("remote_insert_watchpoint: reached end of function"));
5340 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5342 struct remote_state
*rs
= get_remote_state ();
5344 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5346 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5349 sprintf (rs
->buf
, "z%x,", packet
);
5350 p
= strchr (rs
->buf
, '\0');
5351 addr
= remote_address_masked (addr
);
5352 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5353 sprintf (p
, ",%x", len
);
5355 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5357 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5360 case PACKET_UNKNOWN
:
5365 internal_error (__FILE__
, __LINE__
,
5366 _("remote_remove_watchpoint: reached end of function"));
5370 int remote_hw_watchpoint_limit
= -1;
5371 int remote_hw_breakpoint_limit
= -1;
5374 remote_check_watch_resources (int type
, int cnt
, int ot
)
5376 if (type
== bp_hardware_breakpoint
)
5378 if (remote_hw_breakpoint_limit
== 0)
5380 else if (remote_hw_breakpoint_limit
< 0)
5382 else if (cnt
<= remote_hw_breakpoint_limit
)
5387 if (remote_hw_watchpoint_limit
== 0)
5389 else if (remote_hw_watchpoint_limit
< 0)
5393 else if (cnt
<= remote_hw_watchpoint_limit
)
5400 remote_stopped_by_watchpoint (void)
5402 return remote_stopped_by_watchpoint_p
;
5405 extern int stepped_after_stopped_by_watchpoint
;
5408 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5411 if (remote_stopped_by_watchpoint ()
5412 || stepped_after_stopped_by_watchpoint
)
5414 *addr_p
= remote_watch_data_address
;
5423 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5426 struct remote_state
*rs
= get_remote_state ();
5429 /* The length field should be set to the size of a breakpoint
5430 instruction, even though we aren't inserting one ourselves. */
5432 gdbarch_breakpoint_from_pc
5433 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5435 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5442 addr
= remote_address_masked (bp_tgt
->placed_address
);
5443 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5444 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5447 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5449 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5452 case PACKET_UNKNOWN
:
5457 internal_error (__FILE__
, __LINE__
,
5458 _("remote_insert_hw_breakpoint: reached end of function"));
5463 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5466 struct remote_state
*rs
= get_remote_state ();
5469 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5476 addr
= remote_address_masked (bp_tgt
->placed_address
);
5477 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5478 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5481 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5483 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5486 case PACKET_UNKNOWN
:
5491 internal_error (__FILE__
, __LINE__
,
5492 _("remote_remove_hw_breakpoint: reached end of function"));
5495 /* Some targets are only capable of doing downloads, and afterwards
5496 they switch to the remote serial protocol. This function provides
5497 a clean way to get from the download target to the remote target.
5498 It's basically just a wrapper so that we don't have to expose any
5499 of the internal workings of remote.c.
5501 Prior to calling this routine, you should shutdown the current
5502 target code, else you will get the "A program is being debugged
5503 already..." message. Usually a call to pop_target() suffices. */
5506 push_remote_target (char *name
, int from_tty
)
5508 printf_filtered (_("Switching to remote protocol\n"));
5509 remote_open (name
, from_tty
);
5512 /* Table used by the crc32 function to calcuate the checksum. */
5514 static unsigned long crc32_table
[256] =
5517 static unsigned long
5518 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5520 if (!crc32_table
[1])
5522 /* Initialize the CRC table and the decoding table. */
5526 for (i
= 0; i
< 256; i
++)
5528 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5529 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5536 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5542 /* compare-sections command
5544 With no arguments, compares each loadable section in the exec bfd
5545 with the same memory range on the target, and reports mismatches.
5546 Useful for verifying the image on the target against the exec file.
5547 Depends on the target understanding the new "qCRC:" request. */
5549 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5550 target method (target verify memory) and generic version of the
5551 actual command. This will allow other high-level code (especially
5552 generic_load()) to make use of this target functionality. */
5555 compare_sections_command (char *args
, int from_tty
)
5557 struct remote_state
*rs
= get_remote_state ();
5559 unsigned long host_crc
, target_crc
;
5560 extern bfd
*exec_bfd
;
5561 struct cleanup
*old_chain
;
5564 const char *sectname
;
5571 error (_("command cannot be used without an exec file"));
5572 if (!current_target
.to_shortname
||
5573 strcmp (current_target
.to_shortname
, "remote") != 0)
5574 error (_("command can only be used with remote target"));
5576 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5578 if (!(s
->flags
& SEC_LOAD
))
5579 continue; /* skip non-loadable section */
5581 size
= bfd_get_section_size (s
);
5583 continue; /* skip zero-length section */
5585 sectname
= bfd_get_section_name (exec_bfd
, s
);
5586 if (args
&& strcmp (args
, sectname
) != 0)
5587 continue; /* not the section selected by user */
5589 matched
= 1; /* do this section */
5591 /* FIXME: assumes lma can fit into long. */
5592 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5593 (long) lma
, (long) size
);
5596 /* Be clever; compute the host_crc before waiting for target
5598 sectdata
= xmalloc (size
);
5599 old_chain
= make_cleanup (xfree
, sectdata
);
5600 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5601 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5603 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5604 if (rs
->buf
[0] == 'E')
5605 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5606 sectname
, paddr (lma
), paddr (lma
+ size
));
5607 if (rs
->buf
[0] != 'C')
5608 error (_("remote target does not support this operation"));
5610 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5611 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5613 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5614 sectname
, paddr (lma
), paddr (lma
+ size
));
5615 if (host_crc
== target_crc
)
5616 printf_filtered ("matched.\n");
5619 printf_filtered ("MIS-MATCHED!\n");
5623 do_cleanups (old_chain
);
5626 warning (_("One or more sections of the remote executable does not match\n\
5627 the loaded file\n"));
5628 if (args
&& !matched
)
5629 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5632 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5633 into remote target. The number of bytes written to the remote
5634 target is returned, or -1 for error. */
5637 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
5638 const char *annex
, const gdb_byte
*writebuf
,
5639 ULONGEST offset
, LONGEST len
,
5640 struct packet_config
*packet
)
5645 struct remote_state
*rs
= get_remote_state ();
5646 int max_size
= get_memory_write_packet_size ();
5648 if (packet
->support
== PACKET_DISABLE
)
5651 /* Insert header. */
5652 i
= snprintf (rs
->buf
, max_size
,
5653 "qXfer:%s:write:%s:%s:",
5654 object_name
, annex
? annex
: "",
5655 phex_nz (offset
, sizeof offset
));
5656 max_size
-= (i
+ 1);
5658 /* Escape as much data as fits into rs->buf. */
5659 buf_len
= remote_escape_output
5660 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
5662 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
5663 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
5664 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5667 unpack_varlen_hex (rs
->buf
, &n
);
5671 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5672 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5673 number of bytes read is returned, or 0 for EOF, or -1 for error.
5674 The number of bytes read may be less than LEN without indicating an
5675 EOF. PACKET is checked and updated to indicate whether the remote
5676 target supports this object. */
5679 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5681 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5682 struct packet_config
*packet
)
5684 static char *finished_object
;
5685 static char *finished_annex
;
5686 static ULONGEST finished_offset
;
5688 struct remote_state
*rs
= get_remote_state ();
5689 unsigned int total
= 0;
5690 LONGEST i
, n
, packet_len
;
5692 if (packet
->support
== PACKET_DISABLE
)
5695 /* Check whether we've cached an end-of-object packet that matches
5697 if (finished_object
)
5699 if (strcmp (object_name
, finished_object
) == 0
5700 && strcmp (annex
? annex
: "", finished_annex
) == 0
5701 && offset
== finished_offset
)
5704 /* Otherwise, we're now reading something different. Discard
5706 xfree (finished_object
);
5707 xfree (finished_annex
);
5708 finished_object
= NULL
;
5709 finished_annex
= NULL
;
5712 /* Request only enough to fit in a single packet. The actual data
5713 may not, since we don't know how much of it will need to be escaped;
5714 the target is free to respond with slightly less data. We subtract
5715 five to account for the response type and the protocol frame. */
5716 n
= min (get_remote_packet_size () - 5, len
);
5717 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5718 object_name
, annex
? annex
: "",
5719 phex_nz (offset
, sizeof offset
),
5720 phex_nz (n
, sizeof n
));
5721 i
= putpkt (rs
->buf
);
5726 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5727 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5730 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5731 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5733 /* 'm' means there is (or at least might be) more data after this
5734 batch. That does not make sense unless there's at least one byte
5735 of data in this reply. */
5736 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5737 error (_("Remote qXfer reply contained no data."));
5739 /* Got some data. */
5740 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5742 /* 'l' is an EOF marker, possibly including a final block of data,
5743 or possibly empty. If we have the final block of a non-empty
5744 object, record this fact to bypass a subsequent partial read. */
5745 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
5747 finished_object
= xstrdup (object_name
);
5748 finished_annex
= xstrdup (annex
? annex
: "");
5749 finished_offset
= offset
+ i
;
5756 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5757 const char *annex
, gdb_byte
*readbuf
,
5758 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5760 struct remote_state
*rs
= get_remote_state ();
5765 /* Handle memory using the standard memory routines. */
5766 if (object
== TARGET_OBJECT_MEMORY
)
5771 if (writebuf
!= NULL
)
5772 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5774 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5778 else if (xfered
== 0 && errno
== 0)
5784 /* Handle SPU memory using qxfer packets. */
5785 if (object
== TARGET_OBJECT_SPU
)
5788 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
5789 &remote_protocol_packets
5790 [PACKET_qXfer_spu_read
]);
5792 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
5793 &remote_protocol_packets
5794 [PACKET_qXfer_spu_write
]);
5797 /* Only handle flash writes. */
5798 if (writebuf
!= NULL
)
5804 case TARGET_OBJECT_FLASH
:
5805 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5809 else if (xfered
== 0 && errno
== 0)
5819 /* Map pre-existing objects onto letters. DO NOT do this for new
5820 objects!!! Instead specify new query packets. */
5823 case TARGET_OBJECT_AVR
:
5827 case TARGET_OBJECT_AUXV
:
5828 gdb_assert (annex
== NULL
);
5829 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5830 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5832 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5833 return remote_read_qxfer
5834 (ops
, "features", annex
, readbuf
, offset
, len
,
5835 &remote_protocol_packets
[PACKET_qXfer_features
]);
5837 case TARGET_OBJECT_LIBRARIES
:
5838 return remote_read_qxfer
5839 (ops
, "libraries", annex
, readbuf
, offset
, len
,
5840 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
5842 case TARGET_OBJECT_MEMORY_MAP
:
5843 gdb_assert (annex
== NULL
);
5844 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5845 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5851 /* Note: a zero OFFSET and LEN can be used to query the minimum
5853 if (offset
== 0 && len
== 0)
5854 return (get_remote_packet_size ());
5855 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5856 large enough let the caller deal with it. */
5857 if (len
< get_remote_packet_size ())
5859 len
= get_remote_packet_size ();
5861 /* Except for querying the minimum buffer size, target must be open. */
5863 error (_("remote query is only available after target open"));
5865 gdb_assert (annex
!= NULL
);
5866 gdb_assert (readbuf
!= NULL
);
5872 /* We used one buffer char for the remote protocol q command and
5873 another for the query type. As the remote protocol encapsulation
5874 uses 4 chars plus one extra in case we are debugging
5875 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5878 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5880 /* Bad caller may have sent forbidden characters. */
5881 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5886 gdb_assert (annex
[i
] == '\0');
5888 i
= putpkt (rs
->buf
);
5892 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5893 strcpy ((char *) readbuf
, rs
->buf
);
5895 return strlen ((char *) readbuf
);
5899 remote_rcmd (char *command
,
5900 struct ui_file
*outbuf
)
5902 struct remote_state
*rs
= get_remote_state ();
5906 error (_("remote rcmd is only available after target open"));
5908 /* Send a NULL command across as an empty command. */
5909 if (command
== NULL
)
5912 /* The query prefix. */
5913 strcpy (rs
->buf
, "qRcmd,");
5914 p
= strchr (rs
->buf
, '\0');
5916 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5917 error (_("\"monitor\" command ``%s'' is too long."), command
);
5919 /* Encode the actual command. */
5920 bin2hex ((gdb_byte
*) command
, p
, 0);
5922 if (putpkt (rs
->buf
) < 0)
5923 error (_("Communication problem with target."));
5925 /* get/display the response */
5930 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5932 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5935 error (_("Target does not support this command."));
5936 if (buf
[0] == 'O' && buf
[1] != 'K')
5938 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5941 if (strcmp (buf
, "OK") == 0)
5943 if (strlen (buf
) == 3 && buf
[0] == 'E'
5944 && isdigit (buf
[1]) && isdigit (buf
[2]))
5946 error (_("Protocol error with Rcmd"));
5948 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5950 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5951 fputc_unfiltered (c
, outbuf
);
5957 static VEC(mem_region_s
) *
5958 remote_memory_map (struct target_ops
*ops
)
5960 VEC(mem_region_s
) *result
= NULL
;
5961 char *text
= target_read_stralloc (¤t_target
,
5962 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5966 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5967 result
= parse_memory_map (text
);
5968 do_cleanups (back_to
);
5975 packet_command (char *args
, int from_tty
)
5977 struct remote_state
*rs
= get_remote_state ();
5980 error (_("command can only be used with remote target"));
5983 error (_("remote-packet command requires packet text as argument"));
5985 puts_filtered ("sending: ");
5986 print_packet (args
);
5987 puts_filtered ("\n");
5990 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5991 puts_filtered ("received: ");
5992 print_packet (rs
->buf
);
5993 puts_filtered ("\n");
5997 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5999 static void display_thread_info (struct gdb_ext_thread_info
*info
);
6001 static void threadset_test_cmd (char *cmd
, int tty
);
6003 static void threadalive_test (char *cmd
, int tty
);
6005 static void threadlist_test_cmd (char *cmd
, int tty
);
6007 int get_and_display_threadinfo (threadref
*ref
);
6009 static void threadinfo_test_cmd (char *cmd
, int tty
);
6011 static int thread_display_step (threadref
*ref
, void *context
);
6013 static void threadlist_update_test_cmd (char *cmd
, int tty
);
6015 static void init_remote_threadtests (void);
6017 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
6020 threadset_test_cmd (char *cmd
, int tty
)
6022 int sample_thread
= SAMPLE_THREAD
;
6024 printf_filtered (_("Remote threadset test\n"));
6025 set_thread (sample_thread
, 1);
6030 threadalive_test (char *cmd
, int tty
)
6032 int sample_thread
= SAMPLE_THREAD
;
6034 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
6035 printf_filtered ("PASS: Thread alive test\n");
6037 printf_filtered ("FAIL: Thread alive test\n");
6040 void output_threadid (char *title
, threadref
*ref
);
6043 output_threadid (char *title
, threadref
*ref
)
6047 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
6049 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
6053 threadlist_test_cmd (char *cmd
, int tty
)
6056 threadref nextthread
;
6057 int done
, result_count
;
6058 threadref threadlist
[3];
6060 printf_filtered ("Remote Threadlist test\n");
6061 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
6062 &result_count
, &threadlist
[0]))
6063 printf_filtered ("FAIL: threadlist test\n");
6066 threadref
*scan
= threadlist
;
6067 threadref
*limit
= scan
+ result_count
;
6069 while (scan
< limit
)
6070 output_threadid (" thread ", scan
++);
6075 display_thread_info (struct gdb_ext_thread_info
*info
)
6077 output_threadid ("Threadid: ", &info
->threadid
);
6078 printf_filtered ("Name: %s\n ", info
->shortname
);
6079 printf_filtered ("State: %s\n", info
->display
);
6080 printf_filtered ("other: %s\n\n", info
->more_display
);
6084 get_and_display_threadinfo (threadref
*ref
)
6088 struct gdb_ext_thread_info threadinfo
;
6090 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
6091 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
6092 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
6093 display_thread_info (&threadinfo
);
6098 threadinfo_test_cmd (char *cmd
, int tty
)
6100 int athread
= SAMPLE_THREAD
;
6104 int_to_threadref (&thread
, athread
);
6105 printf_filtered ("Remote Threadinfo test\n");
6106 if (!get_and_display_threadinfo (&thread
))
6107 printf_filtered ("FAIL cannot get thread info\n");
6111 thread_display_step (threadref
*ref
, void *context
)
6113 /* output_threadid(" threadstep ",ref); *//* simple test */
6114 return get_and_display_threadinfo (ref
);
6118 threadlist_update_test_cmd (char *cmd
, int tty
)
6120 printf_filtered ("Remote Threadlist update test\n");
6121 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
6125 init_remote_threadtests (void)
6127 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
6128 Fetch and print the remote list of thread identifiers, one pkt only"));
6129 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
6130 _("Fetch and display info about one thread"));
6131 add_com ("tset", class_obscure
, threadset_test_cmd
,
6132 _("Test setting to a different thread"));
6133 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
6134 _("Iterate through updating all remote thread info"));
6135 add_com ("talive", class_obscure
, threadalive_test
,
6136 _(" Remote thread alive test "));
6141 /* Convert a thread ID to a string. Returns the string in a static
6145 remote_pid_to_str (ptid_t ptid
)
6147 static char buf
[32];
6149 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
6153 /* Get the address of the thread local variable in OBJFILE which is
6154 stored at OFFSET within the thread local storage for thread PTID. */
6157 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
6159 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
6161 struct remote_state
*rs
= get_remote_state ();
6163 enum packet_result result
;
6165 strcpy (p
, "qGetTLSAddr:");
6167 p
+= hexnumstr (p
, PIDGET (ptid
));
6169 p
+= hexnumstr (p
, offset
);
6171 p
+= hexnumstr (p
, lm
);
6175 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6176 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6177 if (result
== PACKET_OK
)
6181 unpack_varlen_hex (rs
->buf
, &result
);
6184 else if (result
== PACKET_UNKNOWN
)
6185 throw_error (TLS_GENERIC_ERROR
,
6186 _("Remote target doesn't support qGetTLSAddr packet"));
6188 throw_error (TLS_GENERIC_ERROR
,
6189 _("Remote target failed to process qGetTLSAddr request"));
6192 throw_error (TLS_GENERIC_ERROR
,
6193 _("TLS not supported or disabled on this target"));
6198 /* Support for inferring a target description based on the current
6199 architecture and the size of a 'g' packet. While the 'g' packet
6200 can have any size (since optional registers can be left off the
6201 end), some sizes are easily recognizable given knowledge of the
6202 approximate architecture. */
6204 struct remote_g_packet_guess
6207 const struct target_desc
*tdesc
;
6209 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6210 DEF_VEC_O(remote_g_packet_guess_s
);
6212 struct remote_g_packet_data
6214 VEC(remote_g_packet_guess_s
) *guesses
;
6217 static struct gdbarch_data
*remote_g_packet_data_handle
;
6220 remote_g_packet_data_init (struct obstack
*obstack
)
6222 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6226 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6227 const struct target_desc
*tdesc
)
6229 struct remote_g_packet_data
*data
6230 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6231 struct remote_g_packet_guess new_guess
, *guess
;
6234 gdb_assert (tdesc
!= NULL
);
6237 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6239 if (guess
->bytes
== bytes
)
6240 internal_error (__FILE__
, __LINE__
,
6241 "Duplicate g packet description added for size %d",
6244 new_guess
.bytes
= bytes
;
6245 new_guess
.tdesc
= tdesc
;
6246 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6249 static const struct target_desc
*
6250 remote_read_description (struct target_ops
*target
)
6252 struct remote_g_packet_data
*data
6253 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6255 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6257 struct remote_g_packet_guess
*guess
;
6259 int bytes
= send_g_packet ();
6262 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6264 if (guess
->bytes
== bytes
)
6265 return guess
->tdesc
;
6267 /* We discard the g packet. A minor optimization would be to
6268 hold on to it, and fill the register cache once we have selected
6269 an architecture, but it's too tricky to do safely. */
6276 init_remote_ops (void)
6278 remote_ops
.to_shortname
= "remote";
6279 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6281 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6282 Specify the serial device it is connected to\n\
6283 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6284 remote_ops
.to_open
= remote_open
;
6285 remote_ops
.to_close
= remote_close
;
6286 remote_ops
.to_detach
= remote_detach
;
6287 remote_ops
.to_disconnect
= remote_disconnect
;
6288 remote_ops
.to_resume
= remote_resume
;
6289 remote_ops
.to_wait
= remote_wait
;
6290 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6291 remote_ops
.to_store_registers
= remote_store_registers
;
6292 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6293 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6294 remote_ops
.to_files_info
= remote_files_info
;
6295 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6296 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6297 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6298 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6299 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6300 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6301 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6302 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6303 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6304 remote_ops
.to_kill
= remote_kill
;
6305 remote_ops
.to_load
= generic_load
;
6306 remote_ops
.to_mourn_inferior
= remote_mourn
;
6307 remote_ops
.to_thread_alive
= remote_thread_alive
;
6308 remote_ops
.to_find_new_threads
= remote_threads_info
;
6309 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6310 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6311 remote_ops
.to_stop
= remote_stop
;
6312 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6313 remote_ops
.to_rcmd
= remote_rcmd
;
6314 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6315 remote_ops
.to_stratum
= process_stratum
;
6316 remote_ops
.to_has_all_memory
= 1;
6317 remote_ops
.to_has_memory
= 1;
6318 remote_ops
.to_has_stack
= 1;
6319 remote_ops
.to_has_registers
= 1;
6320 remote_ops
.to_has_execution
= 1;
6321 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6322 remote_ops
.to_magic
= OPS_MAGIC
;
6323 remote_ops
.to_memory_map
= remote_memory_map
;
6324 remote_ops
.to_flash_erase
= remote_flash_erase
;
6325 remote_ops
.to_flash_done
= remote_flash_done
;
6326 remote_ops
.to_read_description
= remote_read_description
;
6329 /* Set up the extended remote vector by making a copy of the standard
6330 remote vector and adding to it. */
6333 init_extended_remote_ops (void)
6335 extended_remote_ops
= remote_ops
;
6337 extended_remote_ops
.to_shortname
= "extended-remote";
6338 extended_remote_ops
.to_longname
=
6339 "Extended remote serial target in gdb-specific protocol";
6340 extended_remote_ops
.to_doc
=
6341 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6342 Specify the serial device it is connected to (e.g. /dev/ttya).",
6343 extended_remote_ops
.to_open
= extended_remote_open
;
6344 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6345 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6349 remote_can_async_p (void)
6351 /* We're async whenever the serial device is. */
6352 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6356 remote_is_async_p (void)
6358 /* We're async whenever the serial device is. */
6359 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6362 /* Pass the SERIAL event on and up to the client. One day this code
6363 will be able to delay notifying the client of an event until the
6364 point where an entire packet has been received. */
6366 static void (*async_client_callback
) (enum inferior_event_type event_type
,
6368 static void *async_client_context
;
6369 static serial_event_ftype remote_async_serial_handler
;
6372 remote_async_serial_handler (struct serial
*scb
, void *context
)
6374 /* Don't propogate error information up to the client. Instead let
6375 the client find out about the error by querying the target. */
6376 async_client_callback (INF_REG_EVENT
, async_client_context
);
6380 remote_async (void (*callback
) (enum inferior_event_type event_type
,
6381 void *context
), void *context
)
6383 if (current_target
.to_async_mask_value
== 0)
6384 internal_error (__FILE__
, __LINE__
,
6385 _("Calling remote_async when async is masked"));
6387 if (callback
!= NULL
)
6389 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
6390 async_client_callback
= callback
;
6391 async_client_context
= context
;
6394 serial_async (remote_desc
, NULL
, NULL
);
6397 /* Target async and target extended-async.
6399 This are temporary targets, until it is all tested. Eventually
6400 async support will be incorporated int the usual 'remote'
6404 init_remote_async_ops (void)
6406 remote_async_ops
.to_shortname
= "async";
6407 remote_async_ops
.to_longname
=
6408 "Remote serial target in async version of the gdb-specific protocol";
6409 remote_async_ops
.to_doc
=
6410 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6411 Specify the serial device it is connected to (e.g. /dev/ttya).";
6412 remote_async_ops
.to_open
= remote_async_open
;
6413 remote_async_ops
.to_close
= remote_close
;
6414 remote_async_ops
.to_detach
= remote_detach
;
6415 remote_async_ops
.to_disconnect
= remote_disconnect
;
6416 remote_async_ops
.to_resume
= remote_async_resume
;
6417 remote_async_ops
.to_wait
= remote_async_wait
;
6418 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
6419 remote_async_ops
.to_store_registers
= remote_store_registers
;
6420 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6421 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6422 remote_async_ops
.to_files_info
= remote_files_info
;
6423 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6424 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6425 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6426 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6427 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6428 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6429 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6430 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6431 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6432 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
6433 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
6434 remote_async_ops
.to_kill
= remote_async_kill
;
6435 remote_async_ops
.to_load
= generic_load
;
6436 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
6437 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
6438 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
6439 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
6440 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6441 remote_async_ops
.to_stop
= remote_stop
;
6442 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
6443 remote_async_ops
.to_rcmd
= remote_rcmd
;
6444 remote_async_ops
.to_stratum
= process_stratum
;
6445 remote_async_ops
.to_has_all_memory
= 1;
6446 remote_async_ops
.to_has_memory
= 1;
6447 remote_async_ops
.to_has_stack
= 1;
6448 remote_async_ops
.to_has_registers
= 1;
6449 remote_async_ops
.to_has_execution
= 1;
6450 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6451 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
6452 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
6453 remote_async_ops
.to_async
= remote_async
;
6454 remote_async_ops
.to_async_mask_value
= 1;
6455 remote_async_ops
.to_magic
= OPS_MAGIC
;
6456 remote_async_ops
.to_memory_map
= remote_memory_map
;
6457 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
6458 remote_async_ops
.to_flash_done
= remote_flash_done
;
6459 remote_async_ops
.to_read_description
= remote_read_description
;
6462 /* Set up the async extended remote vector by making a copy of the standard
6463 remote vector and adding to it. */
6466 init_extended_async_remote_ops (void)
6468 extended_async_remote_ops
= remote_async_ops
;
6470 extended_async_remote_ops
.to_shortname
= "extended-async";
6471 extended_async_remote_ops
.to_longname
=
6472 "Extended remote serial target in async gdb-specific protocol";
6473 extended_async_remote_ops
.to_doc
=
6474 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6475 Specify the serial device it is connected to (e.g. /dev/ttya).",
6476 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
6477 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
6478 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6482 set_remote_cmd (char *args
, int from_tty
)
6484 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
6488 show_remote_cmd (char *args
, int from_tty
)
6490 /* We can't just use cmd_show_list here, because we want to skip
6491 the redundant "show remote Z-packet" and the legacy aliases. */
6492 struct cleanup
*showlist_chain
;
6493 struct cmd_list_element
*list
= remote_show_cmdlist
;
6495 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
6496 for (; list
!= NULL
; list
= list
->next
)
6497 if (strcmp (list
->name
, "Z-packet") == 0)
6499 else if (list
->type
== not_set_cmd
)
6500 /* Alias commands are exactly like the original, except they
6501 don't have the normal type. */
6505 struct cleanup
*option_chain
6506 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
6507 ui_out_field_string (uiout
, "name", list
->name
);
6508 ui_out_text (uiout
, ": ");
6509 if (list
->type
== show_cmd
)
6510 do_setshow_command ((char *) NULL
, from_tty
, list
);
6512 cmd_func (list
, NULL
, from_tty
);
6513 /* Close the tuple. */
6514 do_cleanups (option_chain
);
6517 /* Close the tuple. */
6518 do_cleanups (showlist_chain
);
6522 /* Function to be called whenever a new objfile (shlib) is detected. */
6524 remote_new_objfile (struct objfile
*objfile
)
6526 if (remote_desc
!= 0) /* Have a remote connection. */
6527 remote_check_symbols (objfile
);
6531 _initialize_remote (void)
6533 struct remote_state
*rs
;
6535 /* architecture specific data */
6536 remote_gdbarch_data_handle
=
6537 gdbarch_data_register_post_init (init_remote_state
);
6538 remote_g_packet_data_handle
=
6539 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
6541 /* Initialize the per-target state. At the moment there is only one
6542 of these, not one per target. Only one target is active at a
6543 time. The default buffer size is unimportant; it will be expanded
6544 whenever a larger buffer is needed. */
6545 rs
= get_remote_state_raw ();
6547 rs
->buf
= xmalloc (rs
->buf_size
);
6550 add_target (&remote_ops
);
6552 init_extended_remote_ops ();
6553 add_target (&extended_remote_ops
);
6555 init_remote_async_ops ();
6556 add_target (&remote_async_ops
);
6558 init_extended_async_remote_ops ();
6559 add_target (&extended_async_remote_ops
);
6561 /* Hook into new objfile notification. */
6562 observer_attach_new_objfile (remote_new_objfile
);
6565 init_remote_threadtests ();
6568 /* set/show remote ... */
6570 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
6571 Remote protocol specific variables\n\
6572 Configure various remote-protocol specific variables such as\n\
6573 the packets being used"),
6574 &remote_set_cmdlist
, "set remote ",
6575 0 /* allow-unknown */, &setlist
);
6576 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
6577 Remote protocol specific variables\n\
6578 Configure various remote-protocol specific variables such as\n\
6579 the packets being used"),
6580 &remote_show_cmdlist
, "show remote ",
6581 0 /* allow-unknown */, &showlist
);
6583 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
6584 Compare section data on target to the exec file.\n\
6585 Argument is a single section name (default: all loaded sections)."),
6588 add_cmd ("packet", class_maintenance
, packet_command
, _("\
6589 Send an arbitrary packet to a remote target.\n\
6590 maintenance packet TEXT\n\
6591 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6592 this command sends the string TEXT to the inferior, and displays the\n\
6593 response packet. GDB supplies the initial `$' character, and the\n\
6594 terminating `#' character and checksum."),
6597 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
6598 Set whether to send break if interrupted."), _("\
6599 Show whether to send break if interrupted."), _("\
6600 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6601 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6602 &setlist
, &showlist
);
6604 /* Install commands for configuring memory read/write packets. */
6606 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
6607 Set the maximum number of bytes per memory write packet (deprecated)."),
6609 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
6610 Show the maximum number of bytes per memory write packet (deprecated)."),
6612 add_cmd ("memory-write-packet-size", no_class
,
6613 set_memory_write_packet_size
, _("\
6614 Set the maximum number of bytes per memory-write packet.\n\
6615 Specify the number of bytes in a packet or 0 (zero) for the\n\
6616 default packet size. The actual limit is further reduced\n\
6617 dependent on the target. Specify ``fixed'' to disable the\n\
6618 further restriction and ``limit'' to enable that restriction."),
6619 &remote_set_cmdlist
);
6620 add_cmd ("memory-read-packet-size", no_class
,
6621 set_memory_read_packet_size
, _("\
6622 Set the maximum number of bytes per memory-read packet.\n\
6623 Specify the number of bytes in a packet or 0 (zero) for the\n\
6624 default packet size. The actual limit is further reduced\n\
6625 dependent on the target. Specify ``fixed'' to disable the\n\
6626 further restriction and ``limit'' to enable that restriction."),
6627 &remote_set_cmdlist
);
6628 add_cmd ("memory-write-packet-size", no_class
,
6629 show_memory_write_packet_size
,
6630 _("Show the maximum number of bytes per memory-write packet."),
6631 &remote_show_cmdlist
);
6632 add_cmd ("memory-read-packet-size", no_class
,
6633 show_memory_read_packet_size
,
6634 _("Show the maximum number of bytes per memory-read packet."),
6635 &remote_show_cmdlist
);
6637 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6638 &remote_hw_watchpoint_limit
, _("\
6639 Set the maximum number of target hardware watchpoints."), _("\
6640 Show the maximum number of target hardware watchpoints."), _("\
6641 Specify a negative limit for unlimited."),
6642 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6643 &remote_set_cmdlist
, &remote_show_cmdlist
);
6644 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6645 &remote_hw_breakpoint_limit
, _("\
6646 Set the maximum number of target hardware breakpoints."), _("\
6647 Show the maximum number of target hardware breakpoints."), _("\
6648 Specify a negative limit for unlimited."),
6649 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6650 &remote_set_cmdlist
, &remote_show_cmdlist
);
6652 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6653 &remote_address_size
, _("\
6654 Set the maximum size of the address (in bits) in a memory packet."), _("\
6655 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6657 NULL
, /* FIXME: i18n: */
6658 &setlist
, &showlist
);
6660 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6661 "X", "binary-download", 1);
6663 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6664 "vCont", "verbose-resume", 0);
6666 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
6667 "QPassSignals", "pass-signals", 0);
6669 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6670 "qSymbol", "symbol-lookup", 0);
6672 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6673 "P", "set-register", 1);
6675 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6676 "p", "fetch-register", 1);
6678 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6679 "Z0", "software-breakpoint", 0);
6681 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6682 "Z1", "hardware-breakpoint", 0);
6684 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6685 "Z2", "write-watchpoint", 0);
6687 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6688 "Z3", "read-watchpoint", 0);
6690 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6691 "Z4", "access-watchpoint", 0);
6693 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6694 "qXfer:auxv:read", "read-aux-vector", 0);
6696 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
6697 "qXfer:features:read", "target-features", 0);
6699 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
6700 "qXfer:libraries:read", "library-info", 0);
6702 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
6703 "qXfer:memory-map:read", "memory-map", 0);
6705 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
6706 "qXfer:spu:read", "read-spu-object", 0);
6708 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
6709 "qXfer:spu:write", "write-spu-object", 0);
6711 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6712 "qGetTLSAddr", "get-thread-local-storage-address",
6715 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6716 "qSupported", "supported-packets", 0);
6718 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6719 Z sub-packet has its own set and show commands, but users may
6720 have sets to this variable in their .gdbinit files (or in their
6722 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6723 &remote_Z_packet_detect
, _("\
6724 Set use of remote protocol `Z' packets"), _("\
6725 Show use of remote protocol `Z' packets "), _("\
6726 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6728 set_remote_protocol_Z_packet_cmd
,
6729 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6730 &remote_set_cmdlist
, &remote_show_cmdlist
);
6732 /* Eventually initialize fileio. See fileio.c */
6733 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);