1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* See the GDB User Guide for details of the GDB remote protocol. */
25 #include "gdb_string.h"
31 #include "exceptions.h"
33 /*#include "terminal.h" */
36 #include "gdb-stabs.h"
37 #include "gdbthread.h"
41 #include "gdb_assert.h"
44 #include "cli/cli-decode.h"
45 #include "cli/cli-setshow.h"
46 #include "target-descriptions.h"
51 #include "event-loop.h"
52 #include "event-top.h"
58 #include "gdbcore.h" /* for exec_bfd */
60 #include "remote-fileio.h"
61 #include "gdb/fileio.h"
63 #include "memory-map.h"
65 /* The size to align memory write packets, when practical. The protocol
66 does not guarantee any alignment, and gdb will generate short
67 writes and unaligned writes, but even as a best-effort attempt this
68 can improve bulk transfers. For instance, if a write is misaligned
69 relative to the target's data bus, the stub may need to make an extra
70 round trip fetching data from the target. This doesn't make a
71 huge difference, but it's easy to do, so we try to be helpful.
73 The alignment chosen is arbitrary; usually data bus width is
74 important here, not the possibly larger cache line size. */
75 enum { REMOTE_ALIGN_WRITES
= 16 };
77 /* Prototypes for local functions. */
78 static void cleanup_sigint_signal_handler (void *dummy
);
79 static void initialize_sigint_signal_handler (void);
80 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
82 static void handle_remote_sigint (int);
83 static void handle_remote_sigint_twice (int);
84 static void async_remote_interrupt (gdb_client_data
);
85 void async_remote_interrupt_twice (gdb_client_data
);
87 static void remote_files_info (struct target_ops
*ignore
);
89 static void remote_prepare_to_store (struct regcache
*regcache
);
91 static void remote_fetch_registers (struct regcache
*regcache
, int regno
);
93 static void remote_resume (ptid_t ptid
, int step
,
94 enum target_signal siggnal
);
95 static void remote_async_resume (ptid_t ptid
, int step
,
96 enum target_signal siggnal
);
97 static void remote_open (char *name
, int from_tty
);
98 static void remote_async_open (char *name
, int from_tty
);
100 static void extended_remote_open (char *name
, int from_tty
);
101 static void extended_remote_async_open (char *name
, int from_tty
);
103 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
,
106 static void remote_close (int quitting
);
108 static void remote_store_registers (struct regcache
*regcache
, int regno
);
110 static void remote_mourn (void);
111 static void remote_async_mourn (void);
113 static void extended_remote_restart (void);
115 static void extended_remote_mourn (void);
117 static void remote_mourn_1 (struct target_ops
*);
119 static void remote_send (char **buf
, long *sizeof_buf_p
);
121 static int readchar (int timeout
);
123 static ptid_t
remote_wait (ptid_t ptid
,
124 struct target_waitstatus
*status
);
125 static ptid_t
remote_async_wait (ptid_t ptid
,
126 struct target_waitstatus
*status
);
128 static void remote_kill (void);
129 static void remote_async_kill (void);
131 static int tohex (int nib
);
133 static void remote_detach (char *args
, int from_tty
);
135 static void remote_interrupt (int signo
);
137 static void remote_interrupt_twice (int signo
);
139 static void interrupt_query (void);
141 static void set_thread (int, int);
143 static int remote_thread_alive (ptid_t
);
145 static void get_offsets (void);
147 static void skip_frame (void);
149 static long read_frame (char **buf_p
, long *sizeof_buf
);
151 static int hexnumlen (ULONGEST num
);
153 static void init_remote_ops (void);
155 static void init_extended_remote_ops (void);
157 static void remote_stop (void);
159 static int ishex (int ch
, int *val
);
161 static int stubhex (int ch
);
163 static int hexnumstr (char *, ULONGEST
);
165 static int hexnumnstr (char *, ULONGEST
, int);
167 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
169 static void print_packet (char *);
171 static unsigned long crc32 (unsigned char *, int, unsigned int);
173 static void compare_sections_command (char *, int);
175 static void packet_command (char *, int);
177 static int stub_unpack_int (char *buff
, int fieldlength
);
179 static ptid_t
remote_current_thread (ptid_t oldptid
);
181 static void remote_find_new_threads (void);
183 static void record_currthread (int currthread
);
185 static int fromhex (int a
);
187 static int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
189 static int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
191 static int putpkt_binary (char *buf
, int cnt
);
193 static void check_binary_download (CORE_ADDR addr
);
195 struct packet_config
;
197 static void show_packet_config_cmd (struct packet_config
*config
);
199 static void update_packet_config (struct packet_config
*config
);
201 static void set_remote_protocol_packet_cmd (char *args
, int from_tty
,
202 struct cmd_list_element
*c
);
204 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
206 struct cmd_list_element
*c
,
209 void _initialize_remote (void);
213 static struct cmd_list_element
*remote_cmdlist
;
215 /* For "set remote" and "show remote". */
217 static struct cmd_list_element
*remote_set_cmdlist
;
218 static struct cmd_list_element
*remote_show_cmdlist
;
220 /* Description of the remote protocol state for the currently
221 connected target. This is per-target state, and independent of the
222 selected architecture. */
226 /* A buffer to use for incoming packets, and its current size. The
227 buffer is grown dynamically for larger incoming packets.
228 Outgoing packets may also be constructed in this buffer.
229 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
230 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
235 /* If we negotiated packet size explicitly (and thus can bypass
236 heuristics for the largest packet size that will not overflow
237 a buffer in the stub), this will be set to that packet size.
238 Otherwise zero, meaning to use the guessed size. */
239 long explicit_packet_size
;
241 /* remote_wait is normally called when the target is running and
242 waits for a stop reply packet. But sometimes we need to call it
243 when the target is already stopped. We can send a "?" packet
244 and have remote_wait read the response. Or, if we already have
245 the response, we can stash it in BUF and tell remote_wait to
246 skip calling getpkt. This flag is set when BUF contains a
247 stop reply packet and the target is not waiting. */
248 int cached_wait_status
;
251 /* This data could be associated with a target, but we do not always
252 have access to the current target when we need it, so for now it is
253 static. This will be fine for as long as only one target is in use
255 static struct remote_state remote_state
;
257 static struct remote_state
*
258 get_remote_state_raw (void)
260 return &remote_state
;
263 /* Description of the remote protocol for a given architecture. */
267 long offset
; /* Offset into G packet. */
268 long regnum
; /* GDB's internal register number. */
269 LONGEST pnum
; /* Remote protocol register number. */
270 int in_g_packet
; /* Always part of G packet. */
271 /* long size in bytes; == register_size (current_gdbarch, regnum);
273 /* char *name; == gdbarch_register_name (current_gdbarch, regnum);
277 struct remote_arch_state
279 /* Description of the remote protocol registers. */
280 long sizeof_g_packet
;
282 /* Description of the remote protocol registers indexed by REGNUM
283 (making an array gdbarch_num_regs in size). */
284 struct packet_reg
*regs
;
286 /* This is the size (in chars) of the first response to the ``g''
287 packet. It is used as a heuristic when determining the maximum
288 size of memory-read and memory-write packets. A target will
289 typically only reserve a buffer large enough to hold the ``g''
290 packet. The size does not include packet overhead (headers and
292 long actual_register_packet_size
;
294 /* This is the maximum size (in chars) of a non read/write packet.
295 It is also used as a cap on the size of read/write packets. */
296 long remote_packet_size
;
300 /* Handle for retreving the remote protocol data from gdbarch. */
301 static struct gdbarch_data
*remote_gdbarch_data_handle
;
303 static struct remote_arch_state
*
304 get_remote_arch_state (void)
306 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
309 /* Fetch the global remote target state. */
311 static struct remote_state
*
312 get_remote_state (void)
314 /* Make sure that the remote architecture state has been
315 initialized, because doing so might reallocate rs->buf. Any
316 function which calls getpkt also needs to be mindful of changes
317 to rs->buf, but this call limits the number of places which run
319 get_remote_arch_state ();
321 return get_remote_state_raw ();
325 compare_pnums (const void *lhs_
, const void *rhs_
)
327 const struct packet_reg
* const *lhs
= lhs_
;
328 const struct packet_reg
* const *rhs
= rhs_
;
330 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
332 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
339 init_remote_state (struct gdbarch
*gdbarch
)
341 int regnum
, num_remote_regs
, offset
;
342 struct remote_state
*rs
= get_remote_state_raw ();
343 struct remote_arch_state
*rsa
;
344 struct packet_reg
**remote_regs
;
346 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
348 /* Use the architecture to build a regnum<->pnum table, which will be
349 1:1 unless a feature set specifies otherwise. */
350 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
351 gdbarch_num_regs (gdbarch
),
353 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
355 struct packet_reg
*r
= &rsa
->regs
[regnum
];
357 if (register_size (gdbarch
, regnum
) == 0)
358 /* Do not try to fetch zero-sized (placeholder) registers. */
361 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
366 /* Define the g/G packet format as the contents of each register
367 with a remote protocol number, in order of ascending protocol
370 remote_regs
= alloca (gdbarch_num_regs (gdbarch
)
371 * sizeof (struct packet_reg
*));
372 for (num_remote_regs
= 0, regnum
= 0;
373 regnum
< gdbarch_num_regs (gdbarch
);
375 if (rsa
->regs
[regnum
].pnum
!= -1)
376 remote_regs
[num_remote_regs
++] = &rsa
->regs
[regnum
];
378 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
381 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
383 remote_regs
[regnum
]->in_g_packet
= 1;
384 remote_regs
[regnum
]->offset
= offset
;
385 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
388 /* Record the maximum possible size of the g packet - it may turn out
390 rsa
->sizeof_g_packet
= offset
;
392 /* Default maximum number of characters in a packet body. Many
393 remote stubs have a hardwired buffer size of 400 bytes
394 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
395 as the maximum packet-size to ensure that the packet and an extra
396 NUL character can always fit in the buffer. This stops GDB
397 trashing stubs that try to squeeze an extra NUL into what is
398 already a full buffer (As of 1999-12-04 that was most stubs). */
399 rsa
->remote_packet_size
= 400 - 1;
401 /* This one is filled in when a ``g'' packet is received. */
402 rsa
->actual_register_packet_size
= 0;
404 /* Should rsa->sizeof_g_packet needs more space than the
405 default, adjust the size accordingly. Remember that each byte is
406 encoded as two characters. 32 is the overhead for the packet
407 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
408 (``$NN:G...#NN'') is a better guess, the below has been padded a
410 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
411 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
413 /* Make sure that the packet buffer is plenty big enough for
414 this architecture. */
415 if (rs
->buf_size
< rsa
->remote_packet_size
)
417 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
418 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
424 /* Return the current allowed size of a remote packet. This is
425 inferred from the current architecture, and should be used to
426 limit the length of outgoing packets. */
428 get_remote_packet_size (void)
430 struct remote_state
*rs
= get_remote_state ();
431 struct remote_arch_state
*rsa
= get_remote_arch_state ();
433 if (rs
->explicit_packet_size
)
434 return rs
->explicit_packet_size
;
436 return rsa
->remote_packet_size
;
439 static struct packet_reg
*
440 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
442 if (regnum
< 0 && regnum
>= gdbarch_num_regs (current_gdbarch
))
446 struct packet_reg
*r
= &rsa
->regs
[regnum
];
447 gdb_assert (r
->regnum
== regnum
);
452 static struct packet_reg
*
453 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
456 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
458 struct packet_reg
*r
= &rsa
->regs
[i
];
465 /* FIXME: graces/2002-08-08: These variables should eventually be
466 bound to an instance of the target object (as in gdbarch-tdep()),
467 when such a thing exists. */
469 /* This is set to the data address of the access causing the target
470 to stop for a watchpoint. */
471 static CORE_ADDR remote_watch_data_address
;
473 /* This is non-zero if target stopped for a watchpoint. */
474 static int remote_stopped_by_watchpoint_p
;
476 static struct target_ops remote_ops
;
478 static struct target_ops extended_remote_ops
;
480 /* Temporary target ops. Just like the remote_ops and
481 extended_remote_ops, but with asynchronous support. */
482 static struct target_ops remote_async_ops
;
484 static struct target_ops extended_async_remote_ops
;
486 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
487 ``forever'' still use the normal timeout mechanism. This is
488 currently used by the ASYNC code to guarentee that target reads
489 during the initial connect always time-out. Once getpkt has been
490 modified to return a timeout indication and, in turn
491 remote_wait()/wait_for_inferior() have gained a timeout parameter
493 static int wait_forever_enabled_p
= 1;
496 /* This variable chooses whether to send a ^C or a break when the user
497 requests program interruption. Although ^C is usually what remote
498 systems expect, and that is the default here, sometimes a break is
499 preferable instead. */
501 static int remote_break
;
503 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
504 remote_open knows that we don't have a file open when the program
506 static struct serial
*remote_desc
= NULL
;
508 /* This variable sets the number of bits in an address that are to be
509 sent in a memory ("M" or "m") packet. Normally, after stripping
510 leading zeros, the entire address would be sent. This variable
511 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
512 initial implementation of remote.c restricted the address sent in
513 memory packets to ``host::sizeof long'' bytes - (typically 32
514 bits). Consequently, for 64 bit targets, the upper 32 bits of an
515 address was never sent. Since fixing this bug may cause a break in
516 some remote targets this variable is principly provided to
517 facilitate backward compatibility. */
519 static int remote_address_size
;
521 /* Tempoary to track who currently owns the terminal. See
522 target_async_terminal_* for more details. */
524 static int remote_async_terminal_ours_p
;
526 /* The executable file to use for "run" on the remote side. */
528 static char *remote_exec_file
= "";
531 /* User configurable variables for the number of characters in a
532 memory read/write packet. MIN (rsa->remote_packet_size,
533 rsa->sizeof_g_packet) is the default. Some targets need smaller
534 values (fifo overruns, et.al.) and some users need larger values
535 (speed up transfers). The variables ``preferred_*'' (the user
536 request), ``current_*'' (what was actually set) and ``forced_*''
537 (Positive - a soft limit, negative - a hard limit). */
539 struct memory_packet_config
546 /* Compute the current size of a read/write packet. Since this makes
547 use of ``actual_register_packet_size'' the computation is dynamic. */
550 get_memory_packet_size (struct memory_packet_config
*config
)
552 struct remote_state
*rs
= get_remote_state ();
553 struct remote_arch_state
*rsa
= get_remote_arch_state ();
555 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
556 law?) that some hosts don't cope very well with large alloca()
557 calls. Eventually the alloca() code will be replaced by calls to
558 xmalloc() and make_cleanups() allowing this restriction to either
559 be lifted or removed. */
560 #ifndef MAX_REMOTE_PACKET_SIZE
561 #define MAX_REMOTE_PACKET_SIZE 16384
563 /* NOTE: 20 ensures we can write at least one byte. */
564 #ifndef MIN_REMOTE_PACKET_SIZE
565 #define MIN_REMOTE_PACKET_SIZE 20
570 if (config
->size
<= 0)
571 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
573 what_they_get
= config
->size
;
577 what_they_get
= get_remote_packet_size ();
578 /* Limit the packet to the size specified by the user. */
580 && what_they_get
> config
->size
)
581 what_they_get
= config
->size
;
583 /* Limit it to the size of the targets ``g'' response unless we have
584 permission from the stub to use a larger packet size. */
585 if (rs
->explicit_packet_size
== 0
586 && rsa
->actual_register_packet_size
> 0
587 && what_they_get
> rsa
->actual_register_packet_size
)
588 what_they_get
= rsa
->actual_register_packet_size
;
590 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
591 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
592 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
593 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
595 /* Make sure there is room in the global buffer for this packet
596 (including its trailing NUL byte). */
597 if (rs
->buf_size
< what_they_get
+ 1)
599 rs
->buf_size
= 2 * what_they_get
;
600 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
603 return what_they_get
;
606 /* Update the size of a read/write packet. If they user wants
607 something really big then do a sanity check. */
610 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
612 int fixed_p
= config
->fixed_p
;
613 long size
= config
->size
;
615 error (_("Argument required (integer, `fixed' or `limited')."));
616 else if (strcmp (args
, "hard") == 0
617 || strcmp (args
, "fixed") == 0)
619 else if (strcmp (args
, "soft") == 0
620 || strcmp (args
, "limit") == 0)
625 size
= strtoul (args
, &end
, 0);
627 error (_("Invalid %s (bad syntax)."), config
->name
);
629 /* Instead of explicitly capping the size of a packet to
630 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
631 instead allowed to set the size to something arbitrarily
633 if (size
> MAX_REMOTE_PACKET_SIZE
)
634 error (_("Invalid %s (too large)."), config
->name
);
638 if (fixed_p
&& !config
->fixed_p
)
640 if (! query (_("The target may not be able to correctly handle a %s\n"
641 "of %ld bytes. Change the packet size? "),
643 error (_("Packet size not changed."));
645 /* Update the config. */
646 config
->fixed_p
= fixed_p
;
651 show_memory_packet_size (struct memory_packet_config
*config
)
653 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
655 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
656 get_memory_packet_size (config
));
658 printf_filtered (_("Packets are limited to %ld bytes.\n"),
659 get_memory_packet_size (config
));
662 static struct memory_packet_config memory_write_packet_config
=
664 "memory-write-packet-size",
668 set_memory_write_packet_size (char *args
, int from_tty
)
670 set_memory_packet_size (args
, &memory_write_packet_config
);
674 show_memory_write_packet_size (char *args
, int from_tty
)
676 show_memory_packet_size (&memory_write_packet_config
);
680 get_memory_write_packet_size (void)
682 return get_memory_packet_size (&memory_write_packet_config
);
685 static struct memory_packet_config memory_read_packet_config
=
687 "memory-read-packet-size",
691 set_memory_read_packet_size (char *args
, int from_tty
)
693 set_memory_packet_size (args
, &memory_read_packet_config
);
697 show_memory_read_packet_size (char *args
, int from_tty
)
699 show_memory_packet_size (&memory_read_packet_config
);
703 get_memory_read_packet_size (void)
705 long size
= get_memory_packet_size (&memory_read_packet_config
);
706 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
707 extra buffer size argument before the memory read size can be
708 increased beyond this. */
709 if (size
> get_remote_packet_size ())
710 size
= get_remote_packet_size ();
715 /* Generic configuration support for packets the stub optionally
716 supports. Allows the user to specify the use of the packet as well
717 as allowing GDB to auto-detect support in the remote stub. */
721 PACKET_SUPPORT_UNKNOWN
= 0,
730 enum auto_boolean detect
;
731 enum packet_support support
;
734 /* Analyze a packet's return value and update the packet config
745 update_packet_config (struct packet_config
*config
)
747 switch (config
->detect
)
749 case AUTO_BOOLEAN_TRUE
:
750 config
->support
= PACKET_ENABLE
;
752 case AUTO_BOOLEAN_FALSE
:
753 config
->support
= PACKET_DISABLE
;
755 case AUTO_BOOLEAN_AUTO
:
756 config
->support
= PACKET_SUPPORT_UNKNOWN
;
762 show_packet_config_cmd (struct packet_config
*config
)
764 char *support
= "internal-error";
765 switch (config
->support
)
771 support
= "disabled";
773 case PACKET_SUPPORT_UNKNOWN
:
777 switch (config
->detect
)
779 case AUTO_BOOLEAN_AUTO
:
780 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
781 config
->name
, support
);
783 case AUTO_BOOLEAN_TRUE
:
784 case AUTO_BOOLEAN_FALSE
:
785 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
786 config
->name
, support
);
792 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
793 const char *title
, int legacy
)
800 config
->title
= title
;
801 config
->detect
= AUTO_BOOLEAN_AUTO
;
802 config
->support
= PACKET_SUPPORT_UNKNOWN
;
803 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
805 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
807 /* set/show TITLE-packet {auto,on,off} */
808 cmd_name
= xstrprintf ("%s-packet", title
);
809 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
810 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
811 set_remote_protocol_packet_cmd
,
812 show_remote_protocol_packet_cmd
,
813 &remote_set_cmdlist
, &remote_show_cmdlist
);
814 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
818 legacy_name
= xstrprintf ("%s-packet", name
);
819 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
820 &remote_set_cmdlist
);
821 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
822 &remote_show_cmdlist
);
826 static enum packet_result
827 packet_check_result (const char *buf
)
831 /* The stub recognized the packet request. Check that the
832 operation succeeded. */
834 && isxdigit (buf
[1]) && isxdigit (buf
[2])
836 /* "Enn" - definitly an error. */
839 /* Always treat "E." as an error. This will be used for
840 more verbose error messages, such as E.memtypes. */
841 if (buf
[0] == 'E' && buf
[1] == '.')
844 /* The packet may or may not be OK. Just assume it is. */
848 /* The stub does not support the packet. */
849 return PACKET_UNKNOWN
;
852 static enum packet_result
853 packet_ok (const char *buf
, struct packet_config
*config
)
855 enum packet_result result
;
857 result
= packet_check_result (buf
);
862 /* The stub recognized the packet request. */
863 switch (config
->support
)
865 case PACKET_SUPPORT_UNKNOWN
:
867 fprintf_unfiltered (gdb_stdlog
,
868 "Packet %s (%s) is supported\n",
869 config
->name
, config
->title
);
870 config
->support
= PACKET_ENABLE
;
873 internal_error (__FILE__
, __LINE__
,
874 _("packet_ok: attempt to use a disabled packet"));
881 /* The stub does not support the packet. */
882 switch (config
->support
)
885 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
886 /* If the stub previously indicated that the packet was
887 supported then there is a protocol error.. */
888 error (_("Protocol error: %s (%s) conflicting enabled responses."),
889 config
->name
, config
->title
);
891 /* The user set it wrong. */
892 error (_("Enabled packet %s (%s) not recognized by stub"),
893 config
->name
, config
->title
);
895 case PACKET_SUPPORT_UNKNOWN
:
897 fprintf_unfiltered (gdb_stdlog
,
898 "Packet %s (%s) is NOT supported\n",
899 config
->name
, config
->title
);
900 config
->support
= PACKET_DISABLE
;
928 PACKET_qXfer_features
,
929 PACKET_qXfer_libraries
,
930 PACKET_qXfer_memory_map
,
931 PACKET_qXfer_spu_read
,
932 PACKET_qXfer_spu_write
,
941 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
944 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
945 struct cmd_list_element
*c
)
947 struct packet_config
*packet
;
949 for (packet
= remote_protocol_packets
;
950 packet
< &remote_protocol_packets
[PACKET_MAX
];
953 if (&packet
->detect
== c
->var
)
955 update_packet_config (packet
);
959 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
964 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
965 struct cmd_list_element
*c
,
968 struct packet_config
*packet
;
970 for (packet
= remote_protocol_packets
;
971 packet
< &remote_protocol_packets
[PACKET_MAX
];
974 if (&packet
->detect
== c
->var
)
976 show_packet_config_cmd (packet
);
980 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
984 /* Should we try one of the 'Z' requests? */
988 Z_PACKET_SOFTWARE_BP
,
989 Z_PACKET_HARDWARE_BP
,
996 /* For compatibility with older distributions. Provide a ``set remote
997 Z-packet ...'' command that updates all the Z packet types. */
999 static enum auto_boolean remote_Z_packet_detect
;
1002 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
1003 struct cmd_list_element
*c
)
1006 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1008 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
1009 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1014 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
1015 struct cmd_list_element
*c
,
1019 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1021 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1025 /* Should we try the 'ThreadInfo' query packet?
1027 This variable (NOT available to the user: auto-detect only!)
1028 determines whether GDB will use the new, simpler "ThreadInfo"
1029 query or the older, more complex syntax for thread queries.
1030 This is an auto-detect variable (set to true at each connect,
1031 and set to false when the target fails to recognize it). */
1033 static int use_threadinfo_query
;
1034 static int use_threadextra_query
;
1036 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1037 static struct async_signal_handler
*sigint_remote_twice_token
;
1038 static struct async_signal_handler
*sigint_remote_token
;
1043 /* These are the threads which we last sent to the remote system.
1044 -1 for all or -2 for not sent yet. */
1045 static int general_thread
;
1046 static int continue_thread
;
1048 /* Call this function as a result of
1049 1) A halt indication (T packet) containing a thread id
1050 2) A direct query of currthread
1051 3) Successful execution of set thread
1055 record_currthread (int currthread
)
1057 general_thread
= currthread
;
1059 /* If this is a new thread, add it to GDB's thread list.
1060 If we leave it up to WFI to do this, bad things will happen. */
1061 if (!in_thread_list (pid_to_ptid (currthread
)))
1062 add_thread (pid_to_ptid (currthread
));
1065 static char *last_pass_packet
;
1067 /* If 'QPassSignals' is supported, tell the remote stub what signals
1068 it can simply pass through to the inferior without reporting. */
1071 remote_pass_signals (void)
1073 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1075 char *pass_packet
, *p
;
1076 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1079 gdb_assert (numsigs
< 256);
1080 for (i
= 0; i
< numsigs
; i
++)
1082 if (signal_stop_state (i
) == 0
1083 && signal_print_state (i
) == 0
1084 && signal_pass_state (i
) == 1)
1087 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1088 strcpy (pass_packet
, "QPassSignals:");
1089 p
= pass_packet
+ strlen (pass_packet
);
1090 for (i
= 0; i
< numsigs
; i
++)
1092 if (signal_stop_state (i
) == 0
1093 && signal_print_state (i
) == 0
1094 && signal_pass_state (i
) == 1)
1097 *p
++ = tohex (i
>> 4);
1098 *p
++ = tohex (i
& 15);
1107 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1109 struct remote_state
*rs
= get_remote_state ();
1110 char *buf
= rs
->buf
;
1112 putpkt (pass_packet
);
1113 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1114 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1115 if (last_pass_packet
)
1116 xfree (last_pass_packet
);
1117 last_pass_packet
= pass_packet
;
1120 xfree (pass_packet
);
1124 #define MAGIC_NULL_PID 42000
1127 set_thread (int th
, int gen
)
1129 struct remote_state
*rs
= get_remote_state ();
1130 char *buf
= rs
->buf
;
1131 int state
= gen
? general_thread
: continue_thread
;
1137 buf
[1] = gen
? 'g' : 'c';
1138 if (th
== MAGIC_NULL_PID
)
1144 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
1146 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
1148 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1150 general_thread
= th
;
1152 continue_thread
= th
;
1155 /* Return nonzero if the thread TH is still alive on the remote system. */
1158 remote_thread_alive (ptid_t ptid
)
1160 struct remote_state
*rs
= get_remote_state ();
1161 int tid
= PIDGET (ptid
);
1164 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1166 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1168 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1169 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1172 /* About these extended threadlist and threadinfo packets. They are
1173 variable length packets but, the fields within them are often fixed
1174 length. They are redundent enough to send over UDP as is the
1175 remote protocol in general. There is a matching unit test module
1178 #define OPAQUETHREADBYTES 8
1180 /* a 64 bit opaque identifier */
1181 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1183 /* WARNING: This threadref data structure comes from the remote O.S.,
1184 libstub protocol encoding, and remote.c. it is not particularly
1187 /* Right now, the internal structure is int. We want it to be bigger.
1191 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1193 /* gdb_ext_thread_info is an internal GDB data structure which is
1194 equivalent to the reply of the remote threadinfo packet. */
1196 struct gdb_ext_thread_info
1198 threadref threadid
; /* External form of thread reference. */
1199 int active
; /* Has state interesting to GDB?
1201 char display
[256]; /* Brief state display, name,
1202 blocked/suspended. */
1203 char shortname
[32]; /* To be used to name threads. */
1204 char more_display
[256]; /* Long info, statistics, queue depth,
1208 /* The volume of remote transfers can be limited by submitting
1209 a mask containing bits specifying the desired information.
1210 Use a union of these values as the 'selection' parameter to
1211 get_thread_info. FIXME: Make these TAG names more thread specific.
1214 #define TAG_THREADID 1
1215 #define TAG_EXISTS 2
1216 #define TAG_DISPLAY 4
1217 #define TAG_THREADNAME 8
1218 #define TAG_MOREDISPLAY 16
1220 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1222 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1224 static char *unpack_nibble (char *buf
, int *val
);
1226 static char *pack_nibble (char *buf
, int nibble
);
1228 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1230 static char *unpack_byte (char *buf
, int *value
);
1232 static char *pack_int (char *buf
, int value
);
1234 static char *unpack_int (char *buf
, int *value
);
1236 static char *unpack_string (char *src
, char *dest
, int length
);
1238 static char *pack_threadid (char *pkt
, threadref
*id
);
1240 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1242 void int_to_threadref (threadref
*id
, int value
);
1244 static int threadref_to_int (threadref
*ref
);
1246 static void copy_threadref (threadref
*dest
, threadref
*src
);
1248 static int threadmatch (threadref
*dest
, threadref
*src
);
1250 static char *pack_threadinfo_request (char *pkt
, int mode
,
1253 static int remote_unpack_thread_info_response (char *pkt
,
1254 threadref
*expectedref
,
1255 struct gdb_ext_thread_info
1259 static int remote_get_threadinfo (threadref
*threadid
,
1260 int fieldset
, /*TAG mask */
1261 struct gdb_ext_thread_info
*info
);
1263 static char *pack_threadlist_request (char *pkt
, int startflag
,
1265 threadref
*nextthread
);
1267 static int parse_threadlist_response (char *pkt
,
1269 threadref
*original_echo
,
1270 threadref
*resultlist
,
1273 static int remote_get_threadlist (int startflag
,
1274 threadref
*nextthread
,
1278 threadref
*threadlist
);
1280 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1282 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1283 void *context
, int looplimit
);
1285 static int remote_newthread_step (threadref
*ref
, void *context
);
1287 /* Encode 64 bits in 16 chars of hex. */
1289 static const char hexchars
[] = "0123456789abcdef";
1292 ishex (int ch
, int *val
)
1294 if ((ch
>= 'a') && (ch
<= 'f'))
1296 *val
= ch
- 'a' + 10;
1299 if ((ch
>= 'A') && (ch
<= 'F'))
1301 *val
= ch
- 'A' + 10;
1304 if ((ch
>= '0') && (ch
<= '9'))
1315 if (ch
>= 'a' && ch
<= 'f')
1316 return ch
- 'a' + 10;
1317 if (ch
>= '0' && ch
<= '9')
1319 if (ch
>= 'A' && ch
<= 'F')
1320 return ch
- 'A' + 10;
1325 stub_unpack_int (char *buff
, int fieldlength
)
1332 nibble
= stubhex (*buff
++);
1336 retval
= retval
<< 4;
1342 unpack_varlen_hex (char *buff
, /* packet to parse */
1346 ULONGEST retval
= 0;
1348 while (ishex (*buff
, &nibble
))
1351 retval
= retval
<< 4;
1352 retval
|= nibble
& 0x0f;
1359 unpack_nibble (char *buf
, int *val
)
1361 *val
= fromhex (*buf
++);
1366 pack_nibble (char *buf
, int nibble
)
1368 *buf
++ = hexchars
[(nibble
& 0x0f)];
1373 pack_hex_byte (char *pkt
, int byte
)
1375 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1376 *pkt
++ = hexchars
[(byte
& 0xf)];
1381 unpack_byte (char *buf
, int *value
)
1383 *value
= stub_unpack_int (buf
, 2);
1388 pack_int (char *buf
, int value
)
1390 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1391 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1392 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1393 buf
= pack_hex_byte (buf
, (value
& 0xff));
1398 unpack_int (char *buf
, int *value
)
1400 *value
= stub_unpack_int (buf
, 8);
1404 #if 0 /* Currently unused, uncomment when needed. */
1405 static char *pack_string (char *pkt
, char *string
);
1408 pack_string (char *pkt
, char *string
)
1413 len
= strlen (string
);
1415 len
= 200; /* Bigger than most GDB packets, junk??? */
1416 pkt
= pack_hex_byte (pkt
, len
);
1420 if ((ch
== '\0') || (ch
== '#'))
1421 ch
= '*'; /* Protect encapsulation. */
1426 #endif /* 0 (unused) */
1429 unpack_string (char *src
, char *dest
, int length
)
1438 pack_threadid (char *pkt
, threadref
*id
)
1441 unsigned char *altid
;
1443 altid
= (unsigned char *) id
;
1444 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1446 pkt
= pack_hex_byte (pkt
, *altid
++);
1452 unpack_threadid (char *inbuf
, threadref
*id
)
1455 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1458 altref
= (char *) id
;
1460 while (inbuf
< limit
)
1462 x
= stubhex (*inbuf
++);
1463 y
= stubhex (*inbuf
++);
1464 *altref
++ = (x
<< 4) | y
;
1469 /* Externally, threadrefs are 64 bits but internally, they are still
1470 ints. This is due to a mismatch of specifications. We would like
1471 to use 64bit thread references internally. This is an adapter
1475 int_to_threadref (threadref
*id
, int value
)
1477 unsigned char *scan
;
1479 scan
= (unsigned char *) id
;
1485 *scan
++ = (value
>> 24) & 0xff;
1486 *scan
++ = (value
>> 16) & 0xff;
1487 *scan
++ = (value
>> 8) & 0xff;
1488 *scan
++ = (value
& 0xff);
1492 threadref_to_int (threadref
*ref
)
1495 unsigned char *scan
;
1501 value
= (value
<< 8) | ((*scan
++) & 0xff);
1506 copy_threadref (threadref
*dest
, threadref
*src
)
1509 unsigned char *csrc
, *cdest
;
1511 csrc
= (unsigned char *) src
;
1512 cdest
= (unsigned char *) dest
;
1519 threadmatch (threadref
*dest
, threadref
*src
)
1521 /* Things are broken right now, so just assume we got a match. */
1523 unsigned char *srcp
, *destp
;
1525 srcp
= (char *) src
;
1526 destp
= (char *) dest
;
1530 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1537 threadid:1, # always request threadid
1544 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1547 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1549 *pkt
++ = 'q'; /* Info Query */
1550 *pkt
++ = 'P'; /* process or thread info */
1551 pkt
= pack_int (pkt
, mode
); /* mode */
1552 pkt
= pack_threadid (pkt
, id
); /* threadid */
1553 *pkt
= '\0'; /* terminate */
1557 /* These values tag the fields in a thread info response packet. */
1558 /* Tagging the fields allows us to request specific fields and to
1559 add more fields as time goes by. */
1561 #define TAG_THREADID 1 /* Echo the thread identifier. */
1562 #define TAG_EXISTS 2 /* Is this process defined enough to
1563 fetch registers and its stack? */
1564 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1565 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1566 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1570 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1571 struct gdb_ext_thread_info
*info
)
1573 struct remote_state
*rs
= get_remote_state ();
1577 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1580 /* info->threadid = 0; FIXME: implement zero_threadref. */
1582 info
->display
[0] = '\0';
1583 info
->shortname
[0] = '\0';
1584 info
->more_display
[0] = '\0';
1586 /* Assume the characters indicating the packet type have been
1588 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1589 pkt
= unpack_threadid (pkt
, &ref
);
1592 warning (_("Incomplete response to threadinfo request."));
1593 if (!threadmatch (&ref
, expectedref
))
1594 { /* This is an answer to a different request. */
1595 warning (_("ERROR RMT Thread info mismatch."));
1598 copy_threadref (&info
->threadid
, &ref
);
1600 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1602 /* Packets are terminated with nulls. */
1603 while ((pkt
< limit
) && mask
&& *pkt
)
1605 pkt
= unpack_int (pkt
, &tag
); /* tag */
1606 pkt
= unpack_byte (pkt
, &length
); /* length */
1607 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1609 warning (_("ERROR RMT: threadinfo tag mismatch."));
1613 if (tag
== TAG_THREADID
)
1617 warning (_("ERROR RMT: length of threadid is not 16."));
1621 pkt
= unpack_threadid (pkt
, &ref
);
1622 mask
= mask
& ~TAG_THREADID
;
1625 if (tag
== TAG_EXISTS
)
1627 info
->active
= stub_unpack_int (pkt
, length
);
1629 mask
= mask
& ~(TAG_EXISTS
);
1632 warning (_("ERROR RMT: 'exists' length too long."));
1638 if (tag
== TAG_THREADNAME
)
1640 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1641 mask
= mask
& ~TAG_THREADNAME
;
1644 if (tag
== TAG_DISPLAY
)
1646 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1647 mask
= mask
& ~TAG_DISPLAY
;
1650 if (tag
== TAG_MOREDISPLAY
)
1652 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1653 mask
= mask
& ~TAG_MOREDISPLAY
;
1656 warning (_("ERROR RMT: unknown thread info tag."));
1657 break; /* Not a tag we know about. */
1663 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1664 struct gdb_ext_thread_info
*info
)
1666 struct remote_state
*rs
= get_remote_state ();
1669 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1671 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1672 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1677 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1680 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1681 threadref
*nextthread
)
1683 *pkt
++ = 'q'; /* info query packet */
1684 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1685 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1686 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1687 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1692 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1695 parse_threadlist_response (char *pkt
, int result_limit
,
1696 threadref
*original_echo
, threadref
*resultlist
,
1699 struct remote_state
*rs
= get_remote_state ();
1701 int count
, resultcount
, done
;
1704 /* Assume the 'q' and 'M chars have been stripped. */
1705 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1706 /* done parse past here */
1707 pkt
= unpack_byte (pkt
, &count
); /* count field */
1708 pkt
= unpack_nibble (pkt
, &done
);
1709 /* The first threadid is the argument threadid. */
1710 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1711 while ((count
-- > 0) && (pkt
< limit
))
1713 pkt
= unpack_threadid (pkt
, resultlist
++);
1714 if (resultcount
++ >= result_limit
)
1723 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1724 int *done
, int *result_count
, threadref
*threadlist
)
1726 struct remote_state
*rs
= get_remote_state ();
1727 static threadref echo_nextthread
;
1730 /* Trancate result limit to be smaller than the packet size. */
1731 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1732 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1734 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1736 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1738 if (*rs
->buf
== '\0')
1742 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1745 if (!threadmatch (&echo_nextthread
, nextthread
))
1747 /* FIXME: This is a good reason to drop the packet. */
1748 /* Possably, there is a duplicate response. */
1750 retransmit immediatly - race conditions
1751 retransmit after timeout - yes
1753 wait for packet, then exit
1755 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1756 return 0; /* I choose simply exiting. */
1758 if (*result_count
<= 0)
1762 warning (_("RMT ERROR : failed to get remote thread list."));
1765 return result
; /* break; */
1767 if (*result_count
> result_limit
)
1770 warning (_("RMT ERROR: threadlist response longer than requested."));
1776 /* This is the interface between remote and threads, remotes upper
1779 /* remote_find_new_threads retrieves the thread list and for each
1780 thread in the list, looks up the thread in GDB's internal list,
1781 ading the thread if it does not already exist. This involves
1782 getting partial thread lists from the remote target so, polling the
1783 quit_flag is required. */
1786 /* About this many threadisds fit in a packet. */
1788 #define MAXTHREADLISTRESULTS 32
1791 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1794 int done
, i
, result_count
;
1798 static threadref nextthread
;
1799 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1804 if (loopcount
++ > looplimit
)
1807 warning (_("Remote fetch threadlist -infinite loop-."));
1810 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1811 &done
, &result_count
, resultthreadlist
))
1816 /* Clear for later iterations. */
1818 /* Setup to resume next batch of thread references, set nextthread. */
1819 if (result_count
>= 1)
1820 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1822 while (result_count
--)
1823 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1830 remote_newthread_step (threadref
*ref
, void *context
)
1834 ptid
= pid_to_ptid (threadref_to_int (ref
));
1836 if (!in_thread_list (ptid
))
1838 return 1; /* continue iterator */
1841 #define CRAZY_MAX_THREADS 1000
1844 remote_current_thread (ptid_t oldpid
)
1846 struct remote_state
*rs
= get_remote_state ();
1849 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1850 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1851 /* Use strtoul here, so we'll correctly parse values whose highest
1852 bit is set. The protocol carries them as a simple series of
1853 hex digits; in the absence of a sign, strtol will see such
1854 values as positive numbers out of range for signed 'long', and
1855 return LONG_MAX to indicate an overflow. */
1856 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1861 /* Find new threads for info threads command.
1862 * Original version, using John Metzler's thread protocol.
1866 remote_find_new_threads (void)
1868 remote_threadlist_iterator (remote_newthread_step
, 0,
1870 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1871 inferior_ptid
= remote_current_thread (inferior_ptid
);
1875 * Find all threads for info threads command.
1876 * Uses new thread protocol contributed by Cisco.
1877 * Falls back and attempts to use the older method (above)
1878 * if the target doesn't respond to the new method.
1882 remote_threads_info (void)
1884 struct remote_state
*rs
= get_remote_state ();
1888 if (remote_desc
== 0) /* paranoia */
1889 error (_("Command can only be used when connected to the remote target."));
1891 if (use_threadinfo_query
)
1893 putpkt ("qfThreadInfo");
1894 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1896 if (bufp
[0] != '\0') /* q packet recognized */
1898 while (*bufp
++ == 'm') /* reply contains one or more TID */
1902 /* Use strtoul here, so we'll correctly parse values
1903 whose highest bit is set. The protocol carries
1904 them as a simple series of hex digits; in the
1905 absence of a sign, strtol will see such values as
1906 positive numbers out of range for signed 'long',
1907 and return LONG_MAX to indicate an overflow. */
1908 tid
= strtoul (bufp
, &bufp
, 16);
1909 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1910 add_thread (pid_to_ptid (tid
));
1912 while (*bufp
++ == ','); /* comma-separated list */
1913 putpkt ("qsThreadInfo");
1914 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1921 /* Else fall back to old method based on jmetzler protocol. */
1922 use_threadinfo_query
= 0;
1923 remote_find_new_threads ();
1928 * Collect a descriptive string about the given thread.
1929 * The target may say anything it wants to about the thread
1930 * (typically info about its blocked / runnable state, name, etc.).
1931 * This string will appear in the info threads display.
1933 * Optional: targets are not required to implement this function.
1937 remote_threads_extra_info (struct thread_info
*tp
)
1939 struct remote_state
*rs
= get_remote_state ();
1943 struct gdb_ext_thread_info threadinfo
;
1944 static char display_buf
[100]; /* arbitrary... */
1945 int n
= 0; /* position in display_buf */
1947 if (remote_desc
== 0) /* paranoia */
1948 internal_error (__FILE__
, __LINE__
,
1949 _("remote_threads_extra_info"));
1951 if (use_threadextra_query
)
1953 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1956 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1957 if (rs
->buf
[0] != 0)
1959 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1960 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1961 display_buf
[result
] = '\0';
1966 /* If the above query fails, fall back to the old method. */
1967 use_threadextra_query
= 0;
1968 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1969 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1970 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1971 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1972 if (threadinfo
.active
)
1974 if (*threadinfo
.shortname
)
1975 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1976 " Name: %s,", threadinfo
.shortname
);
1977 if (*threadinfo
.display
)
1978 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1979 " State: %s,", threadinfo
.display
);
1980 if (*threadinfo
.more_display
)
1981 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1982 " Priority: %s", threadinfo
.more_display
);
1986 /* For purely cosmetic reasons, clear up trailing commas. */
1987 if (',' == display_buf
[n
-1])
1988 display_buf
[n
-1] = ' ';
1996 /* Restart the remote side; this is an extended protocol operation. */
1999 extended_remote_restart (void)
2001 struct remote_state
*rs
= get_remote_state ();
2003 /* Send the restart command; for reasons I don't understand the
2004 remote side really expects a number after the "R". */
2005 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
2008 remote_fileio_reset ();
2011 /* Clean up connection to a remote debugger. */
2014 remote_close (int quitting
)
2017 serial_close (remote_desc
);
2021 /* Query the remote side for the text, data and bss offsets. */
2026 struct remote_state
*rs
= get_remote_state ();
2029 int lose
, num_segments
= 0, do_sections
, do_segments
;
2030 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
2031 struct section_offsets
*offs
;
2032 struct symfile_segment_data
*data
;
2034 if (symfile_objfile
== NULL
)
2037 putpkt ("qOffsets");
2038 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2041 if (buf
[0] == '\000')
2042 return; /* Return silently. Stub doesn't support
2046 warning (_("Remote failure reply: %s"), buf
);
2050 /* Pick up each field in turn. This used to be done with scanf, but
2051 scanf will make trouble if CORE_ADDR size doesn't match
2052 conversion directives correctly. The following code will work
2053 with any size of CORE_ADDR. */
2054 text_addr
= data_addr
= bss_addr
= 0;
2058 if (strncmp (ptr
, "Text=", 5) == 0)
2061 /* Don't use strtol, could lose on big values. */
2062 while (*ptr
&& *ptr
!= ';')
2063 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2065 if (strncmp (ptr
, ";Data=", 6) == 0)
2068 while (*ptr
&& *ptr
!= ';')
2069 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2074 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2077 while (*ptr
&& *ptr
!= ';')
2078 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2080 if (bss_addr
!= data_addr
)
2081 warning (_("Target reported unsupported offsets: %s"), buf
);
2086 else if (strncmp (ptr
, "TextSeg=", 8) == 0)
2089 /* Don't use strtol, could lose on big values. */
2090 while (*ptr
&& *ptr
!= ';')
2091 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2094 if (strncmp (ptr
, ";DataSeg=", 9) == 0)
2097 while (*ptr
&& *ptr
!= ';')
2098 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2106 error (_("Malformed response to offset query, %s"), buf
);
2107 else if (*ptr
!= '\0')
2108 warning (_("Target reported unsupported offsets: %s"), buf
);
2110 offs
= ((struct section_offsets
*)
2111 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2112 memcpy (offs
, symfile_objfile
->section_offsets
,
2113 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2115 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
2116 do_segments
= (data
!= NULL
);
2117 do_sections
= num_segments
== 0;
2119 if (num_segments
> 0)
2121 segments
[0] = text_addr
;
2122 segments
[1] = data_addr
;
2124 /* If we have two segments, we can still try to relocate everything
2125 by assuming that the .text and .data offsets apply to the whole
2126 text and data segments. Convert the offsets given in the packet
2127 to base addresses for symfile_map_offsets_to_segments. */
2128 else if (data
&& data
->num_segments
== 2)
2130 segments
[0] = data
->segment_bases
[0] + text_addr
;
2131 segments
[1] = data
->segment_bases
[1] + data_addr
;
2134 /* There's no way to relocate by segment. */
2140 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
2141 offs
, num_segments
, segments
);
2143 if (ret
== 0 && !do_sections
)
2144 error (_("Can not handle qOffsets TextSeg response with this symbol file"));
2151 free_symfile_segment_data (data
);
2155 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2157 /* This is a temporary kludge to force data and bss to use the same offsets
2158 because that's what nlmconv does now. The real solution requires changes
2159 to the stub and remote.c that I don't have time to do right now. */
2161 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2162 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2165 objfile_relocate (symfile_objfile
, offs
);
2168 /* Stub for catch_exception. */
2170 struct start_remote_args
2174 /* The current target. */
2175 struct target_ops
*target
;
2177 /* Non-zero if this is an extended-remote target. */
2182 remote_start_remote (struct ui_out
*uiout
, void *opaque
)
2184 struct remote_state
*rs
= get_remote_state ();
2185 struct start_remote_args
*args
= opaque
;
2186 char *wait_status
= NULL
;
2188 immediate_quit
++; /* Allow user to interrupt it. */
2190 /* Ack any packet which the remote side has already sent. */
2191 serial_write (remote_desc
, "+", 1);
2193 /* Check whether the target is running now. */
2195 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2197 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
2199 if (args
->extended_p
)
2201 /* We're connected, but not running. Drop out before we
2202 call start_remote. */
2203 target_mark_exited (args
->target
);
2207 error (_("The target is not running (try extended-remote?)"));
2211 if (args
->extended_p
)
2212 target_mark_running (args
->target
);
2214 /* Save the reply for later. */
2215 wait_status
= alloca (strlen (rs
->buf
) + 1);
2216 strcpy (wait_status
, rs
->buf
);
2219 /* Let the stub know that we want it to return the thread. */
2222 /* Without this, some commands which require an active target
2223 (such as kill) won't work. This variable serves (at least)
2224 double duty as both the pid of the target process (if it has
2225 such), and as a flag indicating that a target is active.
2226 These functions should be split out into seperate variables,
2227 especially since GDB will someday have a notion of debugging
2228 several processes. */
2229 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2231 /* Now, if we have thread information, update inferior_ptid. */
2232 inferior_ptid
= remote_current_thread (inferior_ptid
);
2234 get_offsets (); /* Get text, data & bss offsets. */
2236 /* Use the previously fetched status. */
2237 gdb_assert (wait_status
!= NULL
);
2238 strcpy (rs
->buf
, wait_status
);
2239 rs
->cached_wait_status
= 1;
2242 start_remote (args
->from_tty
); /* Initialize gdb process mechanisms. */
2245 /* Open a connection to a remote debugger.
2246 NAME is the filename used for communication. */
2249 remote_open (char *name
, int from_tty
)
2251 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2254 /* Just like remote_open, but with asynchronous support. */
2256 remote_async_open (char *name
, int from_tty
)
2258 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2261 /* Open a connection to a remote debugger using the extended
2262 remote gdb protocol. NAME is the filename used for communication. */
2265 extended_remote_open (char *name
, int from_tty
)
2267 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2271 /* Just like extended_remote_open, but with asynchronous support. */
2273 extended_remote_async_open (char *name
, int from_tty
)
2275 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2276 1 /*extended_p */, 1 /* async_p */);
2279 /* Generic code for opening a connection to a remote target. */
2282 init_all_packet_configs (void)
2285 for (i
= 0; i
< PACKET_MAX
; i
++)
2286 update_packet_config (&remote_protocol_packets
[i
]);
2289 /* Symbol look-up. */
2292 remote_check_symbols (struct objfile
*objfile
)
2294 struct remote_state
*rs
= get_remote_state ();
2295 char *msg
, *reply
, *tmp
;
2296 struct minimal_symbol
*sym
;
2299 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2302 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2303 because we need both at the same time. */
2304 msg
= alloca (get_remote_packet_size ());
2306 /* Invite target to request symbol lookups. */
2308 putpkt ("qSymbol::");
2309 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2310 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2313 while (strncmp (reply
, "qSymbol:", 8) == 0)
2316 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2318 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2320 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2323 CORE_ADDR sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
2325 /* If this is a function address, return the start of code
2326 instead of any data function descriptor. */
2327 sym_addr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
2331 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2332 paddr_nz (sym_addr
), &reply
[8]);
2336 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2341 static struct serial
*
2342 remote_serial_open (char *name
)
2344 static int udp_warning
= 0;
2346 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2347 of in ser-tcp.c, because it is the remote protocol assuming that the
2348 serial connection is reliable and not the serial connection promising
2350 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2353 The remote protocol may be unreliable over UDP.\n\
2354 Some events may be lost, rendering further debugging impossible."));
2358 return serial_open (name
);
2361 /* This type describes each known response to the qSupported
2363 struct protocol_feature
2365 /* The name of this protocol feature. */
2368 /* The default for this protocol feature. */
2369 enum packet_support default_support
;
2371 /* The function to call when this feature is reported, or after
2372 qSupported processing if the feature is not supported.
2373 The first argument points to this structure. The second
2374 argument indicates whether the packet requested support be
2375 enabled, disabled, or probed (or the default, if this function
2376 is being called at the end of processing and this feature was
2377 not reported). The third argument may be NULL; if not NULL, it
2378 is a NUL-terminated string taken from the packet following
2379 this feature's name and an equals sign. */
2380 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2383 /* The corresponding packet for this feature. Only used if
2384 FUNC is remote_supported_packet. */
2389 remote_supported_packet (const struct protocol_feature
*feature
,
2390 enum packet_support support
,
2391 const char *argument
)
2395 warning (_("Remote qSupported response supplied an unexpected value for"
2396 " \"%s\"."), feature
->name
);
2400 if (remote_protocol_packets
[feature
->packet
].support
2401 == PACKET_SUPPORT_UNKNOWN
)
2402 remote_protocol_packets
[feature
->packet
].support
= support
;
2406 remote_packet_size (const struct protocol_feature
*feature
,
2407 enum packet_support support
, const char *value
)
2409 struct remote_state
*rs
= get_remote_state ();
2414 if (support
!= PACKET_ENABLE
)
2417 if (value
== NULL
|| *value
== '\0')
2419 warning (_("Remote target reported \"%s\" without a size."),
2425 packet_size
= strtol (value
, &value_end
, 16);
2426 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2428 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2429 feature
->name
, value
);
2433 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2435 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2436 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2437 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2440 /* Record the new maximum packet size. */
2441 rs
->explicit_packet_size
= packet_size
;
2444 static struct protocol_feature remote_protocol_features
[] = {
2445 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2446 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2447 PACKET_qXfer_auxv
},
2448 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2449 PACKET_qXfer_features
},
2450 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
2451 PACKET_qXfer_libraries
},
2452 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2453 PACKET_qXfer_memory_map
},
2454 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
2455 PACKET_qXfer_spu_read
},
2456 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
2457 PACKET_qXfer_spu_write
},
2458 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2459 PACKET_QPassSignals
},
2463 remote_query_supported (void)
2465 struct remote_state
*rs
= get_remote_state ();
2468 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2470 /* The packet support flags are handled differently for this packet
2471 than for most others. We treat an error, a disabled packet, and
2472 an empty response identically: any features which must be reported
2473 to be used will be automatically disabled. An empty buffer
2474 accomplishes this, since that is also the representation for a list
2475 containing no features. */
2478 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2480 putpkt ("qSupported");
2481 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2483 /* If an error occured, warn, but do not return - just reset the
2484 buffer to empty and go on to disable features. */
2485 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2488 warning (_("Remote failure reply: %s"), rs
->buf
);
2493 memset (seen
, 0, sizeof (seen
));
2498 enum packet_support is_supported
;
2499 char *p
, *end
, *name_end
, *value
;
2501 /* First separate out this item from the rest of the packet. If
2502 there's another item after this, we overwrite the separator
2503 (terminated strings are much easier to work with). */
2505 end
= strchr (p
, ';');
2508 end
= p
+ strlen (p
);
2518 warning (_("empty item in \"qSupported\" response"));
2523 name_end
= strchr (p
, '=');
2526 /* This is a name=value entry. */
2527 is_supported
= PACKET_ENABLE
;
2528 value
= name_end
+ 1;
2537 is_supported
= PACKET_ENABLE
;
2541 is_supported
= PACKET_DISABLE
;
2545 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2549 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2555 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2556 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2558 const struct protocol_feature
*feature
;
2561 feature
= &remote_protocol_features
[i
];
2562 feature
->func (feature
, is_supported
, value
);
2567 /* If we increased the packet size, make sure to increase the global
2568 buffer size also. We delay this until after parsing the entire
2569 qSupported packet, because this is the same buffer we were
2571 if (rs
->buf_size
< rs
->explicit_packet_size
)
2573 rs
->buf_size
= rs
->explicit_packet_size
;
2574 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2577 /* Handle the defaults for unmentioned features. */
2578 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2581 const struct protocol_feature
*feature
;
2583 feature
= &remote_protocol_features
[i
];
2584 feature
->func (feature
, feature
->default_support
, NULL
);
2590 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2591 int extended_p
, int async_p
)
2593 struct remote_state
*rs
= get_remote_state ();
2595 error (_("To open a remote debug connection, you need to specify what\n"
2596 "serial device is attached to the remote system\n"
2597 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2599 /* See FIXME above. */
2601 wait_forever_enabled_p
= 1;
2603 /* If we're connected to a running target, target_preopen will kill it.
2604 But if we're connected to a target system with no running process,
2605 then we will still be connected when it returns. Ask this question
2606 first, before target_preopen has a chance to kill anything. */
2607 if (remote_desc
!= NULL
&& !target_has_execution
)
2610 || query (_("Already connected to a remote target. Disconnect? ")))
2613 error (_("Still connected."));
2616 target_preopen (from_tty
);
2618 unpush_target (target
);
2620 /* This time without a query. If we were connected to an
2621 extended-remote target and target_preopen killed the running
2622 process, we may still be connected. If we are starting "target
2623 remote" now, the extended-remote target will not have been
2624 removed by unpush_target. */
2625 if (remote_desc
!= NULL
&& !target_has_execution
)
2628 /* Make sure we send the passed signals list the next time we resume. */
2629 xfree (last_pass_packet
);
2630 last_pass_packet
= NULL
;
2632 remote_fileio_reset ();
2633 reopen_exec_file ();
2636 remote_desc
= remote_serial_open (name
);
2638 perror_with_name (name
);
2640 if (baud_rate
!= -1)
2642 if (serial_setbaudrate (remote_desc
, baud_rate
))
2644 /* The requested speed could not be set. Error out to
2645 top level after closing remote_desc. Take care to
2646 set remote_desc to NULL to avoid closing remote_desc
2648 serial_close (remote_desc
);
2650 perror_with_name (name
);
2654 serial_raw (remote_desc
);
2656 /* If there is something sitting in the buffer we might take it as a
2657 response to a command, which would be bad. */
2658 serial_flush_input (remote_desc
);
2662 puts_filtered ("Remote debugging using ");
2663 puts_filtered (name
);
2664 puts_filtered ("\n");
2666 push_target (target
); /* Switch to using remote target now. */
2668 /* Assume that the target is running, unless we learn otherwise. */
2669 target_mark_running (target
);
2671 /* Reset the target state; these things will be queried either by
2672 remote_query_supported or as they are needed. */
2673 init_all_packet_configs ();
2674 rs
->explicit_packet_size
= 0;
2676 general_thread
= -2;
2677 continue_thread
= -2;
2679 /* Probe for ability to use "ThreadInfo" query, as required. */
2680 use_threadinfo_query
= 1;
2681 use_threadextra_query
= 1;
2683 /* The first packet we send to the target is the optional "supported
2684 packets" request. If the target can answer this, it will tell us
2685 which later probes to skip. */
2686 remote_query_supported ();
2688 /* Next, if the target can specify a description, read it. We do
2689 this before anything involving memory or registers. */
2690 target_find_description ();
2694 /* With this target we start out by owning the terminal. */
2695 remote_async_terminal_ours_p
= 1;
2697 /* FIXME: cagney/1999-09-23: During the initial connection it is
2698 assumed that the target is already ready and able to respond to
2699 requests. Unfortunately remote_start_remote() eventually calls
2700 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2701 around this. Eventually a mechanism that allows
2702 wait_for_inferior() to expect/get timeouts will be
2704 wait_forever_enabled_p
= 0;
2707 /* First delete any symbols previously loaded from shared libraries. */
2708 no_shared_libraries (NULL
, 0);
2710 /* Start the remote connection. If error() or QUIT, discard this
2711 target (we'd otherwise be in an inconsistent state) and then
2712 propogate the error on up the exception chain. This ensures that
2713 the caller doesn't stumble along blindly assuming that the
2714 function succeeded. The CLI doesn't have this problem but other
2715 UI's, such as MI do.
2717 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2718 this function should return an error indication letting the
2719 caller restore the previous state. Unfortunately the command
2720 ``target remote'' is directly wired to this function making that
2721 impossible. On a positive note, the CLI side of this problem has
2722 been fixed - the function set_cmd_context() makes it possible for
2723 all the ``target ....'' commands to share a common callback
2724 function. See cli-dump.c. */
2726 struct gdb_exception ex
;
2727 struct start_remote_args args
;
2729 args
.from_tty
= from_tty
;
2730 args
.target
= target
;
2731 args
.extended_p
= extended_p
;
2733 ex
= catch_exception (uiout
, remote_start_remote
, &args
, RETURN_MASK_ALL
);
2738 wait_forever_enabled_p
= 1;
2739 throw_exception (ex
);
2744 wait_forever_enabled_p
= 1;
2748 /* Tell the remote that we are using the extended protocol. */
2750 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2753 /* If we connected to a live target, do some additional setup. */
2754 if (target_has_execution
)
2756 if (exec_bfd
) /* No use without an exec file. */
2757 remote_check_symbols (symfile_objfile
);
2761 /* This takes a program previously attached to and detaches it. After
2762 this is done, GDB can be used to debug some other program. We
2763 better not have left any breakpoints in the target program or it'll
2764 die when it hits one. */
2767 remote_detach_1 (char *args
, int from_tty
, int extended
)
2769 struct remote_state
*rs
= get_remote_state ();
2772 error (_("Argument given to \"detach\" when remotely debugging."));
2774 if (!target_has_execution
)
2775 error (_("No process to detach from."));
2777 /* Tell the remote target to detach. */
2778 strcpy (rs
->buf
, "D");
2780 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2782 if (rs
->buf
[0] == 'E')
2783 error (_("Can't detach process."));
2785 /* Unregister the file descriptor from the event loop. */
2786 if (target_is_async_p ())
2787 serial_async (remote_desc
, NULL
, 0);
2789 target_mourn_inferior ();
2793 puts_filtered ("Detached from remote process.\n");
2795 puts_filtered ("Ending remote debugging.\n");
2800 remote_detach (char *args
, int from_tty
)
2802 remote_detach_1 (args
, from_tty
, 0);
2806 extended_remote_detach (char *args
, int from_tty
)
2808 remote_detach_1 (args
, from_tty
, 1);
2811 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2814 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2817 error (_("Argument given to \"disconnect\" when remotely debugging."));
2819 /* Unregister the file descriptor from the event loop. */
2820 if (target_is_async_p ())
2821 serial_async (remote_desc
, NULL
, 0);
2823 /* Make sure we unpush even the extended remote targets; mourn
2824 won't do it. So call remote_mourn_1 directly instead of
2825 target_mourn_inferior. */
2826 remote_mourn_1 (target
);
2829 puts_filtered ("Ending remote debugging.\n");
2832 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
2833 be chatty about it. */
2836 extended_remote_attach_1 (struct target_ops
*target
, char *args
, int from_tty
)
2838 struct remote_state
*rs
= get_remote_state ();
2843 error_no_arg (_("process-id to attach"));
2846 pid
= strtol (args
, &dummy
, 0);
2847 /* Some targets don't set errno on errors, grrr! */
2848 if (pid
== 0 && args
== dummy
)
2849 error (_("Illegal process-id: %s."), args
);
2851 if (remote_protocol_packets
[PACKET_vAttach
].support
== PACKET_DISABLE
)
2852 error (_("This target does not support attaching to a process"));
2854 sprintf (rs
->buf
, "vAttach;%x", pid
);
2856 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2858 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vAttach
]) == PACKET_OK
)
2861 printf_unfiltered (_("Attached to %s\n"),
2862 target_pid_to_str (pid_to_ptid (pid
)));
2864 /* We have a wait response; reuse it. */
2865 rs
->cached_wait_status
= 1;
2867 else if (remote_protocol_packets
[PACKET_vAttach
].support
== PACKET_DISABLE
)
2868 error (_("This target does not support attaching to a process"));
2870 error (_("Attaching to %s failed"),
2871 target_pid_to_str (pid_to_ptid (pid
)));
2873 target_mark_running (target
);
2874 inferior_ptid
= pid_to_ptid (pid
);
2879 extended_remote_attach (char *args
, int from_tty
)
2881 extended_remote_attach_1 (&extended_remote_ops
, args
, from_tty
);
2885 extended_async_remote_attach (char *args
, int from_tty
)
2887 extended_remote_attach_1 (&extended_async_remote_ops
, args
, from_tty
);
2890 /* Convert hex digit A to a number. */
2895 if (a
>= '0' && a
<= '9')
2897 else if (a
>= 'a' && a
<= 'f')
2898 return a
- 'a' + 10;
2899 else if (a
>= 'A' && a
<= 'F')
2900 return a
- 'A' + 10;
2902 error (_("Reply contains invalid hex digit %d"), a
);
2906 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2910 for (i
= 0; i
< count
; i
++)
2912 if (hex
[0] == 0 || hex
[1] == 0)
2914 /* Hex string is short, or of uneven length.
2915 Return the count that has been converted so far. */
2918 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2924 /* Convert number NIB to a hex digit. */
2932 return 'a' + nib
- 10;
2936 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2939 /* May use a length, or a nul-terminated string as input. */
2941 count
= strlen ((char *) bin
);
2943 for (i
= 0; i
< count
; i
++)
2945 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2946 *hex
++ = tohex (*bin
++ & 0xf);
2952 /* Check for the availability of vCont. This function should also check
2956 remote_vcont_probe (struct remote_state
*rs
)
2960 strcpy (rs
->buf
, "vCont?");
2962 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2965 /* Make sure that the features we assume are supported. */
2966 if (strncmp (buf
, "vCont", 5) == 0)
2969 int support_s
, support_S
, support_c
, support_C
;
2975 while (p
&& *p
== ';')
2978 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2980 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2982 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2984 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2987 p
= strchr (p
, ';');
2990 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2991 BUF will make packet_ok disable the packet. */
2992 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2996 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2999 /* Resume the remote inferior by using a "vCont" packet. The thread
3000 to be resumed is PTID; STEP and SIGGNAL indicate whether the
3001 resumed thread should be single-stepped and/or signalled. If PTID's
3002 PID is -1, then all threads are resumed; the thread to be stepped and/or
3003 signalled is given in the global INFERIOR_PTID. This function returns
3004 non-zero iff it resumes the inferior.
3006 This function issues a strict subset of all possible vCont commands at the
3010 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
3012 struct remote_state
*rs
= get_remote_state ();
3013 int pid
= PIDGET (ptid
);
3015 struct cleanup
*old_cleanup
;
3017 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
3018 remote_vcont_probe (rs
);
3020 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
3023 /* If we could generate a wider range of packets, we'd have to worry
3024 about overflowing BUF. Should there be a generic
3025 "multi-part-packet" packet? */
3027 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
3029 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
3030 don't have any PID numbers the inferior will understand. Make sure
3031 to only send forms that do not specify a PID. */
3032 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
3033 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
3035 outbuf
= xstrprintf ("vCont;s");
3036 else if (siggnal
!= TARGET_SIGNAL_0
)
3037 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
3039 outbuf
= xstrprintf ("vCont;c");
3043 /* Resume all threads, with preference for INFERIOR_PTID. */
3044 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
3045 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
3046 PIDGET (inferior_ptid
));
3048 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
3049 else if (siggnal
!= TARGET_SIGNAL_0
)
3050 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
3051 PIDGET (inferior_ptid
));
3053 outbuf
= xstrprintf ("vCont;c");
3057 /* Scheduler locking; resume only PTID. */
3058 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
3059 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
3061 outbuf
= xstrprintf ("vCont;s:%x", pid
);
3062 else if (siggnal
!= TARGET_SIGNAL_0
)
3063 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
3065 outbuf
= xstrprintf ("vCont;c:%x", pid
);
3068 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
3069 old_cleanup
= make_cleanup (xfree
, outbuf
);
3073 do_cleanups (old_cleanup
);
3078 /* Tell the remote machine to resume. */
3080 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
3082 static int last_sent_step
;
3085 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
3087 struct remote_state
*rs
= get_remote_state ();
3089 int pid
= PIDGET (ptid
);
3091 last_sent_signal
= siggnal
;
3092 last_sent_step
= step
;
3094 /* Update the inferior on signals to silently pass, if they've changed. */
3095 remote_pass_signals ();
3097 /* The vCont packet doesn't need to specify threads via Hc. */
3098 if (remote_vcont_resume (ptid
, step
, siggnal
))
3101 /* All other supported resume packets do use Hc, so call set_thread. */
3103 set_thread (0, 0); /* Run any thread. */
3105 set_thread (pid
, 0); /* Run this thread. */
3108 if (siggnal
!= TARGET_SIGNAL_0
)
3110 buf
[0] = step
? 'S' : 'C';
3111 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
3112 buf
[2] = tohex (((int) siggnal
) & 0xf);
3116 strcpy (buf
, step
? "s" : "c");
3121 /* Same as remote_resume, but with async support. */
3123 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
3125 remote_resume (ptid
, step
, siggnal
);
3127 /* We are about to start executing the inferior, let's register it
3128 with the event loop. NOTE: this is the one place where all the
3129 execution commands end up. We could alternatively do this in each
3130 of the execution commands in infcmd.c. */
3131 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
3132 into infcmd.c in order to allow inferior function calls to work
3133 NOT asynchronously. */
3134 if (target_can_async_p ())
3135 target_async (inferior_event_handler
, 0);
3136 /* Tell the world that the target is now executing. */
3137 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
3138 this? Instead, should the client of target just assume (for
3139 async targets) that the target is going to start executing? Is
3140 this information already found in the continuation block? */
3141 if (target_is_async_p ())
3142 target_executing
= 1;
3146 /* Set up the signal handler for SIGINT, while the target is
3147 executing, ovewriting the 'regular' SIGINT signal handler. */
3149 initialize_sigint_signal_handler (void)
3151 signal (SIGINT
, handle_remote_sigint
);
3154 /* Signal handler for SIGINT, while the target is executing. */
3156 handle_remote_sigint (int sig
)
3158 signal (sig
, handle_remote_sigint_twice
);
3159 mark_async_signal_handler_wrapper (sigint_remote_token
);
3162 /* Signal handler for SIGINT, installed after SIGINT has already been
3163 sent once. It will take effect the second time that the user sends
3166 handle_remote_sigint_twice (int sig
)
3168 signal (sig
, handle_remote_sigint
);
3169 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
3172 /* Perform the real interruption of the target execution, in response
3175 async_remote_interrupt (gdb_client_data arg
)
3178 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3183 /* Perform interrupt, if the first attempt did not succeed. Just give
3184 up on the target alltogether. */
3186 async_remote_interrupt_twice (gdb_client_data arg
)
3189 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
3194 /* Reinstall the usual SIGINT handlers, after the target has
3197 cleanup_sigint_signal_handler (void *dummy
)
3199 signal (SIGINT
, handle_sigint
);
3202 /* Send ^C to target to halt it. Target will respond, and send us a
3204 static void (*ofunc
) (int);
3206 /* The command line interface's stop routine. This function is installed
3207 as a signal handler for SIGINT. The first time a user requests a
3208 stop, we call remote_stop to send a break or ^C. If there is no
3209 response from the target (it didn't stop when the user requested it),
3210 we ask the user if he'd like to detach from the target. */
3212 remote_interrupt (int signo
)
3214 /* If this doesn't work, try more severe steps. */
3215 signal (signo
, remote_interrupt_twice
);
3217 gdb_call_async_signal_handler (sigint_remote_token
, 1);
3220 /* The user typed ^C twice. */
3223 remote_interrupt_twice (int signo
)
3225 signal (signo
, ofunc
);
3226 gdb_call_async_signal_handler (sigint_remote_twice_token
, 1);
3227 signal (signo
, remote_interrupt
);
3230 /* This is the generic stop called via the target vector. When a target
3231 interrupt is requested, either by the command line or the GUI, we
3232 will eventually end up here. */
3236 /* Send a break or a ^C, depending on user preference. */
3238 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
3241 serial_send_break (remote_desc
);
3243 serial_write (remote_desc
, "\003", 1);
3246 /* Ask the user what to do when an interrupt is received. */
3249 interrupt_query (void)
3251 target_terminal_ours ();
3253 if (query ("Interrupted while waiting for the program.\n\
3254 Give up (and stop debugging it)? "))
3256 target_mourn_inferior ();
3257 signal (SIGINT
, handle_sigint
);
3258 deprecated_throw_reason (RETURN_QUIT
);
3261 target_terminal_inferior ();
3264 /* Enable/disable target terminal ownership. Most targets can use
3265 terminal groups to control terminal ownership. Remote targets are
3266 different in that explicit transfer of ownership to/from GDB/target
3270 remote_async_terminal_inferior (void)
3272 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3273 sync_execution here. This function should only be called when
3274 GDB is resuming the inferior in the forground. A background
3275 resume (``run&'') should leave GDB in control of the terminal and
3276 consequently should not call this code. */
3277 if (!sync_execution
)
3279 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3280 calls target_terminal_*() idenpotent. The event-loop GDB talking
3281 to an asynchronous target with a synchronous command calls this
3282 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3283 stops trying to transfer the terminal to the target when it
3284 shouldn't this guard can go away. */
3285 if (!remote_async_terminal_ours_p
)
3287 delete_file_handler (input_fd
);
3288 remote_async_terminal_ours_p
= 0;
3289 initialize_sigint_signal_handler ();
3290 /* NOTE: At this point we could also register our selves as the
3291 recipient of all input. Any characters typed could then be
3292 passed on down to the target. */
3296 remote_async_terminal_ours (void)
3298 /* See FIXME in remote_async_terminal_inferior. */
3299 if (!sync_execution
)
3301 /* See FIXME in remote_async_terminal_inferior. */
3302 if (remote_async_terminal_ours_p
)
3304 cleanup_sigint_signal_handler (NULL
);
3305 add_file_handler (input_fd
, stdin_event_handler
, 0);
3306 remote_async_terminal_ours_p
= 1;
3309 /* If nonzero, ignore the next kill. */
3314 remote_console_output (char *msg
)
3318 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3321 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3324 fputs_unfiltered (tb
, gdb_stdtarg
);
3326 gdb_flush (gdb_stdtarg
);
3329 /* Wait until the remote machine stops, then return,
3330 storing status in STATUS just as `wait' would.
3331 Returns "pid", which in the case of a multi-threaded
3332 remote OS, is the thread-id. */
3335 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3337 struct remote_state
*rs
= get_remote_state ();
3338 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3339 ULONGEST thread_num
= -1;
3341 int solibs_changed
= 0;
3343 status
->kind
= TARGET_WAITKIND_EXITED
;
3344 status
->value
.integer
= 0;
3350 if (rs
->cached_wait_status
)
3351 /* Use the cached wait status, but only once. */
3352 rs
->cached_wait_status
= 0;
3355 ofunc
= signal (SIGINT
, remote_interrupt
);
3356 /* If the user hit C-c before this packet, or between packets,
3357 pretend that it was hit right here. */
3361 remote_interrupt (SIGINT
);
3363 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3364 signal (SIGINT
, ofunc
);
3369 remote_stopped_by_watchpoint_p
= 0;
3373 case 'E': /* Error of some sort. */
3374 /* We're out of sync with the target now. Did it continue or not?
3375 Not is more likely, so report a stop. */
3376 warning (_("Remote failure reply: %s"), buf
);
3377 status
->kind
= TARGET_WAITKIND_STOPPED
;
3378 status
->value
.sig
= TARGET_SIGNAL_0
;
3380 case 'F': /* File-I/O request. */
3381 remote_fileio_request (buf
);
3383 case 'T': /* Status with PC, SP, FP, ... */
3385 gdb_byte regs
[MAX_REGISTER_SIZE
];
3387 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3388 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3390 n... = register number
3391 r... = register contents
3393 p
= &buf
[3]; /* after Txx */
3402 /* If the packet contains a register number save it in
3403 pnum and set p1 to point to the character following
3404 it. Otherwise p1 points to p. */
3406 /* If this packet is an awatch packet, don't parse the
3407 'a' as a register number. */
3409 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3411 /* Read the ``P'' register number. */
3412 pnum
= strtol (p
, &p_temp
, 16);
3418 if (p1
== p
) /* No register number present here. */
3420 p1
= strchr (p
, ':');
3422 error (_("Malformed packet(a) (missing colon): %s\n\
3425 if (strncmp (p
, "thread", p1
- p
) == 0)
3427 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3428 record_currthread (thread_num
);
3431 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3432 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3433 || (strncmp (p
, "awatch", p1
- p
) == 0))
3435 remote_stopped_by_watchpoint_p
= 1;
3436 p
= unpack_varlen_hex (++p1
, &addr
);
3437 remote_watch_data_address
= (CORE_ADDR
)addr
;
3439 else if (strncmp (p
, "library", p1
- p
) == 0)
3443 while (*p_temp
&& *p_temp
!= ';')
3451 /* Silently skip unknown optional info. */
3452 p_temp
= strchr (p1
+ 1, ';');
3459 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3463 error (_("Malformed packet(b) (missing colon): %s\n\
3468 error (_("Remote sent bad register number %s: %s\n\
3470 phex_nz (pnum
, 0), p
, buf
);
3472 fieldsize
= hex2bin (p
, regs
,
3473 register_size (current_gdbarch
,
3476 if (fieldsize
< register_size (current_gdbarch
,
3478 warning (_("Remote reply is too short: %s"), buf
);
3479 regcache_raw_supply (get_current_regcache (),
3484 error (_("Remote register badly formatted: %s\nhere: %s"),
3489 case 'S': /* Old style status, just signal only. */
3491 status
->kind
= TARGET_WAITKIND_LOADED
;
3494 status
->kind
= TARGET_WAITKIND_STOPPED
;
3495 status
->value
.sig
= (enum target_signal
)
3496 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3501 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3502 record_currthread (thread_num
);
3505 case 'W': /* Target exited. */
3507 /* The remote process exited. */
3508 status
->kind
= TARGET_WAITKIND_EXITED
;
3509 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3513 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3514 status
->value
.sig
= (enum target_signal
)
3515 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3519 case 'O': /* Console output. */
3520 remote_console_output (buf
+ 1);
3523 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3525 /* Zero length reply means that we tried 'S' or 'C' and
3526 the remote system doesn't support it. */
3527 target_terminal_ours_for_output ();
3529 ("Can't send signals to this remote system. %s not sent.\n",
3530 target_signal_to_name (last_sent_signal
));
3531 last_sent_signal
= TARGET_SIGNAL_0
;
3532 target_terminal_inferior ();
3534 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3535 putpkt ((char *) buf
);
3538 /* else fallthrough */
3540 warning (_("Invalid remote reply: %s"), buf
);
3545 if (thread_num
!= -1)
3547 return pid_to_ptid (thread_num
);
3549 return inferior_ptid
;
3552 /* Async version of remote_wait. */
3554 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3556 struct remote_state
*rs
= get_remote_state ();
3557 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3558 ULONGEST thread_num
= -1;
3560 int solibs_changed
= 0;
3562 status
->kind
= TARGET_WAITKIND_EXITED
;
3563 status
->value
.integer
= 0;
3565 remote_stopped_by_watchpoint_p
= 0;
3571 if (rs
->cached_wait_status
)
3572 /* Use the cached wait status, but only once. */
3573 rs
->cached_wait_status
= 0;
3576 if (!target_is_async_p ())
3578 ofunc
= signal (SIGINT
, remote_interrupt
);
3579 /* If the user hit C-c before this packet, or between packets,
3580 pretend that it was hit right here. */
3584 remote_interrupt (SIGINT
);
3587 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3588 _never_ wait for ever -> test on target_is_async_p().
3589 However, before we do that we need to ensure that the caller
3590 knows how to take the target into/out of async mode. */
3591 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3592 if (!target_is_async_p ())
3593 signal (SIGINT
, ofunc
);
3600 case 'E': /* Error of some sort. */
3601 /* We're out of sync with the target now. Did it continue or not?
3602 Not is more likely, so report a stop. */
3603 warning (_("Remote failure reply: %s"), buf
);
3604 status
->kind
= TARGET_WAITKIND_STOPPED
;
3605 status
->value
.sig
= TARGET_SIGNAL_0
;
3607 case 'F': /* File-I/O request. */
3608 remote_fileio_request (buf
);
3610 case 'T': /* Status with PC, SP, FP, ... */
3612 gdb_byte regs
[MAX_REGISTER_SIZE
];
3614 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3615 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3617 n... = register number
3618 r... = register contents
3620 p
= &buf
[3]; /* after Txx */
3629 /* If the packet contains a register number, save it
3630 in pnum and set p1 to point to the character
3631 following it. Otherwise p1 points to p. */
3633 /* If this packet is an awatch packet, don't parse the 'a'
3634 as a register number. */
3636 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3638 /* Read the register number. */
3639 pnum
= strtol (p
, &p_temp
, 16);
3645 if (p1
== p
) /* No register number present here. */
3647 p1
= strchr (p
, ':');
3649 error (_("Malformed packet(a) (missing colon): %s\n\
3652 if (strncmp (p
, "thread", p1
- p
) == 0)
3654 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3655 record_currthread (thread_num
);
3658 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3659 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3660 || (strncmp (p
, "awatch", p1
- p
) == 0))
3662 remote_stopped_by_watchpoint_p
= 1;
3663 p
= unpack_varlen_hex (++p1
, &addr
);
3664 remote_watch_data_address
= (CORE_ADDR
)addr
;
3666 else if (strncmp (p
, "library", p1
- p
) == 0)
3670 while (*p_temp
&& *p_temp
!= ';')
3678 /* Silently skip unknown optional info. */
3679 p_temp
= strchr (p1
+ 1, ';');
3687 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3690 error (_("Malformed packet(b) (missing colon): %s\n\
3695 error (_("Remote sent bad register number %ld: %s\n\
3699 fieldsize
= hex2bin (p
, regs
,
3700 register_size (current_gdbarch
,
3703 if (fieldsize
< register_size (current_gdbarch
,
3705 warning (_("Remote reply is too short: %s"), buf
);
3706 regcache_raw_supply (get_current_regcache (),
3711 error (_("Remote register badly formatted: %s\nhere: %s"),
3716 case 'S': /* Old style status, just signal only. */
3718 status
->kind
= TARGET_WAITKIND_LOADED
;
3721 status
->kind
= TARGET_WAITKIND_STOPPED
;
3722 status
->value
.sig
= (enum target_signal
)
3723 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3728 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3729 record_currthread (thread_num
);
3732 case 'W': /* Target exited. */
3734 /* The remote process exited. */
3735 status
->kind
= TARGET_WAITKIND_EXITED
;
3736 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3740 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3741 status
->value
.sig
= (enum target_signal
)
3742 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3746 case 'O': /* Console output. */
3747 remote_console_output (buf
+ 1);
3748 /* Return immediately to the event loop. The event loop will
3749 still be waiting on the inferior afterwards. */
3750 status
->kind
= TARGET_WAITKIND_IGNORE
;
3753 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3755 /* Zero length reply means that we tried 'S' or 'C' and
3756 the remote system doesn't support it. */
3757 target_terminal_ours_for_output ();
3759 ("Can't send signals to this remote system. %s not sent.\n",
3760 target_signal_to_name (last_sent_signal
));
3761 last_sent_signal
= TARGET_SIGNAL_0
;
3762 target_terminal_inferior ();
3764 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3765 putpkt ((char *) buf
);
3768 /* else fallthrough */
3770 warning (_("Invalid remote reply: %s"), buf
);
3775 if (thread_num
!= -1)
3777 return pid_to_ptid (thread_num
);
3779 return inferior_ptid
;
3782 /* Fetch a single register using a 'p' packet. */
3785 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3787 struct remote_state
*rs
= get_remote_state ();
3789 char regp
[MAX_REGISTER_SIZE
];
3792 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3795 if (reg
->pnum
== -1)
3800 p
+= hexnumstr (p
, reg
->pnum
);
3802 remote_send (&rs
->buf
, &rs
->buf_size
);
3806 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3810 case PACKET_UNKNOWN
:
3813 error (_("Could not fetch register \"%s\""),
3814 gdbarch_register_name (get_regcache_arch (regcache
), reg
->regnum
));
3817 /* If this register is unfetchable, tell the regcache. */
3820 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3824 /* Otherwise, parse and supply the value. */
3830 error (_("fetch_register_using_p: early buf termination"));
3832 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3835 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3839 /* Fetch the registers included in the target's 'g' packet. */
3842 send_g_packet (void)
3844 struct remote_state
*rs
= get_remote_state ();
3849 sprintf (rs
->buf
, "g");
3850 remote_send (&rs
->buf
, &rs
->buf_size
);
3852 /* We can get out of synch in various cases. If the first character
3853 in the buffer is not a hex character, assume that has happened
3854 and try to fetch another packet to read. */
3855 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3856 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3857 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3858 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3861 fprintf_unfiltered (gdb_stdlog
,
3862 "Bad register packet; fetching a new packet\n");
3863 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3866 buf_len
= strlen (rs
->buf
);
3868 /* Sanity check the received packet. */
3869 if (buf_len
% 2 != 0)
3870 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3876 process_g_packet (struct regcache
*regcache
)
3878 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3879 struct remote_state
*rs
= get_remote_state ();
3880 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3885 buf_len
= strlen (rs
->buf
);
3887 /* Further sanity checks, with knowledge of the architecture. */
3888 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3889 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3891 /* Save the size of the packet sent to us by the target. It is used
3892 as a heuristic when determining the max size of packets that the
3893 target can safely receive. */
3894 if (rsa
->actual_register_packet_size
== 0)
3895 rsa
->actual_register_packet_size
= buf_len
;
3897 /* If this is smaller than we guessed the 'g' packet would be,
3898 update our records. A 'g' reply that doesn't include a register's
3899 value implies either that the register is not available, or that
3900 the 'p' packet must be used. */
3901 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3903 rsa
->sizeof_g_packet
= buf_len
/ 2;
3905 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
3907 if (rsa
->regs
[i
].pnum
== -1)
3910 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3911 rsa
->regs
[i
].in_g_packet
= 0;
3913 rsa
->regs
[i
].in_g_packet
= 1;
3917 regs
= alloca (rsa
->sizeof_g_packet
);
3919 /* Unimplemented registers read as all bits zero. */
3920 memset (regs
, 0, rsa
->sizeof_g_packet
);
3922 /* Reply describes registers byte by byte, each byte encoded as two
3923 hex characters. Suck them all up, then supply them to the
3924 register cacheing/storage mechanism. */
3927 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3929 if (p
[0] == 0 || p
[1] == 0)
3930 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3931 internal_error (__FILE__
, __LINE__
,
3932 "unexpected end of 'g' packet reply");
3934 if (p
[0] == 'x' && p
[1] == 'x')
3935 regs
[i
] = 0; /* 'x' */
3937 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3943 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
3945 struct packet_reg
*r
= &rsa
->regs
[i
];
3948 if (r
->offset
* 2 >= strlen (rs
->buf
))
3949 /* This shouldn't happen - we adjusted in_g_packet above. */
3950 internal_error (__FILE__
, __LINE__
,
3951 "unexpected end of 'g' packet reply");
3952 else if (rs
->buf
[r
->offset
* 2] == 'x')
3954 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3955 /* The register isn't available, mark it as such (at
3956 the same time setting the value to zero). */
3957 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3960 regcache_raw_supply (regcache
, r
->regnum
,
3968 fetch_registers_using_g (struct regcache
*regcache
)
3971 process_g_packet (regcache
);
3975 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3977 struct remote_state
*rs
= get_remote_state ();
3978 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3981 set_thread (PIDGET (inferior_ptid
), 1);
3985 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3986 gdb_assert (reg
!= NULL
);
3988 /* If this register might be in the 'g' packet, try that first -
3989 we are likely to read more than one register. If this is the
3990 first 'g' packet, we might be overly optimistic about its
3991 contents, so fall back to 'p'. */
3992 if (reg
->in_g_packet
)
3994 fetch_registers_using_g (regcache
);
3995 if (reg
->in_g_packet
)
3999 if (fetch_register_using_p (regcache
, reg
))
4002 /* This register is not available. */
4003 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
4008 fetch_registers_using_g (regcache
);
4010 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
4011 if (!rsa
->regs
[i
].in_g_packet
)
4012 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
4014 /* This register is not available. */
4015 regcache_raw_supply (regcache
, i
, NULL
);
4019 /* Prepare to store registers. Since we may send them all (using a
4020 'G' request), we have to read out the ones we don't want to change
4024 remote_prepare_to_store (struct regcache
*regcache
)
4026 struct remote_arch_state
*rsa
= get_remote_arch_state ();
4028 gdb_byte buf
[MAX_REGISTER_SIZE
];
4030 /* Make sure the entire registers array is valid. */
4031 switch (remote_protocol_packets
[PACKET_P
].support
)
4033 case PACKET_DISABLE
:
4034 case PACKET_SUPPORT_UNKNOWN
:
4035 /* Make sure all the necessary registers are cached. */
4036 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
4037 if (rsa
->regs
[i
].in_g_packet
)
4038 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
4045 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
4046 packet was not recognized. */
4049 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
4051 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4052 struct remote_state
*rs
= get_remote_state ();
4053 struct remote_arch_state
*rsa
= get_remote_arch_state ();
4054 /* Try storing a single register. */
4055 char *buf
= rs
->buf
;
4056 gdb_byte regp
[MAX_REGISTER_SIZE
];
4059 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
4062 if (reg
->pnum
== -1)
4065 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
4066 p
= buf
+ strlen (buf
);
4067 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
4068 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
4069 remote_send (&rs
->buf
, &rs
->buf_size
);
4071 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
4076 error (_("Could not write register \"%s\""),
4077 gdbarch_register_name (gdbarch
, reg
->regnum
));
4078 case PACKET_UNKNOWN
:
4081 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
4085 /* Store register REGNUM, or all registers if REGNUM == -1, from the
4086 contents of the register cache buffer. FIXME: ignores errors. */
4089 store_registers_using_G (const struct regcache
*regcache
)
4091 struct remote_state
*rs
= get_remote_state ();
4092 struct remote_arch_state
*rsa
= get_remote_arch_state ();
4096 /* Extract all the registers in the regcache copying them into a
4100 regs
= alloca (rsa
->sizeof_g_packet
);
4101 memset (regs
, 0, rsa
->sizeof_g_packet
);
4102 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
4104 struct packet_reg
*r
= &rsa
->regs
[i
];
4106 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
4110 /* Command describes registers byte by byte,
4111 each byte encoded as two hex characters. */
4114 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
4116 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
4117 remote_send (&rs
->buf
, &rs
->buf_size
);
4120 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
4121 of the register cache buffer. FIXME: ignores errors. */
4124 remote_store_registers (struct regcache
*regcache
, int regnum
)
4126 struct remote_state
*rs
= get_remote_state ();
4127 struct remote_arch_state
*rsa
= get_remote_arch_state ();
4130 set_thread (PIDGET (inferior_ptid
), 1);
4134 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
4135 gdb_assert (reg
!= NULL
);
4137 /* Always prefer to store registers using the 'P' packet if
4138 possible; we often change only a small number of registers.
4139 Sometimes we change a larger number; we'd need help from a
4140 higher layer to know to use 'G'. */
4141 if (store_register_using_P (regcache
, reg
))
4144 /* For now, don't complain if we have no way to write the
4145 register. GDB loses track of unavailable registers too
4146 easily. Some day, this may be an error. We don't have
4147 any way to read the register, either... */
4148 if (!reg
->in_g_packet
)
4151 store_registers_using_G (regcache
);
4155 store_registers_using_G (regcache
);
4157 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
4158 if (!rsa
->regs
[i
].in_g_packet
)
4159 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
4160 /* See above for why we do not issue an error here. */
4165 /* Return the number of hex digits in num. */
4168 hexnumlen (ULONGEST num
)
4172 for (i
= 0; num
!= 0; i
++)
4178 /* Set BUF to the minimum number of hex digits representing NUM. */
4181 hexnumstr (char *buf
, ULONGEST num
)
4183 int len
= hexnumlen (num
);
4184 return hexnumnstr (buf
, num
, len
);
4188 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
4191 hexnumnstr (char *buf
, ULONGEST num
, int width
)
4197 for (i
= width
- 1; i
>= 0; i
--)
4199 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
4206 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
4209 remote_address_masked (CORE_ADDR addr
)
4211 int address_size
= remote_address_size
;
4212 /* If "remoteaddresssize" was not set, default to target address size. */
4214 address_size
= gdbarch_addr_bit (current_gdbarch
);
4216 if (address_size
> 0
4217 && address_size
< (sizeof (ULONGEST
) * 8))
4219 /* Only create a mask when that mask can safely be constructed
4220 in a ULONGEST variable. */
4222 mask
= (mask
<< address_size
) - 1;
4228 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
4229 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
4230 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
4231 (which may be more than *OUT_LEN due to escape characters). The
4232 total number of bytes in the output buffer will be at most
4236 remote_escape_output (const gdb_byte
*buffer
, int len
,
4237 gdb_byte
*out_buf
, int *out_len
,
4240 int input_index
, output_index
;
4243 for (input_index
= 0; input_index
< len
; input_index
++)
4245 gdb_byte b
= buffer
[input_index
];
4247 if (b
== '$' || b
== '#' || b
== '}')
4249 /* These must be escaped. */
4250 if (output_index
+ 2 > out_maxlen
)
4252 out_buf
[output_index
++] = '}';
4253 out_buf
[output_index
++] = b
^ 0x20;
4257 if (output_index
+ 1 > out_maxlen
)
4259 out_buf
[output_index
++] = b
;
4263 *out_len
= input_index
;
4264 return output_index
;
4267 /* Convert BUFFER, escaped data LEN bytes long, into binary data
4268 in OUT_BUF. Return the number of bytes written to OUT_BUF.
4269 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
4271 This function reverses remote_escape_output. It allows more
4272 escaped characters than that function does, in particular because
4273 '*' must be escaped to avoid the run-length encoding processing
4274 in reading packets. */
4277 remote_unescape_input (const gdb_byte
*buffer
, int len
,
4278 gdb_byte
*out_buf
, int out_maxlen
)
4280 int input_index
, output_index
;
4285 for (input_index
= 0; input_index
< len
; input_index
++)
4287 gdb_byte b
= buffer
[input_index
];
4289 if (output_index
+ 1 > out_maxlen
)
4291 warning (_("Received too much data from remote target;"
4292 " ignoring overflow."));
4293 return output_index
;
4298 out_buf
[output_index
++] = b
^ 0x20;
4304 out_buf
[output_index
++] = b
;
4308 error (_("Unmatched escape character in target response."));
4310 return output_index
;
4313 /* Determine whether the remote target supports binary downloading.
4314 This is accomplished by sending a no-op memory write of zero length
4315 to the target at the specified address. It does not suffice to send
4316 the whole packet, since many stubs strip the eighth bit and
4317 subsequently compute a wrong checksum, which causes real havoc with
4320 NOTE: This can still lose if the serial line is not eight-bit
4321 clean. In cases like this, the user should clear "remote
4325 check_binary_download (CORE_ADDR addr
)
4327 struct remote_state
*rs
= get_remote_state ();
4329 switch (remote_protocol_packets
[PACKET_X
].support
)
4331 case PACKET_DISABLE
:
4335 case PACKET_SUPPORT_UNKNOWN
:
4341 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4343 p
+= hexnumstr (p
, (ULONGEST
) 0);
4347 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4348 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4350 if (rs
->buf
[0] == '\0')
4353 fprintf_unfiltered (gdb_stdlog
,
4354 "binary downloading NOT suppported by target\n");
4355 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4360 fprintf_unfiltered (gdb_stdlog
,
4361 "binary downloading suppported by target\n");
4362 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4369 /* Write memory data directly to the remote machine.
4370 This does not inform the data cache; the data cache uses this.
4371 HEADER is the starting part of the packet.
4372 MEMADDR is the address in the remote memory space.
4373 MYADDR is the address of the buffer in our space.
4374 LEN is the number of bytes.
4375 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4376 should send data as binary ('X'), or hex-encoded ('M').
4378 The function creates packet of the form
4379 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4381 where encoding of <DATA> is termined by PACKET_FORMAT.
4383 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4386 Returns the number of bytes transferred, or 0 (setting errno) for
4387 error. Only transfer a single packet. */
4390 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4391 const gdb_byte
*myaddr
, int len
,
4392 char packet_format
, int use_length
)
4394 struct remote_state
*rs
= get_remote_state ();
4404 if (packet_format
!= 'X' && packet_format
!= 'M')
4405 internal_error (__FILE__
, __LINE__
,
4406 "remote_write_bytes_aux: bad packet format");
4411 payload_size
= get_memory_write_packet_size ();
4413 /* The packet buffer will be large enough for the payload;
4414 get_memory_packet_size ensures this. */
4417 /* Compute the size of the actual payload by subtracting out the
4418 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4420 payload_size
-= strlen ("$,:#NN");
4422 /* The comma won't be used. */
4424 header_length
= strlen (header
);
4425 payload_size
-= header_length
;
4426 payload_size
-= hexnumlen (memaddr
);
4428 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4430 strcat (rs
->buf
, header
);
4431 p
= rs
->buf
+ strlen (header
);
4433 /* Compute a best guess of the number of bytes actually transfered. */
4434 if (packet_format
== 'X')
4436 /* Best guess at number of bytes that will fit. */
4437 todo
= min (len
, payload_size
);
4439 payload_size
-= hexnumlen (todo
);
4440 todo
= min (todo
, payload_size
);
4444 /* Num bytes that will fit. */
4445 todo
= min (len
, payload_size
/ 2);
4447 payload_size
-= hexnumlen (todo
);
4448 todo
= min (todo
, payload_size
/ 2);
4452 internal_error (__FILE__
, __LINE__
,
4453 _("minumum packet size too small to write data"));
4455 /* If we already need another packet, then try to align the end
4456 of this packet to a useful boundary. */
4457 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4458 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4460 /* Append "<memaddr>". */
4461 memaddr
= remote_address_masked (memaddr
);
4462 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4469 /* Append <len>. Retain the location/size of <len>. It may need to
4470 be adjusted once the packet body has been created. */
4472 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4480 /* Append the packet body. */
4481 if (packet_format
== 'X')
4483 /* Binary mode. Send target system values byte by byte, in
4484 increasing byte addresses. Only escape certain critical
4486 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4489 /* If not all TODO bytes fit, then we'll need another packet. Make
4490 a second try to keep the end of the packet aligned. Don't do
4491 this if the packet is tiny. */
4492 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4496 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4498 if (new_nr_bytes
!= nr_bytes
)
4499 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4504 p
+= payload_length
;
4505 if (use_length
&& nr_bytes
< todo
)
4507 /* Escape chars have filled up the buffer prematurely,
4508 and we have actually sent fewer bytes than planned.
4509 Fix-up the length field of the packet. Use the same
4510 number of characters as before. */
4511 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4512 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4517 /* Normal mode: Send target system values byte by byte, in
4518 increasing byte addresses. Each byte is encoded as a two hex
4520 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4524 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4525 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4527 if (rs
->buf
[0] == 'E')
4529 /* There is no correspondance between what the remote protocol
4530 uses for errors and errno codes. We would like a cleaner way
4531 of representing errors (big enough to include errno codes,
4532 bfd_error codes, and others). But for now just return EIO. */
4537 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4538 fewer bytes than we'd planned. */
4542 /* Write memory data directly to the remote machine.
4543 This does not inform the data cache; the data cache uses this.
4544 MEMADDR is the address in the remote memory space.
4545 MYADDR is the address of the buffer in our space.
4546 LEN is the number of bytes.
4548 Returns number of bytes transferred, or 0 (setting errno) for
4549 error. Only transfer a single packet. */
4552 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4554 char *packet_format
= 0;
4556 /* Check whether the target supports binary download. */
4557 check_binary_download (memaddr
);
4559 switch (remote_protocol_packets
[PACKET_X
].support
)
4562 packet_format
= "X";
4564 case PACKET_DISABLE
:
4565 packet_format
= "M";
4567 case PACKET_SUPPORT_UNKNOWN
:
4568 internal_error (__FILE__
, __LINE__
,
4569 _("remote_write_bytes: bad internal state"));
4571 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4574 return remote_write_bytes_aux (packet_format
,
4575 memaddr
, myaddr
, len
, packet_format
[0], 1);
4578 /* Read memory data directly from the remote machine.
4579 This does not use the data cache; the data cache uses this.
4580 MEMADDR is the address in the remote memory space.
4581 MYADDR is the address of the buffer in our space.
4582 LEN is the number of bytes.
4584 Returns number of bytes transferred, or 0 for error. */
4586 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4587 remote targets) shouldn't attempt to read the entire buffer.
4588 Instead it should read a single packet worth of data and then
4589 return the byte size of that packet to the caller. The caller (its
4590 caller and its callers caller ;-) already contains code for
4591 handling partial reads. */
4594 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4596 struct remote_state
*rs
= get_remote_state ();
4597 int max_buf_size
; /* Max size of packet output buffer. */
4603 max_buf_size
= get_memory_read_packet_size ();
4604 /* The packet buffer will be large enough for the payload;
4605 get_memory_packet_size ensures this. */
4614 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4616 /* construct "m"<memaddr>","<len>" */
4617 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4618 memaddr
= remote_address_masked (memaddr
);
4621 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4623 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4627 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4629 if (rs
->buf
[0] == 'E'
4630 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4631 && rs
->buf
[3] == '\0')
4633 /* There is no correspondance between what the remote
4634 protocol uses for errors and errno codes. We would like
4635 a cleaner way of representing errors (big enough to
4636 include errno codes, bfd_error codes, and others). But
4637 for now just return EIO. */
4642 /* Reply describes memory byte by byte,
4643 each byte encoded as two hex characters. */
4646 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4648 /* Reply is short. This means that we were able to read
4649 only part of what we wanted to. */
4650 return i
+ (origlen
- len
);
4659 /* Read or write LEN bytes from inferior memory at MEMADDR,
4660 transferring to or from debugger address BUFFER. Write to inferior
4661 if SHOULD_WRITE is nonzero. Returns length of data written or
4662 read; 0 for error. TARGET is unused. */
4665 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4666 int should_write
, struct mem_attrib
*attrib
,
4667 struct target_ops
*target
)
4672 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4674 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4679 /* Sends a packet with content determined by the printf format string
4680 FORMAT and the remaining arguments, then gets the reply. Returns
4681 whether the packet was a success, a failure, or unknown. */
4684 remote_send_printf (const char *format
, ...)
4686 struct remote_state
*rs
= get_remote_state ();
4687 int max_size
= get_remote_packet_size ();
4690 va_start (ap
, format
);
4693 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4694 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4696 if (putpkt (rs
->buf
) < 0)
4697 error (_("Communication problem with target."));
4700 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4702 return packet_check_result (rs
->buf
);
4706 restore_remote_timeout (void *p
)
4708 int value
= *(int *)p
;
4709 remote_timeout
= value
;
4712 /* Flash writing can take quite some time. We'll set
4713 effectively infinite timeout for flash operations.
4714 In future, we'll need to decide on a better approach. */
4715 static const int remote_flash_timeout
= 1000;
4718 remote_flash_erase (struct target_ops
*ops
,
4719 ULONGEST address
, LONGEST length
)
4721 int saved_remote_timeout
= remote_timeout
;
4722 enum packet_result ret
;
4724 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4725 &saved_remote_timeout
);
4726 remote_timeout
= remote_flash_timeout
;
4728 ret
= remote_send_printf ("vFlashErase:%s,%s",
4733 case PACKET_UNKNOWN
:
4734 error (_("Remote target does not support flash erase"));
4736 error (_("Error erasing flash with vFlashErase packet"));
4741 do_cleanups (back_to
);
4745 remote_flash_write (struct target_ops
*ops
,
4746 ULONGEST address
, LONGEST length
,
4747 const gdb_byte
*data
)
4749 int saved_remote_timeout
= remote_timeout
;
4751 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4752 &saved_remote_timeout
);
4754 remote_timeout
= remote_flash_timeout
;
4755 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4756 do_cleanups (back_to
);
4762 remote_flash_done (struct target_ops
*ops
)
4764 int saved_remote_timeout
= remote_timeout
;
4766 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4767 &saved_remote_timeout
);
4769 remote_timeout
= remote_flash_timeout
;
4770 ret
= remote_send_printf ("vFlashDone");
4771 do_cleanups (back_to
);
4775 case PACKET_UNKNOWN
:
4776 error (_("Remote target does not support vFlashDone"));
4778 error (_("Error finishing flash operation"));
4785 remote_files_info (struct target_ops
*ignore
)
4787 puts_filtered ("Debugging a target over a serial line.\n");
4790 /* Stuff for dealing with the packets which are part of this protocol.
4791 See comment at top of file for details. */
4793 /* Read a single character from the remote end. */
4796 readchar (int timeout
)
4800 ch
= serial_readchar (remote_desc
, timeout
);
4805 switch ((enum serial_rc
) ch
)
4808 target_mourn_inferior ();
4809 error (_("Remote connection closed"));
4812 perror_with_name (_("Remote communication error"));
4814 case SERIAL_TIMEOUT
:
4820 /* Send the command in *BUF to the remote machine, and read the reply
4821 into *BUF. Report an error if we get an error reply. Resize
4822 *BUF using xrealloc if necessary to hold the result, and update
4826 remote_send (char **buf
,
4830 getpkt (buf
, sizeof_buf
, 0);
4832 if ((*buf
)[0] == 'E')
4833 error (_("Remote failure reply: %s"), *buf
);
4836 /* Display a null-terminated packet on stdout, for debugging, using C
4840 print_packet (char *buf
)
4842 puts_filtered ("\"");
4843 fputstr_filtered (buf
, '"', gdb_stdout
);
4844 puts_filtered ("\"");
4850 return putpkt_binary (buf
, strlen (buf
));
4853 /* Send a packet to the remote machine, with error checking. The data
4854 of the packet is in BUF. The string in BUF can be at most
4855 get_remote_packet_size () - 5 to account for the $, # and checksum,
4856 and for a possible /0 if we are debugging (remote_debug) and want
4857 to print the sent packet as a string. */
4860 putpkt_binary (char *buf
, int cnt
)
4862 struct remote_state
*rs
= get_remote_state ();
4864 unsigned char csum
= 0;
4865 char *buf2
= alloca (cnt
+ 6);
4871 /* We're sending out a new packet. Make sure we don't look at a
4872 stale cached response. */
4873 rs
->cached_wait_status
= 0;
4875 /* Copy the packet into buffer BUF2, encapsulating it
4876 and giving it a checksum. */
4881 for (i
= 0; i
< cnt
; i
++)
4887 *p
++ = tohex ((csum
>> 4) & 0xf);
4888 *p
++ = tohex (csum
& 0xf);
4890 /* Send it over and over until we get a positive ack. */
4894 int started_error_output
= 0;
4899 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4900 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4901 fprintf_unfiltered (gdb_stdlog
, "...");
4902 gdb_flush (gdb_stdlog
);
4904 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4905 perror_with_name (_("putpkt: write failed"));
4907 /* Read until either a timeout occurs (-2) or '+' is read. */
4910 ch
= readchar (remote_timeout
);
4918 case SERIAL_TIMEOUT
:
4920 if (started_error_output
)
4922 putchar_unfiltered ('\n');
4923 started_error_output
= 0;
4932 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4936 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4937 case SERIAL_TIMEOUT
:
4941 break; /* Retransmit buffer. */
4945 fprintf_unfiltered (gdb_stdlog
,
4946 "Packet instead of Ack, ignoring it\n");
4947 /* It's probably an old response sent because an ACK
4948 was lost. Gobble up the packet and ack it so it
4949 doesn't get retransmitted when we resend this
4952 serial_write (remote_desc
, "+", 1);
4953 continue; /* Now, go look for +. */
4958 if (!started_error_output
)
4960 started_error_output
= 1;
4961 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4963 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4967 break; /* Here to retransmit. */
4971 /* This is wrong. If doing a long backtrace, the user should be
4972 able to get out next time we call QUIT, without anything as
4973 violent as interrupt_query. If we want to provide a way out of
4974 here without getting to the next QUIT, it should be based on
4975 hitting ^C twice as in remote_wait. */
4985 /* Come here after finding the start of a frame when we expected an
4986 ack. Do our best to discard the rest of this packet. */
4995 c
= readchar (remote_timeout
);
4998 case SERIAL_TIMEOUT
:
4999 /* Nothing we can do. */
5002 /* Discard the two bytes of checksum and stop. */
5003 c
= readchar (remote_timeout
);
5005 c
= readchar (remote_timeout
);
5008 case '*': /* Run length encoding. */
5009 /* Discard the repeat count. */
5010 c
= readchar (remote_timeout
);
5015 /* A regular character. */
5021 /* Come here after finding the start of the frame. Collect the rest
5022 into *BUF, verifying the checksum, length, and handling run-length
5023 compression. NUL terminate the buffer. If there is not enough room,
5024 expand *BUF using xrealloc.
5026 Returns -1 on error, number of characters in buffer (ignoring the
5027 trailing NULL) on success. (could be extended to return one of the
5028 SERIAL status indications). */
5031 read_frame (char **buf_p
,
5044 c
= readchar (remote_timeout
);
5047 case SERIAL_TIMEOUT
:
5049 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
5053 fputs_filtered ("Saw new packet start in middle of old one\n",
5055 return -1; /* Start a new packet, count retries. */
5058 unsigned char pktcsum
;
5064 check_0
= readchar (remote_timeout
);
5066 check_1
= readchar (remote_timeout
);
5068 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
5071 fputs_filtered ("Timeout in checksum, retrying\n",
5075 else if (check_0
< 0 || check_1
< 0)
5078 fputs_filtered ("Communication error in checksum\n",
5083 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
5084 if (csum
== pktcsum
)
5089 fprintf_filtered (gdb_stdlog
,
5090 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
5092 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
5093 fputs_filtered ("\n", gdb_stdlog
);
5095 /* Number of characters in buffer ignoring trailing
5099 case '*': /* Run length encoding. */
5104 c
= readchar (remote_timeout
);
5106 repeat
= c
- ' ' + 3; /* Compute repeat count. */
5108 /* The character before ``*'' is repeated. */
5110 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
5112 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
5114 /* Make some more room in the buffer. */
5115 *sizeof_buf
+= repeat
;
5116 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
5120 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
5126 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
5130 if (bc
>= *sizeof_buf
- 1)
5132 /* Make some more room in the buffer. */
5134 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
5145 /* Read a packet from the remote machine, with error checking, and
5146 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
5147 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
5148 rather than timing out; this is used (in synchronous mode) to wait
5149 for a target that is is executing user code to stop. */
5150 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
5151 don't have to change all the calls to getpkt to deal with the
5152 return value, because at the moment I don't know what the right
5153 thing to do it for those. */
5161 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
5165 /* Read a packet from the remote machine, with error checking, and
5166 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
5167 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
5168 rather than timing out; this is used (in synchronous mode) to wait
5169 for a target that is is executing user code to stop. If FOREVER ==
5170 0, this function is allowed to time out gracefully and return an
5171 indication of this to the caller. Otherwise return the number
5174 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
5176 struct remote_state
*rs
= get_remote_state ();
5182 /* We're reading a new response. Make sure we don't look at a
5183 previously cached response. */
5184 rs
->cached_wait_status
= 0;
5186 strcpy (*buf
, "timeout");
5190 timeout
= watchdog
> 0 ? watchdog
: -1;
5194 timeout
= remote_timeout
;
5198 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
5200 /* This can loop forever if the remote side sends us characters
5201 continuously, but if it pauses, we'll get a zero from
5202 readchar because of timeout. Then we'll count that as a
5205 /* Note that we will only wait forever prior to the start of a
5206 packet. After that, we expect characters to arrive at a
5207 brisk pace. They should show up within remote_timeout
5212 c
= readchar (timeout
);
5214 if (c
== SERIAL_TIMEOUT
)
5216 if (forever
) /* Watchdog went off? Kill the target. */
5219 target_mourn_inferior ();
5220 error (_("Watchdog timeout has expired. Target detached."));
5223 fputs_filtered ("Timed out.\n", gdb_stdlog
);
5229 /* We've found the start of a packet, now collect the data. */
5231 val
= read_frame (buf
, sizeof_buf
);
5237 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
5238 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
5239 fprintf_unfiltered (gdb_stdlog
, "\n");
5241 serial_write (remote_desc
, "+", 1);
5245 /* Try the whole thing again. */
5247 serial_write (remote_desc
, "-", 1);
5250 /* We have tried hard enough, and just can't receive the packet.
5253 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
5254 serial_write (remote_desc
, "+", 1);
5261 /* For some mysterious reason, wait_for_inferior calls kill instead of
5262 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5266 target_mourn_inferior ();
5270 /* Use catch_errors so the user can quit from gdb even when we aren't on
5271 speaking terms with the remote system. */
5272 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5274 /* Don't wait for it to die. I'm not really sure it matters whether
5275 we do or not. For the existing stubs, kill is a noop. */
5276 target_mourn_inferior ();
5279 /* Async version of remote_kill. */
5281 remote_async_kill (void)
5283 /* Unregister the file descriptor from the event loop. */
5284 if (target_is_async_p ())
5285 serial_async (remote_desc
, NULL
, 0);
5287 /* For some mysterious reason, wait_for_inferior calls kill instead of
5288 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5292 target_mourn_inferior ();
5296 /* Use catch_errors so the user can quit from gdb even when we
5297 aren't on speaking terms with the remote system. */
5298 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5300 /* Don't wait for it to die. I'm not really sure it matters whether
5301 we do or not. For the existing stubs, kill is a noop. */
5302 target_mourn_inferior ();
5308 remote_mourn_1 (&remote_ops
);
5312 remote_async_mourn (void)
5314 remote_mourn_1 (&remote_async_ops
);
5317 /* Worker function for remote_mourn. */
5319 remote_mourn_1 (struct target_ops
*target
)
5321 unpush_target (target
);
5322 generic_mourn_inferior ();
5326 extended_remote_mourn_1 (struct target_ops
*target
)
5328 struct remote_state
*rs
= get_remote_state ();
5330 /* Unlike "target remote", we do not want to unpush the target; then
5331 the next time the user says "run", we won't be connected. */
5333 /* Call common code to mark the inferior as not running. */
5334 generic_mourn_inferior ();
5336 /* Check whether the target is running now - some remote stubs
5337 automatically restart after kill. */
5339 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5341 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
5343 /* Assume that the target has been restarted. Set inferior_ptid
5344 so that bits of core GDB realizes there's something here, e.g.,
5345 so that the user can say "kill" again. */
5346 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
5350 /* Mark this (still pushed) target as not executable until we
5352 target_mark_exited (target
);
5357 extended_remote_mourn (void)
5359 extended_remote_mourn_1 (&extended_remote_ops
);
5363 extended_async_remote_mourn (void)
5365 extended_remote_mourn_1 (&extended_async_remote_ops
);
5369 extended_remote_run (char *args
)
5371 struct remote_state
*rs
= get_remote_state ();
5375 /* If the user has disabled vRun support, or we have detected that
5376 support is not available, do not try it. */
5377 if (remote_protocol_packets
[PACKET_vRun
].support
== PACKET_DISABLE
)
5380 strcpy (rs
->buf
, "vRun;");
5381 len
= strlen (rs
->buf
);
5383 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
5384 error (_("Remote file name too long for run packet"));
5385 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
, 0);
5389 struct cleanup
*back_to
;
5393 argv
= buildargv (args
);
5394 back_to
= make_cleanup ((void (*) (void *)) freeargv
, argv
);
5395 for (i
= 0; argv
[i
] != NULL
; i
++)
5397 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
5398 error (_("Argument list too long for run packet"));
5399 rs
->buf
[len
++] = ';';
5400 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
, 0);
5402 do_cleanups (back_to
);
5405 rs
->buf
[len
++] = '\0';
5408 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5410 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]) == PACKET_OK
)
5412 /* We have a wait response; we don't need it, though. All is well. */
5415 else if (remote_protocol_packets
[PACKET_vRun
].support
== PACKET_DISABLE
)
5416 /* It wasn't disabled before, but it is now. */
5420 if (remote_exec_file
[0] == '\0')
5421 error (_("Running the default executable on the remote target failed; "
5422 "try \"set remote exec-file\"?"));
5424 error (_("Running \"%s\" on the remote target failed"),
5429 /* In the extended protocol we want to be able to do things like
5430 "run" and have them basically work as expected. So we need
5431 a special create_inferior function. We support changing the
5432 executable file and the command line arguments, but not the
5436 extended_remote_create_inferior_1 (char *exec_file
, char *args
,
5437 char **env
, int from_tty
,
5440 /* If running asynchronously, register the target file descriptor
5441 with the event loop. */
5442 if (async_p
&& target_can_async_p ())
5443 target_async (inferior_event_handler
, 0);
5445 /* Now restart the remote server. */
5446 if (extended_remote_run (args
) == -1)
5448 /* vRun was not supported. Fail if we need it to do what the
5450 if (remote_exec_file
[0])
5451 error (_("Remote target does not support \"set remote exec-file\""));
5453 error (_("Remote target does not support \"set args\" or run <ARGS>"));
5455 /* Fall back to "R". */
5456 extended_remote_restart ();
5459 /* Now mark the inferior as running before we do anything else. */
5461 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
5463 target_mark_running (&extended_async_remote_ops
);
5465 target_mark_running (&extended_remote_ops
);
5467 /* Get updated offsets, if the stub uses qOffsets. */
5470 /* Clean up from the last time we were running. */
5471 init_thread_list ();
5472 init_wait_for_inferior ();
5476 extended_remote_create_inferior (char *exec_file
, char *args
,
5477 char **env
, int from_tty
)
5479 extended_remote_create_inferior_1 (exec_file
, args
, env
, from_tty
, 0);
5483 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5484 char **env
, int from_tty
)
5486 extended_remote_create_inferior_1 (exec_file
, args
, env
, from_tty
, 1);
5490 /* Insert a breakpoint. On targets that have software breakpoint
5491 support, we ask the remote target to do the work; on targets
5492 which don't, we insert a traditional memory breakpoint. */
5495 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5497 CORE_ADDR addr
= bp_tgt
->placed_address
;
5498 struct remote_state
*rs
= get_remote_state ();
5500 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5501 If it succeeds, then set the support to PACKET_ENABLE. If it
5502 fails, and the user has explicitly requested the Z support then
5503 report an error, otherwise, mark it disabled and go on. */
5505 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5512 gdbarch_breakpoint_from_pc
5513 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5514 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5515 p
+= hexnumstr (p
, addr
);
5516 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5519 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5521 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5527 case PACKET_UNKNOWN
:
5532 return memory_insert_breakpoint (bp_tgt
);
5536 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5538 CORE_ADDR addr
= bp_tgt
->placed_address
;
5539 struct remote_state
*rs
= get_remote_state ();
5542 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5550 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5551 p
+= hexnumstr (p
, addr
);
5552 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5555 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5557 return (rs
->buf
[0] == 'E');
5560 return memory_remove_breakpoint (bp_tgt
);
5564 watchpoint_to_Z_packet (int type
)
5569 return Z_PACKET_WRITE_WP
;
5572 return Z_PACKET_READ_WP
;
5575 return Z_PACKET_ACCESS_WP
;
5578 internal_error (__FILE__
, __LINE__
,
5579 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5584 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5586 struct remote_state
*rs
= get_remote_state ();
5588 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5590 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5593 sprintf (rs
->buf
, "Z%x,", packet
);
5594 p
= strchr (rs
->buf
, '\0');
5595 addr
= remote_address_masked (addr
);
5596 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5597 sprintf (p
, ",%x", len
);
5600 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5602 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5605 case PACKET_UNKNOWN
:
5610 internal_error (__FILE__
, __LINE__
,
5611 _("remote_insert_watchpoint: reached end of function"));
5616 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5618 struct remote_state
*rs
= get_remote_state ();
5620 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5622 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5625 sprintf (rs
->buf
, "z%x,", packet
);
5626 p
= strchr (rs
->buf
, '\0');
5627 addr
= remote_address_masked (addr
);
5628 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5629 sprintf (p
, ",%x", len
);
5631 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5633 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5636 case PACKET_UNKNOWN
:
5641 internal_error (__FILE__
, __LINE__
,
5642 _("remote_remove_watchpoint: reached end of function"));
5646 int remote_hw_watchpoint_limit
= -1;
5647 int remote_hw_breakpoint_limit
= -1;
5650 remote_check_watch_resources (int type
, int cnt
, int ot
)
5652 if (type
== bp_hardware_breakpoint
)
5654 if (remote_hw_breakpoint_limit
== 0)
5656 else if (remote_hw_breakpoint_limit
< 0)
5658 else if (cnt
<= remote_hw_breakpoint_limit
)
5663 if (remote_hw_watchpoint_limit
== 0)
5665 else if (remote_hw_watchpoint_limit
< 0)
5669 else if (cnt
<= remote_hw_watchpoint_limit
)
5676 remote_stopped_by_watchpoint (void)
5678 return remote_stopped_by_watchpoint_p
;
5682 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5685 if (remote_stopped_by_watchpoint ())
5687 *addr_p
= remote_watch_data_address
;
5696 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5699 struct remote_state
*rs
= get_remote_state ();
5702 /* The length field should be set to the size of a breakpoint
5703 instruction, even though we aren't inserting one ourselves. */
5705 gdbarch_breakpoint_from_pc
5706 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5708 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5715 addr
= remote_address_masked (bp_tgt
->placed_address
);
5716 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5717 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5720 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5722 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5725 case PACKET_UNKNOWN
:
5730 internal_error (__FILE__
, __LINE__
,
5731 _("remote_insert_hw_breakpoint: reached end of function"));
5736 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5739 struct remote_state
*rs
= get_remote_state ();
5742 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5749 addr
= remote_address_masked (bp_tgt
->placed_address
);
5750 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5751 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5754 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5756 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5759 case PACKET_UNKNOWN
:
5764 internal_error (__FILE__
, __LINE__
,
5765 _("remote_remove_hw_breakpoint: reached end of function"));
5768 /* Some targets are only capable of doing downloads, and afterwards
5769 they switch to the remote serial protocol. This function provides
5770 a clean way to get from the download target to the remote target.
5771 It's basically just a wrapper so that we don't have to expose any
5772 of the internal workings of remote.c.
5774 Prior to calling this routine, you should shutdown the current
5775 target code, else you will get the "A program is being debugged
5776 already..." message. Usually a call to pop_target() suffices. */
5779 push_remote_target (char *name
, int from_tty
)
5781 printf_filtered (_("Switching to remote protocol\n"));
5782 remote_open (name
, from_tty
);
5785 /* Table used by the crc32 function to calcuate the checksum. */
5787 static unsigned long crc32_table
[256] =
5790 static unsigned long
5791 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5793 if (!crc32_table
[1])
5795 /* Initialize the CRC table and the decoding table. */
5799 for (i
= 0; i
< 256; i
++)
5801 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5802 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5809 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5815 /* compare-sections command
5817 With no arguments, compares each loadable section in the exec bfd
5818 with the same memory range on the target, and reports mismatches.
5819 Useful for verifying the image on the target against the exec file.
5820 Depends on the target understanding the new "qCRC:" request. */
5822 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5823 target method (target verify memory) and generic version of the
5824 actual command. This will allow other high-level code (especially
5825 generic_load()) to make use of this target functionality. */
5828 compare_sections_command (char *args
, int from_tty
)
5830 struct remote_state
*rs
= get_remote_state ();
5832 unsigned long host_crc
, target_crc
;
5833 extern bfd
*exec_bfd
;
5834 struct cleanup
*old_chain
;
5837 const char *sectname
;
5844 error (_("command cannot be used without an exec file"));
5845 if (!current_target
.to_shortname
||
5846 strcmp (current_target
.to_shortname
, "remote") != 0)
5847 error (_("command can only be used with remote target"));
5849 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5851 if (!(s
->flags
& SEC_LOAD
))
5852 continue; /* skip non-loadable section */
5854 size
= bfd_get_section_size (s
);
5856 continue; /* skip zero-length section */
5858 sectname
= bfd_get_section_name (exec_bfd
, s
);
5859 if (args
&& strcmp (args
, sectname
) != 0)
5860 continue; /* not the section selected by user */
5862 matched
= 1; /* do this section */
5864 /* FIXME: assumes lma can fit into long. */
5865 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5866 (long) lma
, (long) size
);
5869 /* Be clever; compute the host_crc before waiting for target
5871 sectdata
= xmalloc (size
);
5872 old_chain
= make_cleanup (xfree
, sectdata
);
5873 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5874 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5876 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5877 if (rs
->buf
[0] == 'E')
5878 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5879 sectname
, paddr (lma
), paddr (lma
+ size
));
5880 if (rs
->buf
[0] != 'C')
5881 error (_("remote target does not support this operation"));
5883 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5884 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5886 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5887 sectname
, paddr (lma
), paddr (lma
+ size
));
5888 if (host_crc
== target_crc
)
5889 printf_filtered ("matched.\n");
5892 printf_filtered ("MIS-MATCHED!\n");
5896 do_cleanups (old_chain
);
5899 warning (_("One or more sections of the remote executable does not match\n\
5900 the loaded file\n"));
5901 if (args
&& !matched
)
5902 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5905 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5906 into remote target. The number of bytes written to the remote
5907 target is returned, or -1 for error. */
5910 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
5911 const char *annex
, const gdb_byte
*writebuf
,
5912 ULONGEST offset
, LONGEST len
,
5913 struct packet_config
*packet
)
5918 struct remote_state
*rs
= get_remote_state ();
5919 int max_size
= get_memory_write_packet_size ();
5921 if (packet
->support
== PACKET_DISABLE
)
5924 /* Insert header. */
5925 i
= snprintf (rs
->buf
, max_size
,
5926 "qXfer:%s:write:%s:%s:",
5927 object_name
, annex
? annex
: "",
5928 phex_nz (offset
, sizeof offset
));
5929 max_size
-= (i
+ 1);
5931 /* Escape as much data as fits into rs->buf. */
5932 buf_len
= remote_escape_output
5933 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
5935 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
5936 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
5937 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5940 unpack_varlen_hex (rs
->buf
, &n
);
5944 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5945 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5946 number of bytes read is returned, or 0 for EOF, or -1 for error.
5947 The number of bytes read may be less than LEN without indicating an
5948 EOF. PACKET is checked and updated to indicate whether the remote
5949 target supports this object. */
5952 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5954 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5955 struct packet_config
*packet
)
5957 static char *finished_object
;
5958 static char *finished_annex
;
5959 static ULONGEST finished_offset
;
5961 struct remote_state
*rs
= get_remote_state ();
5962 unsigned int total
= 0;
5963 LONGEST i
, n
, packet_len
;
5965 if (packet
->support
== PACKET_DISABLE
)
5968 /* Check whether we've cached an end-of-object packet that matches
5970 if (finished_object
)
5972 if (strcmp (object_name
, finished_object
) == 0
5973 && strcmp (annex
? annex
: "", finished_annex
) == 0
5974 && offset
== finished_offset
)
5977 /* Otherwise, we're now reading something different. Discard
5979 xfree (finished_object
);
5980 xfree (finished_annex
);
5981 finished_object
= NULL
;
5982 finished_annex
= NULL
;
5985 /* Request only enough to fit in a single packet. The actual data
5986 may not, since we don't know how much of it will need to be escaped;
5987 the target is free to respond with slightly less data. We subtract
5988 five to account for the response type and the protocol frame. */
5989 n
= min (get_remote_packet_size () - 5, len
);
5990 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5991 object_name
, annex
? annex
: "",
5992 phex_nz (offset
, sizeof offset
),
5993 phex_nz (n
, sizeof n
));
5994 i
= putpkt (rs
->buf
);
5999 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
6000 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
6003 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
6004 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
6006 /* 'm' means there is (or at least might be) more data after this
6007 batch. That does not make sense unless there's at least one byte
6008 of data in this reply. */
6009 if (rs
->buf
[0] == 'm' && packet_len
== 1)
6010 error (_("Remote qXfer reply contained no data."));
6012 /* Got some data. */
6013 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
6015 /* 'l' is an EOF marker, possibly including a final block of data,
6016 or possibly empty. If we have the final block of a non-empty
6017 object, record this fact to bypass a subsequent partial read. */
6018 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
6020 finished_object
= xstrdup (object_name
);
6021 finished_annex
= xstrdup (annex
? annex
: "");
6022 finished_offset
= offset
+ i
;
6029 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
6030 const char *annex
, gdb_byte
*readbuf
,
6031 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
6033 struct remote_state
*rs
= get_remote_state ();
6038 /* Handle memory using the standard memory routines. */
6039 if (object
== TARGET_OBJECT_MEMORY
)
6044 /* If the remote target is connected but not running, we should
6045 pass this request down to a lower stratum (e.g. the executable
6047 if (!target_has_execution
)
6050 if (writebuf
!= NULL
)
6051 xfered
= remote_write_bytes (offset
, writebuf
, len
);
6053 xfered
= remote_read_bytes (offset
, readbuf
, len
);
6057 else if (xfered
== 0 && errno
== 0)
6063 /* Handle SPU memory using qxfer packets. */
6064 if (object
== TARGET_OBJECT_SPU
)
6067 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
6068 &remote_protocol_packets
6069 [PACKET_qXfer_spu_read
]);
6071 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
6072 &remote_protocol_packets
6073 [PACKET_qXfer_spu_write
]);
6076 /* Only handle flash writes. */
6077 if (writebuf
!= NULL
)
6083 case TARGET_OBJECT_FLASH
:
6084 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
6088 else if (xfered
== 0 && errno
== 0)
6098 /* Map pre-existing objects onto letters. DO NOT do this for new
6099 objects!!! Instead specify new query packets. */
6102 case TARGET_OBJECT_AVR
:
6106 case TARGET_OBJECT_AUXV
:
6107 gdb_assert (annex
== NULL
);
6108 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
6109 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
6111 case TARGET_OBJECT_AVAILABLE_FEATURES
:
6112 return remote_read_qxfer
6113 (ops
, "features", annex
, readbuf
, offset
, len
,
6114 &remote_protocol_packets
[PACKET_qXfer_features
]);
6116 case TARGET_OBJECT_LIBRARIES
:
6117 return remote_read_qxfer
6118 (ops
, "libraries", annex
, readbuf
, offset
, len
,
6119 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
6121 case TARGET_OBJECT_MEMORY_MAP
:
6122 gdb_assert (annex
== NULL
);
6123 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
6124 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
6130 /* Note: a zero OFFSET and LEN can be used to query the minimum
6132 if (offset
== 0 && len
== 0)
6133 return (get_remote_packet_size ());
6134 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
6135 large enough let the caller deal with it. */
6136 if (len
< get_remote_packet_size ())
6138 len
= get_remote_packet_size ();
6140 /* Except for querying the minimum buffer size, target must be open. */
6142 error (_("remote query is only available after target open"));
6144 gdb_assert (annex
!= NULL
);
6145 gdb_assert (readbuf
!= NULL
);
6151 /* We used one buffer char for the remote protocol q command and
6152 another for the query type. As the remote protocol encapsulation
6153 uses 4 chars plus one extra in case we are debugging
6154 (remote_debug), we have PBUFZIZ - 7 left to pack the query
6157 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
6159 /* Bad caller may have sent forbidden characters. */
6160 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
6165 gdb_assert (annex
[i
] == '\0');
6167 i
= putpkt (rs
->buf
);
6171 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6172 strcpy ((char *) readbuf
, rs
->buf
);
6174 return strlen ((char *) readbuf
);
6178 remote_rcmd (char *command
,
6179 struct ui_file
*outbuf
)
6181 struct remote_state
*rs
= get_remote_state ();
6185 error (_("remote rcmd is only available after target open"));
6187 /* Send a NULL command across as an empty command. */
6188 if (command
== NULL
)
6191 /* The query prefix. */
6192 strcpy (rs
->buf
, "qRcmd,");
6193 p
= strchr (rs
->buf
, '\0');
6195 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
6196 error (_("\"monitor\" command ``%s'' is too long."), command
);
6198 /* Encode the actual command. */
6199 bin2hex ((gdb_byte
*) command
, p
, 0);
6201 if (putpkt (rs
->buf
) < 0)
6202 error (_("Communication problem with target."));
6204 /* get/display the response */
6209 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
6211 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6214 error (_("Target does not support this command."));
6215 if (buf
[0] == 'O' && buf
[1] != 'K')
6217 remote_console_output (buf
+ 1); /* 'O' message from stub. */
6220 if (strcmp (buf
, "OK") == 0)
6222 if (strlen (buf
) == 3 && buf
[0] == 'E'
6223 && isdigit (buf
[1]) && isdigit (buf
[2]))
6225 error (_("Protocol error with Rcmd"));
6227 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
6229 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
6230 fputc_unfiltered (c
, outbuf
);
6236 static VEC(mem_region_s
) *
6237 remote_memory_map (struct target_ops
*ops
)
6239 VEC(mem_region_s
) *result
= NULL
;
6240 char *text
= target_read_stralloc (¤t_target
,
6241 TARGET_OBJECT_MEMORY_MAP
, NULL
);
6245 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
6246 result
= parse_memory_map (text
);
6247 do_cleanups (back_to
);
6254 packet_command (char *args
, int from_tty
)
6256 struct remote_state
*rs
= get_remote_state ();
6259 error (_("command can only be used with remote target"));
6262 error (_("remote-packet command requires packet text as argument"));
6264 puts_filtered ("sending: ");
6265 print_packet (args
);
6266 puts_filtered ("\n");
6269 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6270 puts_filtered ("received: ");
6271 print_packet (rs
->buf
);
6272 puts_filtered ("\n");
6276 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
6278 static void display_thread_info (struct gdb_ext_thread_info
*info
);
6280 static void threadset_test_cmd (char *cmd
, int tty
);
6282 static void threadalive_test (char *cmd
, int tty
);
6284 static void threadlist_test_cmd (char *cmd
, int tty
);
6286 int get_and_display_threadinfo (threadref
*ref
);
6288 static void threadinfo_test_cmd (char *cmd
, int tty
);
6290 static int thread_display_step (threadref
*ref
, void *context
);
6292 static void threadlist_update_test_cmd (char *cmd
, int tty
);
6294 static void init_remote_threadtests (void);
6296 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
6299 threadset_test_cmd (char *cmd
, int tty
)
6301 int sample_thread
= SAMPLE_THREAD
;
6303 printf_filtered (_("Remote threadset test\n"));
6304 set_thread (sample_thread
, 1);
6309 threadalive_test (char *cmd
, int tty
)
6311 int sample_thread
= SAMPLE_THREAD
;
6313 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
6314 printf_filtered ("PASS: Thread alive test\n");
6316 printf_filtered ("FAIL: Thread alive test\n");
6319 void output_threadid (char *title
, threadref
*ref
);
6322 output_threadid (char *title
, threadref
*ref
)
6326 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
6328 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
6332 threadlist_test_cmd (char *cmd
, int tty
)
6335 threadref nextthread
;
6336 int done
, result_count
;
6337 threadref threadlist
[3];
6339 printf_filtered ("Remote Threadlist test\n");
6340 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
6341 &result_count
, &threadlist
[0]))
6342 printf_filtered ("FAIL: threadlist test\n");
6345 threadref
*scan
= threadlist
;
6346 threadref
*limit
= scan
+ result_count
;
6348 while (scan
< limit
)
6349 output_threadid (" thread ", scan
++);
6354 display_thread_info (struct gdb_ext_thread_info
*info
)
6356 output_threadid ("Threadid: ", &info
->threadid
);
6357 printf_filtered ("Name: %s\n ", info
->shortname
);
6358 printf_filtered ("State: %s\n", info
->display
);
6359 printf_filtered ("other: %s\n\n", info
->more_display
);
6363 get_and_display_threadinfo (threadref
*ref
)
6367 struct gdb_ext_thread_info threadinfo
;
6369 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
6370 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
6371 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
6372 display_thread_info (&threadinfo
);
6377 threadinfo_test_cmd (char *cmd
, int tty
)
6379 int athread
= SAMPLE_THREAD
;
6383 int_to_threadref (&thread
, athread
);
6384 printf_filtered ("Remote Threadinfo test\n");
6385 if (!get_and_display_threadinfo (&thread
))
6386 printf_filtered ("FAIL cannot get thread info\n");
6390 thread_display_step (threadref
*ref
, void *context
)
6392 /* output_threadid(" threadstep ",ref); *//* simple test */
6393 return get_and_display_threadinfo (ref
);
6397 threadlist_update_test_cmd (char *cmd
, int tty
)
6399 printf_filtered ("Remote Threadlist update test\n");
6400 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
6404 init_remote_threadtests (void)
6406 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
6407 Fetch and print the remote list of thread identifiers, one pkt only"));
6408 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
6409 _("Fetch and display info about one thread"));
6410 add_com ("tset", class_obscure
, threadset_test_cmd
,
6411 _("Test setting to a different thread"));
6412 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
6413 _("Iterate through updating all remote thread info"));
6414 add_com ("talive", class_obscure
, threadalive_test
,
6415 _(" Remote thread alive test "));
6420 /* Convert a thread ID to a string. Returns the string in a static
6424 remote_pid_to_str (ptid_t ptid
)
6426 static char buf
[32];
6428 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
6432 /* Get the address of the thread local variable in OBJFILE which is
6433 stored at OFFSET within the thread local storage for thread PTID. */
6436 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
6438 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
6440 struct remote_state
*rs
= get_remote_state ();
6442 enum packet_result result
;
6444 strcpy (p
, "qGetTLSAddr:");
6446 p
+= hexnumstr (p
, PIDGET (ptid
));
6448 p
+= hexnumstr (p
, offset
);
6450 p
+= hexnumstr (p
, lm
);
6454 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6455 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6456 if (result
== PACKET_OK
)
6460 unpack_varlen_hex (rs
->buf
, &result
);
6463 else if (result
== PACKET_UNKNOWN
)
6464 throw_error (TLS_GENERIC_ERROR
,
6465 _("Remote target doesn't support qGetTLSAddr packet"));
6467 throw_error (TLS_GENERIC_ERROR
,
6468 _("Remote target failed to process qGetTLSAddr request"));
6471 throw_error (TLS_GENERIC_ERROR
,
6472 _("TLS not supported or disabled on this target"));
6477 /* Support for inferring a target description based on the current
6478 architecture and the size of a 'g' packet. While the 'g' packet
6479 can have any size (since optional registers can be left off the
6480 end), some sizes are easily recognizable given knowledge of the
6481 approximate architecture. */
6483 struct remote_g_packet_guess
6486 const struct target_desc
*tdesc
;
6488 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6489 DEF_VEC_O(remote_g_packet_guess_s
);
6491 struct remote_g_packet_data
6493 VEC(remote_g_packet_guess_s
) *guesses
;
6496 static struct gdbarch_data
*remote_g_packet_data_handle
;
6499 remote_g_packet_data_init (struct obstack
*obstack
)
6501 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6505 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6506 const struct target_desc
*tdesc
)
6508 struct remote_g_packet_data
*data
6509 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6510 struct remote_g_packet_guess new_guess
, *guess
;
6513 gdb_assert (tdesc
!= NULL
);
6516 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6518 if (guess
->bytes
== bytes
)
6519 internal_error (__FILE__
, __LINE__
,
6520 "Duplicate g packet description added for size %d",
6523 new_guess
.bytes
= bytes
;
6524 new_guess
.tdesc
= tdesc
;
6525 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6528 static const struct target_desc
*
6529 remote_read_description (struct target_ops
*target
)
6531 struct remote_g_packet_data
*data
6532 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6534 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6536 struct remote_g_packet_guess
*guess
;
6538 int bytes
= send_g_packet ();
6541 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6543 if (guess
->bytes
== bytes
)
6544 return guess
->tdesc
;
6546 /* We discard the g packet. A minor optimization would be to
6547 hold on to it, and fill the register cache once we have selected
6548 an architecture, but it's too tricky to do safely. */
6554 /* Remote file transfer support. This is host-initiated I/O, not
6555 target-initiated; for target-initiated, see remote-fileio.c. */
6557 /* If *LEFT is at least the length of STRING, copy STRING to
6558 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6559 decrease *LEFT. Otherwise raise an error. */
6562 remote_buffer_add_string (char **buffer
, int *left
, char *string
)
6564 int len
= strlen (string
);
6567 error (_("Packet too long for target."));
6569 memcpy (*buffer
, string
, len
);
6573 /* NUL-terminate the buffer as a convenience, if there is
6579 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
6580 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6581 decrease *LEFT. Otherwise raise an error. */
6584 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
6587 if (2 * len
> *left
)
6588 error (_("Packet too long for target."));
6590 bin2hex (bytes
, *buffer
, len
);
6594 /* NUL-terminate the buffer as a convenience, if there is
6600 /* If *LEFT is large enough, convert VALUE to hex and add it to
6601 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6602 decrease *LEFT. Otherwise raise an error. */
6605 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
6607 int len
= hexnumlen (value
);
6610 error (_("Packet too long for target."));
6612 hexnumstr (*buffer
, value
);
6616 /* NUL-terminate the buffer as a convenience, if there is
6622 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
6623 value, *REMOTE_ERRNO to the remote error number or zero if none
6624 was included, and *ATTACHMENT to point to the start of the annex
6625 if any. The length of the packet isn't needed here; there may
6626 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
6628 Return 0 if the packet could be parsed, -1 if it could not. If
6629 -1 is returned, the other variables may not be initialized. */
6632 remote_hostio_parse_result (char *buffer
, int *retcode
,
6633 int *remote_errno
, char **attachment
)
6640 if (buffer
[0] != 'F')
6644 *retcode
= strtol (&buffer
[1], &p
, 16);
6645 if (errno
!= 0 || p
== &buffer
[1])
6648 /* Check for ",errno". */
6652 *remote_errno
= strtol (p
+ 1, &p2
, 16);
6653 if (errno
!= 0 || p
+ 1 == p2
)
6658 /* Check for ";attachment". If there is no attachment, the
6659 packet should end here. */
6662 *attachment
= p
+ 1;
6665 else if (*p
== '\0')
6671 /* Send a prepared I/O packet to the target and read its response.
6672 The prepared packet is in the global RS->BUF before this function
6673 is called, and the answer is there when we return.
6675 COMMAND_BYTES is the length of the request to send, which may include
6676 binary data. WHICH_PACKET is the packet configuration to check
6677 before attempting a packet. If an error occurs, *REMOTE_ERRNO
6678 is set to the error number and -1 is returned. Otherwise the value
6679 returned by the function is returned.
6681 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
6682 attachment is expected; an error will be reported if there's a
6683 mismatch. If one is found, *ATTACHMENT will be set to point into
6684 the packet buffer and *ATTACHMENT_LEN will be set to the
6685 attachment's length. */
6688 remote_hostio_send_command (int command_bytes
, int which_packet
,
6689 int *remote_errno
, char **attachment
,
6690 int *attachment_len
)
6692 struct remote_state
*rs
= get_remote_state ();
6693 int ret
, bytes_read
;
6694 char *attachment_tmp
;
6696 if (remote_protocol_packets
[which_packet
].support
== PACKET_DISABLE
)
6698 *remote_errno
= FILEIO_ENOSYS
;
6702 putpkt_binary (rs
->buf
, command_bytes
);
6703 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
6705 /* If it timed out, something is wrong. Don't try to parse the
6709 *remote_errno
= FILEIO_EINVAL
;
6713 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
6716 *remote_errno
= FILEIO_EINVAL
;
6718 case PACKET_UNKNOWN
:
6719 *remote_errno
= FILEIO_ENOSYS
;
6725 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
6728 *remote_errno
= FILEIO_EINVAL
;
6732 /* Make sure we saw an attachment if and only if we expected one. */
6733 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
6734 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
6736 *remote_errno
= FILEIO_EINVAL
;
6740 /* If an attachment was found, it must point into the packet buffer;
6741 work out how many bytes there were. */
6742 if (attachment_tmp
!= NULL
)
6744 *attachment
= attachment_tmp
;
6745 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
6751 /* Open FILENAME on the remote target, using FLAGS and MODE. Return a
6752 remote file descriptor, or -1 if an error occurs (and set
6756 remote_hostio_open (const char *filename
, int flags
, int mode
,
6759 struct remote_state
*rs
= get_remote_state ();
6761 int left
= get_remote_packet_size () - 1;
6763 remote_buffer_add_string (&p
, &left
, "vFile:open:");
6765 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
6767 remote_buffer_add_string (&p
, &left
, ",");
6769 remote_buffer_add_int (&p
, &left
, flags
);
6770 remote_buffer_add_string (&p
, &left
, ",");
6772 remote_buffer_add_int (&p
, &left
, mode
);
6774 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
6775 remote_errno
, NULL
, NULL
);
6778 /* Write up to LEN bytes from WRITE_BUF to FD on the remote target.
6779 Return the number of bytes written, or -1 if an error occurs (and
6780 set *REMOTE_ERRNO). */
6783 remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
6784 ULONGEST offset
, int *remote_errno
)
6786 struct remote_state
*rs
= get_remote_state ();
6788 int left
= get_remote_packet_size ();
6791 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
6793 remote_buffer_add_int (&p
, &left
, fd
);
6794 remote_buffer_add_string (&p
, &left
, ",");
6796 remote_buffer_add_int (&p
, &left
, offset
);
6797 remote_buffer_add_string (&p
, &left
, ",");
6799 p
+= remote_escape_output (write_buf
, len
, p
, &out_len
,
6800 get_remote_packet_size () - (p
- rs
->buf
));
6802 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
6803 remote_errno
, NULL
, NULL
);
6806 /* Read up to LEN bytes FD on the remote target into READ_BUF
6807 Return the number of bytes read, or -1 if an error occurs (and
6808 set *REMOTE_ERRNO). */
6811 remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
6812 ULONGEST offset
, int *remote_errno
)
6814 struct remote_state
*rs
= get_remote_state ();
6817 int left
= get_remote_packet_size ();
6818 int ret
, attachment_len
;
6821 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
6823 remote_buffer_add_int (&p
, &left
, fd
);
6824 remote_buffer_add_string (&p
, &left
, ",");
6826 remote_buffer_add_int (&p
, &left
, len
);
6827 remote_buffer_add_string (&p
, &left
, ",");
6829 remote_buffer_add_int (&p
, &left
, offset
);
6831 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
6832 remote_errno
, &attachment
,
6838 read_len
= remote_unescape_input (attachment
, attachment_len
,
6840 if (read_len
!= ret
)
6841 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
6846 /* Close FD on the remote target. Return 0, or -1 if an error occurs
6847 (and set *REMOTE_ERRNO). */
6850 remote_hostio_close (int fd
, int *remote_errno
)
6852 struct remote_state
*rs
= get_remote_state ();
6854 int left
= get_remote_packet_size () - 1;
6856 remote_buffer_add_string (&p
, &left
, "vFile:close:");
6858 remote_buffer_add_int (&p
, &left
, fd
);
6860 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
6861 remote_errno
, NULL
, NULL
);
6864 /* Unlink FILENAME on the remote target. Return 0, or -1 if an error
6865 occurs (and set *REMOTE_ERRNO). */
6868 remote_hostio_unlink (const char *filename
, int *remote_errno
)
6870 struct remote_state
*rs
= get_remote_state ();
6872 int left
= get_remote_packet_size () - 1;
6874 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
6876 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
6879 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
6880 remote_errno
, NULL
, NULL
);
6884 remote_fileio_errno_to_host (int errnum
)
6908 case FILEIO_ENOTDIR
:
6928 case FILEIO_ENAMETOOLONG
:
6929 return ENAMETOOLONG
;
6935 remote_hostio_error (int errnum
)
6937 int host_error
= remote_fileio_errno_to_host (errnum
);
6939 if (host_error
== -1)
6940 error (_("Unknown remote I/O error %d"), errnum
);
6942 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
6946 fclose_cleanup (void *file
)
6952 remote_hostio_close_cleanup (void *opaque
)
6954 int fd
= *(int *) opaque
;
6957 remote_hostio_close (fd
, &remote_errno
);
6961 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
6963 struct cleanup
*back_to
, *close_cleanup
;
6964 int retcode
, fd
, remote_errno
, bytes
, io_size
;
6967 int bytes_in_buffer
;
6972 error (_("command can only be used with remote target"));
6974 file
= fopen (local_file
, "rb");
6976 perror_with_name (local_file
);
6977 back_to
= make_cleanup (fclose_cleanup
, file
);
6979 fd
= remote_hostio_open (remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
6981 0700, &remote_errno
);
6983 remote_hostio_error (remote_errno
);
6985 /* Send up to this many bytes at once. They won't all fit in the
6986 remote packet limit, so we'll transfer slightly fewer. */
6987 io_size
= get_remote_packet_size ();
6988 buffer
= xmalloc (io_size
);
6989 make_cleanup (xfree
, buffer
);
6991 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
6993 bytes_in_buffer
= 0;
6996 while (bytes_in_buffer
|| !saw_eof
)
7000 bytes
= fread (buffer
+ bytes_in_buffer
, 1, io_size
- bytes_in_buffer
,
7005 error (_("Error reading %s."), local_file
);
7008 /* EOF. Unless there is something still in the
7009 buffer from the last iteration, we are done. */
7011 if (bytes_in_buffer
== 0)
7019 bytes
+= bytes_in_buffer
;
7020 bytes_in_buffer
= 0;
7022 retcode
= remote_hostio_pwrite (fd
, buffer
, bytes
, offset
, &remote_errno
);
7025 remote_hostio_error (remote_errno
);
7026 else if (retcode
== 0)
7027 error (_("Remote write of %d bytes returned 0!"), bytes
);
7028 else if (retcode
< bytes
)
7030 /* Short write. Save the rest of the read data for the next
7032 bytes_in_buffer
= bytes
- retcode
;
7033 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
7039 discard_cleanups (close_cleanup
);
7040 if (remote_hostio_close (fd
, &remote_errno
))
7041 remote_hostio_error (remote_errno
);
7044 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
7045 do_cleanups (back_to
);
7049 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
7051 struct cleanup
*back_to
, *close_cleanup
;
7052 int retcode
, fd
, remote_errno
, bytes
, io_size
;
7058 error (_("command can only be used with remote target"));
7060 fd
= remote_hostio_open (remote_file
, FILEIO_O_RDONLY
, 0, &remote_errno
);
7062 remote_hostio_error (remote_errno
);
7064 file
= fopen (local_file
, "wb");
7066 perror_with_name (local_file
);
7067 back_to
= make_cleanup (fclose_cleanup
, file
);
7069 /* Send up to this many bytes at once. They won't all fit in the
7070 remote packet limit, so we'll transfer slightly fewer. */
7071 io_size
= get_remote_packet_size ();
7072 buffer
= xmalloc (io_size
);
7073 make_cleanup (xfree
, buffer
);
7075 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
7080 bytes
= remote_hostio_pread (fd
, buffer
, io_size
, offset
, &remote_errno
);
7082 /* Success, but no bytes, means end-of-file. */
7085 remote_hostio_error (remote_errno
);
7089 bytes
= fwrite (buffer
, 1, bytes
, file
);
7091 perror_with_name (local_file
);
7094 discard_cleanups (close_cleanup
);
7095 if (remote_hostio_close (fd
, &remote_errno
))
7096 remote_hostio_error (remote_errno
);
7099 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
7100 do_cleanups (back_to
);
7104 remote_file_delete (const char *remote_file
, int from_tty
)
7106 int retcode
, remote_errno
;
7109 error (_("command can only be used with remote target"));
7111 retcode
= remote_hostio_unlink (remote_file
, &remote_errno
);
7113 remote_hostio_error (remote_errno
);
7116 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
7120 remote_put_command (char *args
, int from_tty
)
7122 struct cleanup
*back_to
;
7125 argv
= buildargv (args
);
7128 back_to
= make_cleanup_freeargv (argv
);
7129 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
7130 error (_("Invalid parameters to remote put"));
7132 remote_file_put (argv
[0], argv
[1], from_tty
);
7134 do_cleanups (back_to
);
7138 remote_get_command (char *args
, int from_tty
)
7140 struct cleanup
*back_to
;
7143 argv
= buildargv (args
);
7146 back_to
= make_cleanup_freeargv (argv
);
7147 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
7148 error (_("Invalid parameters to remote get"));
7150 remote_file_get (argv
[0], argv
[1], from_tty
);
7152 do_cleanups (back_to
);
7156 remote_delete_command (char *args
, int from_tty
)
7158 struct cleanup
*back_to
;
7161 argv
= buildargv (args
);
7164 back_to
= make_cleanup_freeargv (argv
);
7165 if (argv
[0] == NULL
|| argv
[1] != NULL
)
7166 error (_("Invalid parameters to remote delete"));
7168 remote_file_delete (argv
[0], from_tty
);
7170 do_cleanups (back_to
);
7174 remote_command (char *args
, int from_tty
)
7176 help_list (remote_cmdlist
, "remote ", -1, gdb_stdout
);
7180 init_remote_ops (void)
7182 remote_ops
.to_shortname
= "remote";
7183 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
7185 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
7186 Specify the serial device it is connected to\n\
7187 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
7188 remote_ops
.to_open
= remote_open
;
7189 remote_ops
.to_close
= remote_close
;
7190 remote_ops
.to_detach
= remote_detach
;
7191 remote_ops
.to_disconnect
= remote_disconnect
;
7192 remote_ops
.to_resume
= remote_resume
;
7193 remote_ops
.to_wait
= remote_wait
;
7194 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
7195 remote_ops
.to_store_registers
= remote_store_registers
;
7196 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
7197 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
7198 remote_ops
.to_files_info
= remote_files_info
;
7199 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
7200 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
7201 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
7202 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
7203 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
7204 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
7205 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
7206 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
7207 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
7208 remote_ops
.to_kill
= remote_kill
;
7209 remote_ops
.to_load
= generic_load
;
7210 remote_ops
.to_mourn_inferior
= remote_mourn
;
7211 remote_ops
.to_thread_alive
= remote_thread_alive
;
7212 remote_ops
.to_find_new_threads
= remote_threads_info
;
7213 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
7214 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
7215 remote_ops
.to_stop
= remote_stop
;
7216 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
7217 remote_ops
.to_rcmd
= remote_rcmd
;
7218 remote_ops
.to_log_command
= serial_log_command
;
7219 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
7220 remote_ops
.to_stratum
= process_stratum
;
7221 remote_ops
.to_has_all_memory
= 1;
7222 remote_ops
.to_has_memory
= 1;
7223 remote_ops
.to_has_stack
= 1;
7224 remote_ops
.to_has_registers
= 1;
7225 remote_ops
.to_has_execution
= 1;
7226 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
7227 remote_ops
.to_magic
= OPS_MAGIC
;
7228 remote_ops
.to_memory_map
= remote_memory_map
;
7229 remote_ops
.to_flash_erase
= remote_flash_erase
;
7230 remote_ops
.to_flash_done
= remote_flash_done
;
7231 remote_ops
.to_read_description
= remote_read_description
;
7234 /* Set up the extended remote vector by making a copy of the standard
7235 remote vector and adding to it. */
7238 init_extended_remote_ops (void)
7240 extended_remote_ops
= remote_ops
;
7242 extended_remote_ops
.to_shortname
= "extended-remote";
7243 extended_remote_ops
.to_longname
=
7244 "Extended remote serial target in gdb-specific protocol";
7245 extended_remote_ops
.to_doc
=
7246 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
7247 Specify the serial device it is connected to (e.g. /dev/ttya).",
7248 extended_remote_ops
.to_open
= extended_remote_open
;
7249 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
7250 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
7251 extended_remote_ops
.to_detach
= extended_remote_detach
;
7252 extended_remote_ops
.to_attach
= extended_remote_attach
;
7256 remote_can_async_p (void)
7258 /* We're async whenever the serial device is. */
7259 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
7263 remote_is_async_p (void)
7265 /* We're async whenever the serial device is. */
7266 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
7269 /* Pass the SERIAL event on and up to the client. One day this code
7270 will be able to delay notifying the client of an event until the
7271 point where an entire packet has been received. */
7273 static void (*async_client_callback
) (enum inferior_event_type event_type
,
7275 static void *async_client_context
;
7276 static serial_event_ftype remote_async_serial_handler
;
7279 remote_async_serial_handler (struct serial
*scb
, void *context
)
7281 /* Don't propogate error information up to the client. Instead let
7282 the client find out about the error by querying the target. */
7283 async_client_callback (INF_REG_EVENT
, async_client_context
);
7287 remote_async (void (*callback
) (enum inferior_event_type event_type
,
7288 void *context
), void *context
)
7290 if (current_target
.to_async_mask_value
== 0)
7291 internal_error (__FILE__
, __LINE__
,
7292 _("Calling remote_async when async is masked"));
7294 if (callback
!= NULL
)
7296 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
7297 async_client_callback
= callback
;
7298 async_client_context
= context
;
7301 serial_async (remote_desc
, NULL
, NULL
);
7304 /* Target async and target extended-async.
7306 This are temporary targets, until it is all tested. Eventually
7307 async support will be incorporated int the usual 'remote'
7311 init_remote_async_ops (void)
7313 remote_async_ops
.to_shortname
= "async";
7314 remote_async_ops
.to_longname
=
7315 "Remote serial target in async version of the gdb-specific protocol";
7316 remote_async_ops
.to_doc
=
7317 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
7318 Specify the serial device it is connected to (e.g. /dev/ttya).";
7319 remote_async_ops
.to_open
= remote_async_open
;
7320 remote_async_ops
.to_close
= remote_close
;
7321 remote_async_ops
.to_detach
= remote_detach
;
7322 remote_async_ops
.to_disconnect
= remote_disconnect
;
7323 remote_async_ops
.to_resume
= remote_async_resume
;
7324 remote_async_ops
.to_wait
= remote_async_wait
;
7325 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
7326 remote_async_ops
.to_store_registers
= remote_store_registers
;
7327 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
7328 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
7329 remote_async_ops
.to_files_info
= remote_files_info
;
7330 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
7331 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
7332 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
7333 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
7334 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
7335 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
7336 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
7337 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
7338 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
7339 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
7340 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
7341 remote_async_ops
.to_kill
= remote_async_kill
;
7342 remote_async_ops
.to_load
= generic_load
;
7343 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
7344 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
7345 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
7346 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
7347 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
7348 remote_async_ops
.to_stop
= remote_stop
;
7349 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
7350 remote_async_ops
.to_rcmd
= remote_rcmd
;
7351 remote_async_ops
.to_get_thread_local_address
7352 = remote_get_thread_local_address
;
7353 remote_async_ops
.to_stratum
= process_stratum
;
7354 remote_async_ops
.to_has_all_memory
= 1;
7355 remote_async_ops
.to_has_memory
= 1;
7356 remote_async_ops
.to_has_stack
= 1;
7357 remote_async_ops
.to_has_registers
= 1;
7358 remote_async_ops
.to_has_execution
= 1;
7359 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
7360 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
7361 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
7362 remote_async_ops
.to_async
= remote_async
;
7363 remote_async_ops
.to_async_mask_value
= 1;
7364 remote_async_ops
.to_magic
= OPS_MAGIC
;
7365 remote_async_ops
.to_memory_map
= remote_memory_map
;
7366 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
7367 remote_async_ops
.to_flash_done
= remote_flash_done
;
7368 remote_async_ops
.to_read_description
= remote_read_description
;
7371 /* Set up the async extended remote vector by making a copy of the standard
7372 remote vector and adding to it. */
7375 init_extended_async_remote_ops (void)
7377 extended_async_remote_ops
= remote_async_ops
;
7379 extended_async_remote_ops
.to_shortname
= "extended-async";
7380 extended_async_remote_ops
.to_longname
=
7381 "Extended remote serial target in async gdb-specific protocol";
7382 extended_async_remote_ops
.to_doc
=
7383 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
7384 Specify the serial device it is connected to (e.g. /dev/ttya).",
7385 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
7386 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
7387 extended_async_remote_ops
.to_mourn_inferior
= extended_async_remote_mourn
;
7388 extended_async_remote_ops
.to_detach
= extended_remote_detach
;
7389 extended_async_remote_ops
.to_attach
= extended_async_remote_attach
;
7393 set_remote_cmd (char *args
, int from_tty
)
7395 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
7399 show_remote_cmd (char *args
, int from_tty
)
7401 /* We can't just use cmd_show_list here, because we want to skip
7402 the redundant "show remote Z-packet" and the legacy aliases. */
7403 struct cleanup
*showlist_chain
;
7404 struct cmd_list_element
*list
= remote_show_cmdlist
;
7406 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
7407 for (; list
!= NULL
; list
= list
->next
)
7408 if (strcmp (list
->name
, "Z-packet") == 0)
7410 else if (list
->type
== not_set_cmd
)
7411 /* Alias commands are exactly like the original, except they
7412 don't have the normal type. */
7416 struct cleanup
*option_chain
7417 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
7418 ui_out_field_string (uiout
, "name", list
->name
);
7419 ui_out_text (uiout
, ": ");
7420 if (list
->type
== show_cmd
)
7421 do_setshow_command ((char *) NULL
, from_tty
, list
);
7423 cmd_func (list
, NULL
, from_tty
);
7424 /* Close the tuple. */
7425 do_cleanups (option_chain
);
7428 /* Close the tuple. */
7429 do_cleanups (showlist_chain
);
7433 /* Function to be called whenever a new objfile (shlib) is detected. */
7435 remote_new_objfile (struct objfile
*objfile
)
7437 if (remote_desc
!= 0) /* Have a remote connection. */
7438 remote_check_symbols (objfile
);
7442 _initialize_remote (void)
7444 struct remote_state
*rs
;
7446 /* architecture specific data */
7447 remote_gdbarch_data_handle
=
7448 gdbarch_data_register_post_init (init_remote_state
);
7449 remote_g_packet_data_handle
=
7450 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
7452 /* Initialize the per-target state. At the moment there is only one
7453 of these, not one per target. Only one target is active at a
7454 time. The default buffer size is unimportant; it will be expanded
7455 whenever a larger buffer is needed. */
7456 rs
= get_remote_state_raw ();
7458 rs
->buf
= xmalloc (rs
->buf_size
);
7461 add_target (&remote_ops
);
7463 init_extended_remote_ops ();
7464 add_target (&extended_remote_ops
);
7466 init_remote_async_ops ();
7467 add_target (&remote_async_ops
);
7469 init_extended_async_remote_ops ();
7470 add_target (&extended_async_remote_ops
);
7472 /* Hook into new objfile notification. */
7473 observer_attach_new_objfile (remote_new_objfile
);
7475 /* Set up signal handlers. */
7476 sigint_remote_token
=
7477 create_async_signal_handler (async_remote_interrupt
, NULL
);
7478 sigint_remote_twice_token
=
7479 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
7482 init_remote_threadtests ();
7485 /* set/show remote ... */
7487 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
7488 Remote protocol specific variables\n\
7489 Configure various remote-protocol specific variables such as\n\
7490 the packets being used"),
7491 &remote_set_cmdlist
, "set remote ",
7492 0 /* allow-unknown */, &setlist
);
7493 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
7494 Remote protocol specific variables\n\
7495 Configure various remote-protocol specific variables such as\n\
7496 the packets being used"),
7497 &remote_show_cmdlist
, "show remote ",
7498 0 /* allow-unknown */, &showlist
);
7500 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
7501 Compare section data on target to the exec file.\n\
7502 Argument is a single section name (default: all loaded sections)."),
7505 add_cmd ("packet", class_maintenance
, packet_command
, _("\
7506 Send an arbitrary packet to a remote target.\n\
7507 maintenance packet TEXT\n\
7508 If GDB is talking to an inferior via the GDB serial protocol, then\n\
7509 this command sends the string TEXT to the inferior, and displays the\n\
7510 response packet. GDB supplies the initial `$' character, and the\n\
7511 terminating `#' character and checksum."),
7514 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
7515 Set whether to send break if interrupted."), _("\
7516 Show whether to send break if interrupted."), _("\
7517 If set, a break, instead of a cntrl-c, is sent to the remote target."),
7518 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
7519 &setlist
, &showlist
);
7521 /* Install commands for configuring memory read/write packets. */
7523 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
7524 Set the maximum number of bytes per memory write packet (deprecated)."),
7526 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
7527 Show the maximum number of bytes per memory write packet (deprecated)."),
7529 add_cmd ("memory-write-packet-size", no_class
,
7530 set_memory_write_packet_size
, _("\
7531 Set the maximum number of bytes per memory-write packet.\n\
7532 Specify the number of bytes in a packet or 0 (zero) for the\n\
7533 default packet size. The actual limit is further reduced\n\
7534 dependent on the target. Specify ``fixed'' to disable the\n\
7535 further restriction and ``limit'' to enable that restriction."),
7536 &remote_set_cmdlist
);
7537 add_cmd ("memory-read-packet-size", no_class
,
7538 set_memory_read_packet_size
, _("\
7539 Set the maximum number of bytes per memory-read packet.\n\
7540 Specify the number of bytes in a packet or 0 (zero) for the\n\
7541 default packet size. The actual limit is further reduced\n\
7542 dependent on the target. Specify ``fixed'' to disable the\n\
7543 further restriction and ``limit'' to enable that restriction."),
7544 &remote_set_cmdlist
);
7545 add_cmd ("memory-write-packet-size", no_class
,
7546 show_memory_write_packet_size
,
7547 _("Show the maximum number of bytes per memory-write packet."),
7548 &remote_show_cmdlist
);
7549 add_cmd ("memory-read-packet-size", no_class
,
7550 show_memory_read_packet_size
,
7551 _("Show the maximum number of bytes per memory-read packet."),
7552 &remote_show_cmdlist
);
7554 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
7555 &remote_hw_watchpoint_limit
, _("\
7556 Set the maximum number of target hardware watchpoints."), _("\
7557 Show the maximum number of target hardware watchpoints."), _("\
7558 Specify a negative limit for unlimited."),
7559 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
7560 &remote_set_cmdlist
, &remote_show_cmdlist
);
7561 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
7562 &remote_hw_breakpoint_limit
, _("\
7563 Set the maximum number of target hardware breakpoints."), _("\
7564 Show the maximum number of target hardware breakpoints."), _("\
7565 Specify a negative limit for unlimited."),
7566 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
7567 &remote_set_cmdlist
, &remote_show_cmdlist
);
7569 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
7570 &remote_address_size
, _("\
7571 Set the maximum size of the address (in bits) in a memory packet."), _("\
7572 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
7574 NULL
, /* FIXME: i18n: */
7575 &setlist
, &showlist
);
7577 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
7578 "X", "binary-download", 1);
7580 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
7581 "vCont", "verbose-resume", 0);
7583 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
7584 "QPassSignals", "pass-signals", 0);
7586 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
7587 "qSymbol", "symbol-lookup", 0);
7589 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
7590 "P", "set-register", 1);
7592 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
7593 "p", "fetch-register", 1);
7595 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
7596 "Z0", "software-breakpoint", 0);
7598 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
7599 "Z1", "hardware-breakpoint", 0);
7601 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
7602 "Z2", "write-watchpoint", 0);
7604 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
7605 "Z3", "read-watchpoint", 0);
7607 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
7608 "Z4", "access-watchpoint", 0);
7610 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
7611 "qXfer:auxv:read", "read-aux-vector", 0);
7613 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
7614 "qXfer:features:read", "target-features", 0);
7616 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
7617 "qXfer:libraries:read", "library-info", 0);
7619 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
7620 "qXfer:memory-map:read", "memory-map", 0);
7622 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
7623 "qXfer:spu:read", "read-spu-object", 0);
7625 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
7626 "qXfer:spu:write", "write-spu-object", 0);
7628 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
7629 "qGetTLSAddr", "get-thread-local-storage-address",
7632 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
7633 "qSupported", "supported-packets", 0);
7635 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
7636 "vFile:open", "hostio-open", 0);
7638 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
7639 "vFile:pread", "hostio-pread", 0);
7641 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
7642 "vFile:pwrite", "hostio-pwrite", 0);
7644 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
7645 "vFile:close", "hostio-close", 0);
7647 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
7648 "vFile:unlink", "hostio-unlink", 0);
7650 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
7651 "vAttach", "attach", 0);
7653 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
7656 /* Keep the old ``set remote Z-packet ...'' working. Each individual
7657 Z sub-packet has its own set and show commands, but users may
7658 have sets to this variable in their .gdbinit files (or in their
7660 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
7661 &remote_Z_packet_detect
, _("\
7662 Set use of remote protocol `Z' packets"), _("\
7663 Show use of remote protocol `Z' packets "), _("\
7664 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
7666 set_remote_protocol_Z_packet_cmd
,
7667 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
7668 &remote_set_cmdlist
, &remote_show_cmdlist
);
7670 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
7671 Manipulate files on the remote system\n\
7672 Transfer files to and from the remote target system."),
7673 &remote_cmdlist
, "remote ",
7674 0 /* allow-unknown */, &cmdlist
);
7676 add_cmd ("put", class_files
, remote_put_command
,
7677 _("Copy a local file to the remote system."),
7680 add_cmd ("get", class_files
, remote_get_command
,
7681 _("Copy a remote file to the local system."),
7684 add_cmd ("delete", class_files
, remote_delete_command
,
7685 _("Delete a remote file."),
7688 remote_exec_file
= xstrdup ("");
7689 add_setshow_string_noescape_cmd ("exec-file", class_files
,
7690 &remote_exec_file
, _("\
7691 Set the remote pathname for \"run\""), _("\
7692 Show the remote pathname for \"run\""), NULL
, NULL
, NULL
,
7693 &remote_set_cmdlist
, &remote_show_cmdlist
);
7695 /* Eventually initialize fileio. See fileio.c */
7696 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);