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
;
242 /* This data could be associated with a target, but we do not always
243 have access to the current target when we need it, so for now it is
244 static. This will be fine for as long as only one target is in use
246 static struct remote_state remote_state
;
248 static struct remote_state
*
249 get_remote_state_raw (void)
251 return &remote_state
;
254 /* Description of the remote protocol for a given architecture. */
258 long offset
; /* Offset into G packet. */
259 long regnum
; /* GDB's internal register number. */
260 LONGEST pnum
; /* Remote protocol register number. */
261 int in_g_packet
; /* Always part of G packet. */
262 /* long size in bytes; == register_size (current_gdbarch, regnum);
264 /* char *name; == gdbarch_register_name (current_gdbarch, regnum);
268 struct remote_arch_state
270 /* Description of the remote protocol registers. */
271 long sizeof_g_packet
;
273 /* Description of the remote protocol registers indexed by REGNUM
274 (making an array gdbarch_num_regs in size). */
275 struct packet_reg
*regs
;
277 /* This is the size (in chars) of the first response to the ``g''
278 packet. It is used as a heuristic when determining the maximum
279 size of memory-read and memory-write packets. A target will
280 typically only reserve a buffer large enough to hold the ``g''
281 packet. The size does not include packet overhead (headers and
283 long actual_register_packet_size
;
285 /* This is the maximum size (in chars) of a non read/write packet.
286 It is also used as a cap on the size of read/write packets. */
287 long remote_packet_size
;
291 /* Handle for retreving the remote protocol data from gdbarch. */
292 static struct gdbarch_data
*remote_gdbarch_data_handle
;
294 static struct remote_arch_state
*
295 get_remote_arch_state (void)
297 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
300 /* Fetch the global remote target state. */
302 static struct remote_state
*
303 get_remote_state (void)
305 /* Make sure that the remote architecture state has been
306 initialized, because doing so might reallocate rs->buf. Any
307 function which calls getpkt also needs to be mindful of changes
308 to rs->buf, but this call limits the number of places which run
310 get_remote_arch_state ();
312 return get_remote_state_raw ();
316 compare_pnums (const void *lhs_
, const void *rhs_
)
318 const struct packet_reg
* const *lhs
= lhs_
;
319 const struct packet_reg
* const *rhs
= rhs_
;
321 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
323 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
330 init_remote_state (struct gdbarch
*gdbarch
)
332 int regnum
, num_remote_regs
, offset
;
333 struct remote_state
*rs
= get_remote_state_raw ();
334 struct remote_arch_state
*rsa
;
335 struct packet_reg
**remote_regs
;
337 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
339 /* Use the architecture to build a regnum<->pnum table, which will be
340 1:1 unless a feature set specifies otherwise. */
341 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
342 gdbarch_num_regs (gdbarch
),
344 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
346 struct packet_reg
*r
= &rsa
->regs
[regnum
];
348 if (register_size (gdbarch
, regnum
) == 0)
349 /* Do not try to fetch zero-sized (placeholder) registers. */
352 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
357 /* Define the g/G packet format as the contents of each register
358 with a remote protocol number, in order of ascending protocol
361 remote_regs
= alloca (gdbarch_num_regs (gdbarch
)
362 * sizeof (struct packet_reg
*));
363 for (num_remote_regs
= 0, regnum
= 0;
364 regnum
< gdbarch_num_regs (gdbarch
);
366 if (rsa
->regs
[regnum
].pnum
!= -1)
367 remote_regs
[num_remote_regs
++] = &rsa
->regs
[regnum
];
369 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
372 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
374 remote_regs
[regnum
]->in_g_packet
= 1;
375 remote_regs
[regnum
]->offset
= offset
;
376 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
379 /* Record the maximum possible size of the g packet - it may turn out
381 rsa
->sizeof_g_packet
= offset
;
383 /* Default maximum number of characters in a packet body. Many
384 remote stubs have a hardwired buffer size of 400 bytes
385 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
386 as the maximum packet-size to ensure that the packet and an extra
387 NUL character can always fit in the buffer. This stops GDB
388 trashing stubs that try to squeeze an extra NUL into what is
389 already a full buffer (As of 1999-12-04 that was most stubs). */
390 rsa
->remote_packet_size
= 400 - 1;
392 /* This one is filled in when a ``g'' packet is received. */
393 rsa
->actual_register_packet_size
= 0;
395 /* Should rsa->sizeof_g_packet needs more space than the
396 default, adjust the size accordingly. Remember that each byte is
397 encoded as two characters. 32 is the overhead for the packet
398 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
399 (``$NN:G...#NN'') is a better guess, the below has been padded a
401 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
402 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
404 /* Make sure that the packet buffer is plenty big enough for
405 this architecture. */
406 if (rs
->buf_size
< rsa
->remote_packet_size
)
408 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
409 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
415 /* Return the current allowed size of a remote packet. This is
416 inferred from the current architecture, and should be used to
417 limit the length of outgoing packets. */
419 get_remote_packet_size (void)
421 struct remote_state
*rs
= get_remote_state ();
422 struct remote_arch_state
*rsa
= get_remote_arch_state ();
424 if (rs
->explicit_packet_size
)
425 return rs
->explicit_packet_size
;
427 return rsa
->remote_packet_size
;
430 static struct packet_reg
*
431 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
433 if (regnum
< 0 && regnum
>= gdbarch_num_regs (current_gdbarch
))
437 struct packet_reg
*r
= &rsa
->regs
[regnum
];
438 gdb_assert (r
->regnum
== regnum
);
443 static struct packet_reg
*
444 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
447 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
449 struct packet_reg
*r
= &rsa
->regs
[i
];
456 /* FIXME: graces/2002-08-08: These variables should eventually be
457 bound to an instance of the target object (as in gdbarch-tdep()),
458 when such a thing exists. */
460 /* This is set to the data address of the access causing the target
461 to stop for a watchpoint. */
462 static CORE_ADDR remote_watch_data_address
;
464 /* This is non-zero if target stopped for a watchpoint. */
465 static int remote_stopped_by_watchpoint_p
;
467 static struct target_ops remote_ops
;
469 static struct target_ops extended_remote_ops
;
471 /* Temporary target ops. Just like the remote_ops and
472 extended_remote_ops, but with asynchronous support. */
473 static struct target_ops remote_async_ops
;
475 static struct target_ops extended_async_remote_ops
;
477 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
478 ``forever'' still use the normal timeout mechanism. This is
479 currently used by the ASYNC code to guarentee that target reads
480 during the initial connect always time-out. Once getpkt has been
481 modified to return a timeout indication and, in turn
482 remote_wait()/wait_for_inferior() have gained a timeout parameter
484 static int wait_forever_enabled_p
= 1;
487 /* This variable chooses whether to send a ^C or a break when the user
488 requests program interruption. Although ^C is usually what remote
489 systems expect, and that is the default here, sometimes a break is
490 preferable instead. */
492 static int remote_break
;
494 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
495 remote_open knows that we don't have a file open when the program
497 static struct serial
*remote_desc
= NULL
;
499 /* This variable sets the number of bits in an address that are to be
500 sent in a memory ("M" or "m") packet. Normally, after stripping
501 leading zeros, the entire address would be sent. This variable
502 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
503 initial implementation of remote.c restricted the address sent in
504 memory packets to ``host::sizeof long'' bytes - (typically 32
505 bits). Consequently, for 64 bit targets, the upper 32 bits of an
506 address was never sent. Since fixing this bug may cause a break in
507 some remote targets this variable is principly provided to
508 facilitate backward compatibility. */
510 static int remote_address_size
;
512 /* Tempoary to track who currently owns the terminal. See
513 target_async_terminal_* for more details. */
515 static int remote_async_terminal_ours_p
;
518 /* User configurable variables for the number of characters in a
519 memory read/write packet. MIN (rsa->remote_packet_size,
520 rsa->sizeof_g_packet) is the default. Some targets need smaller
521 values (fifo overruns, et.al.) and some users need larger values
522 (speed up transfers). The variables ``preferred_*'' (the user
523 request), ``current_*'' (what was actually set) and ``forced_*''
524 (Positive - a soft limit, negative - a hard limit). */
526 struct memory_packet_config
533 /* Compute the current size of a read/write packet. Since this makes
534 use of ``actual_register_packet_size'' the computation is dynamic. */
537 get_memory_packet_size (struct memory_packet_config
*config
)
539 struct remote_state
*rs
= get_remote_state ();
540 struct remote_arch_state
*rsa
= get_remote_arch_state ();
542 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
543 law?) that some hosts don't cope very well with large alloca()
544 calls. Eventually the alloca() code will be replaced by calls to
545 xmalloc() and make_cleanups() allowing this restriction to either
546 be lifted or removed. */
547 #ifndef MAX_REMOTE_PACKET_SIZE
548 #define MAX_REMOTE_PACKET_SIZE 16384
550 /* NOTE: 20 ensures we can write at least one byte. */
551 #ifndef MIN_REMOTE_PACKET_SIZE
552 #define MIN_REMOTE_PACKET_SIZE 20
557 if (config
->size
<= 0)
558 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
560 what_they_get
= config
->size
;
564 what_they_get
= get_remote_packet_size ();
565 /* Limit the packet to the size specified by the user. */
567 && what_they_get
> config
->size
)
568 what_they_get
= config
->size
;
570 /* Limit it to the size of the targets ``g'' response unless we have
571 permission from the stub to use a larger packet size. */
572 if (rs
->explicit_packet_size
== 0
573 && rsa
->actual_register_packet_size
> 0
574 && what_they_get
> rsa
->actual_register_packet_size
)
575 what_they_get
= rsa
->actual_register_packet_size
;
577 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
578 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
579 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
580 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
582 /* Make sure there is room in the global buffer for this packet
583 (including its trailing NUL byte). */
584 if (rs
->buf_size
< what_they_get
+ 1)
586 rs
->buf_size
= 2 * what_they_get
;
587 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
590 return what_they_get
;
593 /* Update the size of a read/write packet. If they user wants
594 something really big then do a sanity check. */
597 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
599 int fixed_p
= config
->fixed_p
;
600 long size
= config
->size
;
602 error (_("Argument required (integer, `fixed' or `limited')."));
603 else if (strcmp (args
, "hard") == 0
604 || strcmp (args
, "fixed") == 0)
606 else if (strcmp (args
, "soft") == 0
607 || strcmp (args
, "limit") == 0)
612 size
= strtoul (args
, &end
, 0);
614 error (_("Invalid %s (bad syntax)."), config
->name
);
616 /* Instead of explicitly capping the size of a packet to
617 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
618 instead allowed to set the size to something arbitrarily
620 if (size
> MAX_REMOTE_PACKET_SIZE
)
621 error (_("Invalid %s (too large)."), config
->name
);
625 if (fixed_p
&& !config
->fixed_p
)
627 if (! query (_("The target may not be able to correctly handle a %s\n"
628 "of %ld bytes. Change the packet size? "),
630 error (_("Packet size not changed."));
632 /* Update the config. */
633 config
->fixed_p
= fixed_p
;
638 show_memory_packet_size (struct memory_packet_config
*config
)
640 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
642 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
643 get_memory_packet_size (config
));
645 printf_filtered (_("Packets are limited to %ld bytes.\n"),
646 get_memory_packet_size (config
));
649 static struct memory_packet_config memory_write_packet_config
=
651 "memory-write-packet-size",
655 set_memory_write_packet_size (char *args
, int from_tty
)
657 set_memory_packet_size (args
, &memory_write_packet_config
);
661 show_memory_write_packet_size (char *args
, int from_tty
)
663 show_memory_packet_size (&memory_write_packet_config
);
667 get_memory_write_packet_size (void)
669 return get_memory_packet_size (&memory_write_packet_config
);
672 static struct memory_packet_config memory_read_packet_config
=
674 "memory-read-packet-size",
678 set_memory_read_packet_size (char *args
, int from_tty
)
680 set_memory_packet_size (args
, &memory_read_packet_config
);
684 show_memory_read_packet_size (char *args
, int from_tty
)
686 show_memory_packet_size (&memory_read_packet_config
);
690 get_memory_read_packet_size (void)
692 long size
= get_memory_packet_size (&memory_read_packet_config
);
693 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
694 extra buffer size argument before the memory read size can be
695 increased beyond this. */
696 if (size
> get_remote_packet_size ())
697 size
= get_remote_packet_size ();
702 /* Generic configuration support for packets the stub optionally
703 supports. Allows the user to specify the use of the packet as well
704 as allowing GDB to auto-detect support in the remote stub. */
708 PACKET_SUPPORT_UNKNOWN
= 0,
717 enum auto_boolean detect
;
718 enum packet_support support
;
721 /* Analyze a packet's return value and update the packet config
732 update_packet_config (struct packet_config
*config
)
734 switch (config
->detect
)
736 case AUTO_BOOLEAN_TRUE
:
737 config
->support
= PACKET_ENABLE
;
739 case AUTO_BOOLEAN_FALSE
:
740 config
->support
= PACKET_DISABLE
;
742 case AUTO_BOOLEAN_AUTO
:
743 config
->support
= PACKET_SUPPORT_UNKNOWN
;
749 show_packet_config_cmd (struct packet_config
*config
)
751 char *support
= "internal-error";
752 switch (config
->support
)
758 support
= "disabled";
760 case PACKET_SUPPORT_UNKNOWN
:
764 switch (config
->detect
)
766 case AUTO_BOOLEAN_AUTO
:
767 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
768 config
->name
, support
);
770 case AUTO_BOOLEAN_TRUE
:
771 case AUTO_BOOLEAN_FALSE
:
772 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
773 config
->name
, support
);
779 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
780 const char *title
, int legacy
)
787 config
->title
= title
;
788 config
->detect
= AUTO_BOOLEAN_AUTO
;
789 config
->support
= PACKET_SUPPORT_UNKNOWN
;
790 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
792 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
794 /* set/show TITLE-packet {auto,on,off} */
795 cmd_name
= xstrprintf ("%s-packet", title
);
796 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
797 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
798 set_remote_protocol_packet_cmd
,
799 show_remote_protocol_packet_cmd
,
800 &remote_set_cmdlist
, &remote_show_cmdlist
);
801 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
805 legacy_name
= xstrprintf ("%s-packet", name
);
806 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
807 &remote_set_cmdlist
);
808 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
809 &remote_show_cmdlist
);
813 static enum packet_result
814 packet_check_result (const char *buf
)
818 /* The stub recognized the packet request. Check that the
819 operation succeeded. */
821 && isxdigit (buf
[1]) && isxdigit (buf
[2])
823 /* "Enn" - definitly an error. */
826 /* Always treat "E." as an error. This will be used for
827 more verbose error messages, such as E.memtypes. */
828 if (buf
[0] == 'E' && buf
[1] == '.')
831 /* The packet may or may not be OK. Just assume it is. */
835 /* The stub does not support the packet. */
836 return PACKET_UNKNOWN
;
839 static enum packet_result
840 packet_ok (const char *buf
, struct packet_config
*config
)
842 enum packet_result result
;
844 result
= packet_check_result (buf
);
849 /* The stub recognized the packet request. */
850 switch (config
->support
)
852 case PACKET_SUPPORT_UNKNOWN
:
854 fprintf_unfiltered (gdb_stdlog
,
855 "Packet %s (%s) is supported\n",
856 config
->name
, config
->title
);
857 config
->support
= PACKET_ENABLE
;
860 internal_error (__FILE__
, __LINE__
,
861 _("packet_ok: attempt to use a disabled packet"));
868 /* The stub does not support the packet. */
869 switch (config
->support
)
872 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
873 /* If the stub previously indicated that the packet was
874 supported then there is a protocol error.. */
875 error (_("Protocol error: %s (%s) conflicting enabled responses."),
876 config
->name
, config
->title
);
878 /* The user set it wrong. */
879 error (_("Enabled packet %s (%s) not recognized by stub"),
880 config
->name
, config
->title
);
882 case PACKET_SUPPORT_UNKNOWN
:
884 fprintf_unfiltered (gdb_stdlog
,
885 "Packet %s (%s) is NOT supported\n",
886 config
->name
, config
->title
);
887 config
->support
= PACKET_DISABLE
;
915 PACKET_qXfer_features
,
916 PACKET_qXfer_libraries
,
917 PACKET_qXfer_memory_map
,
918 PACKET_qXfer_spu_read
,
919 PACKET_qXfer_spu_write
,
926 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
929 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
930 struct cmd_list_element
*c
)
932 struct packet_config
*packet
;
934 for (packet
= remote_protocol_packets
;
935 packet
< &remote_protocol_packets
[PACKET_MAX
];
938 if (&packet
->detect
== c
->var
)
940 update_packet_config (packet
);
944 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
949 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
950 struct cmd_list_element
*c
,
953 struct packet_config
*packet
;
955 for (packet
= remote_protocol_packets
;
956 packet
< &remote_protocol_packets
[PACKET_MAX
];
959 if (&packet
->detect
== c
->var
)
961 show_packet_config_cmd (packet
);
965 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
969 /* Should we try one of the 'Z' requests? */
973 Z_PACKET_SOFTWARE_BP
,
974 Z_PACKET_HARDWARE_BP
,
981 /* For compatibility with older distributions. Provide a ``set remote
982 Z-packet ...'' command that updates all the Z packet types. */
984 static enum auto_boolean remote_Z_packet_detect
;
987 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
988 struct cmd_list_element
*c
)
991 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
993 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
994 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
999 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
1000 struct cmd_list_element
*c
,
1004 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1006 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1010 /* Should we try the 'ThreadInfo' query packet?
1012 This variable (NOT available to the user: auto-detect only!)
1013 determines whether GDB will use the new, simpler "ThreadInfo"
1014 query or the older, more complex syntax for thread queries.
1015 This is an auto-detect variable (set to true at each connect,
1016 and set to false when the target fails to recognize it). */
1018 static int use_threadinfo_query
;
1019 static int use_threadextra_query
;
1021 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1022 static struct async_signal_handler
*sigint_remote_twice_token
;
1023 static struct async_signal_handler
*sigint_remote_token
;
1025 /* These are pointers to hook functions that may be set in order to
1026 modify resume/wait behavior for a particular architecture. */
1028 void (*deprecated_target_resume_hook
) (void);
1029 void (*deprecated_target_wait_loop_hook
) (void);
1033 /* These are the threads which we last sent to the remote system.
1034 -1 for all or -2 for not sent yet. */
1035 static int general_thread
;
1036 static int continue_thread
;
1038 /* Call this function as a result of
1039 1) A halt indication (T packet) containing a thread id
1040 2) A direct query of currthread
1041 3) Successful execution of set thread
1045 record_currthread (int currthread
)
1047 general_thread
= currthread
;
1049 /* If this is a new thread, add it to GDB's thread list.
1050 If we leave it up to WFI to do this, bad things will happen. */
1051 if (!in_thread_list (pid_to_ptid (currthread
)))
1052 add_thread (pid_to_ptid (currthread
));
1055 static char *last_pass_packet
;
1057 /* If 'QPassSignals' is supported, tell the remote stub what signals
1058 it can simply pass through to the inferior without reporting. */
1061 remote_pass_signals (void)
1063 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1065 char *pass_packet
, *p
;
1066 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1069 gdb_assert (numsigs
< 256);
1070 for (i
= 0; i
< numsigs
; i
++)
1072 if (signal_stop_state (i
) == 0
1073 && signal_print_state (i
) == 0
1074 && signal_pass_state (i
) == 1)
1077 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1078 strcpy (pass_packet
, "QPassSignals:");
1079 p
= pass_packet
+ strlen (pass_packet
);
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 *p
++ = tohex (i
>> 4);
1088 *p
++ = tohex (i
& 15);
1097 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1099 struct remote_state
*rs
= get_remote_state ();
1100 char *buf
= rs
->buf
;
1102 putpkt (pass_packet
);
1103 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1104 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1105 if (last_pass_packet
)
1106 xfree (last_pass_packet
);
1107 last_pass_packet
= pass_packet
;
1110 xfree (pass_packet
);
1114 #define MAGIC_NULL_PID 42000
1117 set_thread (int th
, int gen
)
1119 struct remote_state
*rs
= get_remote_state ();
1120 char *buf
= rs
->buf
;
1121 int state
= gen
? general_thread
: continue_thread
;
1127 buf
[1] = gen
? 'g' : 'c';
1128 if (th
== MAGIC_NULL_PID
)
1134 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
1136 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
1138 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1140 general_thread
= th
;
1142 continue_thread
= th
;
1145 /* Return nonzero if the thread TH is still alive on the remote system. */
1148 remote_thread_alive (ptid_t ptid
)
1150 struct remote_state
*rs
= get_remote_state ();
1151 int tid
= PIDGET (ptid
);
1154 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1156 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1158 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1159 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1162 /* About these extended threadlist and threadinfo packets. They are
1163 variable length packets but, the fields within them are often fixed
1164 length. They are redundent enough to send over UDP as is the
1165 remote protocol in general. There is a matching unit test module
1168 #define OPAQUETHREADBYTES 8
1170 /* a 64 bit opaque identifier */
1171 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1173 /* WARNING: This threadref data structure comes from the remote O.S.,
1174 libstub protocol encoding, and remote.c. it is not particularly
1177 /* Right now, the internal structure is int. We want it to be bigger.
1181 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1183 /* gdb_ext_thread_info is an internal GDB data structure which is
1184 equivalent to the reply of the remote threadinfo packet. */
1186 struct gdb_ext_thread_info
1188 threadref threadid
; /* External form of thread reference. */
1189 int active
; /* Has state interesting to GDB?
1191 char display
[256]; /* Brief state display, name,
1192 blocked/suspended. */
1193 char shortname
[32]; /* To be used to name threads. */
1194 char more_display
[256]; /* Long info, statistics, queue depth,
1198 /* The volume of remote transfers can be limited by submitting
1199 a mask containing bits specifying the desired information.
1200 Use a union of these values as the 'selection' parameter to
1201 get_thread_info. FIXME: Make these TAG names more thread specific.
1204 #define TAG_THREADID 1
1205 #define TAG_EXISTS 2
1206 #define TAG_DISPLAY 4
1207 #define TAG_THREADNAME 8
1208 #define TAG_MOREDISPLAY 16
1210 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1212 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1214 static char *unpack_nibble (char *buf
, int *val
);
1216 static char *pack_nibble (char *buf
, int nibble
);
1218 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1220 static char *unpack_byte (char *buf
, int *value
);
1222 static char *pack_int (char *buf
, int value
);
1224 static char *unpack_int (char *buf
, int *value
);
1226 static char *unpack_string (char *src
, char *dest
, int length
);
1228 static char *pack_threadid (char *pkt
, threadref
*id
);
1230 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1232 void int_to_threadref (threadref
*id
, int value
);
1234 static int threadref_to_int (threadref
*ref
);
1236 static void copy_threadref (threadref
*dest
, threadref
*src
);
1238 static int threadmatch (threadref
*dest
, threadref
*src
);
1240 static char *pack_threadinfo_request (char *pkt
, int mode
,
1243 static int remote_unpack_thread_info_response (char *pkt
,
1244 threadref
*expectedref
,
1245 struct gdb_ext_thread_info
1249 static int remote_get_threadinfo (threadref
*threadid
,
1250 int fieldset
, /*TAG mask */
1251 struct gdb_ext_thread_info
*info
);
1253 static char *pack_threadlist_request (char *pkt
, int startflag
,
1255 threadref
*nextthread
);
1257 static int parse_threadlist_response (char *pkt
,
1259 threadref
*original_echo
,
1260 threadref
*resultlist
,
1263 static int remote_get_threadlist (int startflag
,
1264 threadref
*nextthread
,
1268 threadref
*threadlist
);
1270 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1272 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1273 void *context
, int looplimit
);
1275 static int remote_newthread_step (threadref
*ref
, void *context
);
1277 /* Encode 64 bits in 16 chars of hex. */
1279 static const char hexchars
[] = "0123456789abcdef";
1282 ishex (int ch
, int *val
)
1284 if ((ch
>= 'a') && (ch
<= 'f'))
1286 *val
= ch
- 'a' + 10;
1289 if ((ch
>= 'A') && (ch
<= 'F'))
1291 *val
= ch
- 'A' + 10;
1294 if ((ch
>= '0') && (ch
<= '9'))
1305 if (ch
>= 'a' && ch
<= 'f')
1306 return ch
- 'a' + 10;
1307 if (ch
>= '0' && ch
<= '9')
1309 if (ch
>= 'A' && ch
<= 'F')
1310 return ch
- 'A' + 10;
1315 stub_unpack_int (char *buff
, int fieldlength
)
1322 nibble
= stubhex (*buff
++);
1326 retval
= retval
<< 4;
1332 unpack_varlen_hex (char *buff
, /* packet to parse */
1336 ULONGEST retval
= 0;
1338 while (ishex (*buff
, &nibble
))
1341 retval
= retval
<< 4;
1342 retval
|= nibble
& 0x0f;
1349 unpack_nibble (char *buf
, int *val
)
1351 *val
= fromhex (*buf
++);
1356 pack_nibble (char *buf
, int nibble
)
1358 *buf
++ = hexchars
[(nibble
& 0x0f)];
1363 pack_hex_byte (char *pkt
, int byte
)
1365 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1366 *pkt
++ = hexchars
[(byte
& 0xf)];
1371 unpack_byte (char *buf
, int *value
)
1373 *value
= stub_unpack_int (buf
, 2);
1378 pack_int (char *buf
, int value
)
1380 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1381 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1382 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1383 buf
= pack_hex_byte (buf
, (value
& 0xff));
1388 unpack_int (char *buf
, int *value
)
1390 *value
= stub_unpack_int (buf
, 8);
1394 #if 0 /* Currently unused, uncomment when needed. */
1395 static char *pack_string (char *pkt
, char *string
);
1398 pack_string (char *pkt
, char *string
)
1403 len
= strlen (string
);
1405 len
= 200; /* Bigger than most GDB packets, junk??? */
1406 pkt
= pack_hex_byte (pkt
, len
);
1410 if ((ch
== '\0') || (ch
== '#'))
1411 ch
= '*'; /* Protect encapsulation. */
1416 #endif /* 0 (unused) */
1419 unpack_string (char *src
, char *dest
, int length
)
1428 pack_threadid (char *pkt
, threadref
*id
)
1431 unsigned char *altid
;
1433 altid
= (unsigned char *) id
;
1434 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1436 pkt
= pack_hex_byte (pkt
, *altid
++);
1442 unpack_threadid (char *inbuf
, threadref
*id
)
1445 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1448 altref
= (char *) id
;
1450 while (inbuf
< limit
)
1452 x
= stubhex (*inbuf
++);
1453 y
= stubhex (*inbuf
++);
1454 *altref
++ = (x
<< 4) | y
;
1459 /* Externally, threadrefs are 64 bits but internally, they are still
1460 ints. This is due to a mismatch of specifications. We would like
1461 to use 64bit thread references internally. This is an adapter
1465 int_to_threadref (threadref
*id
, int value
)
1467 unsigned char *scan
;
1469 scan
= (unsigned char *) id
;
1475 *scan
++ = (value
>> 24) & 0xff;
1476 *scan
++ = (value
>> 16) & 0xff;
1477 *scan
++ = (value
>> 8) & 0xff;
1478 *scan
++ = (value
& 0xff);
1482 threadref_to_int (threadref
*ref
)
1485 unsigned char *scan
;
1491 value
= (value
<< 8) | ((*scan
++) & 0xff);
1496 copy_threadref (threadref
*dest
, threadref
*src
)
1499 unsigned char *csrc
, *cdest
;
1501 csrc
= (unsigned char *) src
;
1502 cdest
= (unsigned char *) dest
;
1509 threadmatch (threadref
*dest
, threadref
*src
)
1511 /* Things are broken right now, so just assume we got a match. */
1513 unsigned char *srcp
, *destp
;
1515 srcp
= (char *) src
;
1516 destp
= (char *) dest
;
1520 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1527 threadid:1, # always request threadid
1534 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1537 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1539 *pkt
++ = 'q'; /* Info Query */
1540 *pkt
++ = 'P'; /* process or thread info */
1541 pkt
= pack_int (pkt
, mode
); /* mode */
1542 pkt
= pack_threadid (pkt
, id
); /* threadid */
1543 *pkt
= '\0'; /* terminate */
1547 /* These values tag the fields in a thread info response packet. */
1548 /* Tagging the fields allows us to request specific fields and to
1549 add more fields as time goes by. */
1551 #define TAG_THREADID 1 /* Echo the thread identifier. */
1552 #define TAG_EXISTS 2 /* Is this process defined enough to
1553 fetch registers and its stack? */
1554 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1555 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1556 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1560 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1561 struct gdb_ext_thread_info
*info
)
1563 struct remote_state
*rs
= get_remote_state ();
1567 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1570 /* info->threadid = 0; FIXME: implement zero_threadref. */
1572 info
->display
[0] = '\0';
1573 info
->shortname
[0] = '\0';
1574 info
->more_display
[0] = '\0';
1576 /* Assume the characters indicating the packet type have been
1578 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1579 pkt
= unpack_threadid (pkt
, &ref
);
1582 warning (_("Incomplete response to threadinfo request."));
1583 if (!threadmatch (&ref
, expectedref
))
1584 { /* This is an answer to a different request. */
1585 warning (_("ERROR RMT Thread info mismatch."));
1588 copy_threadref (&info
->threadid
, &ref
);
1590 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1592 /* Packets are terminated with nulls. */
1593 while ((pkt
< limit
) && mask
&& *pkt
)
1595 pkt
= unpack_int (pkt
, &tag
); /* tag */
1596 pkt
= unpack_byte (pkt
, &length
); /* length */
1597 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1599 warning (_("ERROR RMT: threadinfo tag mismatch."));
1603 if (tag
== TAG_THREADID
)
1607 warning (_("ERROR RMT: length of threadid is not 16."));
1611 pkt
= unpack_threadid (pkt
, &ref
);
1612 mask
= mask
& ~TAG_THREADID
;
1615 if (tag
== TAG_EXISTS
)
1617 info
->active
= stub_unpack_int (pkt
, length
);
1619 mask
= mask
& ~(TAG_EXISTS
);
1622 warning (_("ERROR RMT: 'exists' length too long."));
1628 if (tag
== TAG_THREADNAME
)
1630 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1631 mask
= mask
& ~TAG_THREADNAME
;
1634 if (tag
== TAG_DISPLAY
)
1636 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1637 mask
= mask
& ~TAG_DISPLAY
;
1640 if (tag
== TAG_MOREDISPLAY
)
1642 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1643 mask
= mask
& ~TAG_MOREDISPLAY
;
1646 warning (_("ERROR RMT: unknown thread info tag."));
1647 break; /* Not a tag we know about. */
1653 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1654 struct gdb_ext_thread_info
*info
)
1656 struct remote_state
*rs
= get_remote_state ();
1659 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1661 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1662 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1667 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1670 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1671 threadref
*nextthread
)
1673 *pkt
++ = 'q'; /* info query packet */
1674 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1675 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1676 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1677 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1682 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1685 parse_threadlist_response (char *pkt
, int result_limit
,
1686 threadref
*original_echo
, threadref
*resultlist
,
1689 struct remote_state
*rs
= get_remote_state ();
1691 int count
, resultcount
, done
;
1694 /* Assume the 'q' and 'M chars have been stripped. */
1695 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1696 /* done parse past here */
1697 pkt
= unpack_byte (pkt
, &count
); /* count field */
1698 pkt
= unpack_nibble (pkt
, &done
);
1699 /* The first threadid is the argument threadid. */
1700 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1701 while ((count
-- > 0) && (pkt
< limit
))
1703 pkt
= unpack_threadid (pkt
, resultlist
++);
1704 if (resultcount
++ >= result_limit
)
1713 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1714 int *done
, int *result_count
, threadref
*threadlist
)
1716 struct remote_state
*rs
= get_remote_state ();
1717 static threadref echo_nextthread
;
1720 /* Trancate result limit to be smaller than the packet size. */
1721 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1722 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1724 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1726 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1729 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1732 if (!threadmatch (&echo_nextthread
, nextthread
))
1734 /* FIXME: This is a good reason to drop the packet. */
1735 /* Possably, there is a duplicate response. */
1737 retransmit immediatly - race conditions
1738 retransmit after timeout - yes
1740 wait for packet, then exit
1742 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1743 return 0; /* I choose simply exiting. */
1745 if (*result_count
<= 0)
1749 warning (_("RMT ERROR : failed to get remote thread list."));
1752 return result
; /* break; */
1754 if (*result_count
> result_limit
)
1757 warning (_("RMT ERROR: threadlist response longer than requested."));
1763 /* This is the interface between remote and threads, remotes upper
1766 /* remote_find_new_threads retrieves the thread list and for each
1767 thread in the list, looks up the thread in GDB's internal list,
1768 ading the thread if it does not already exist. This involves
1769 getting partial thread lists from the remote target so, polling the
1770 quit_flag is required. */
1773 /* About this many threadisds fit in a packet. */
1775 #define MAXTHREADLISTRESULTS 32
1778 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1781 int done
, i
, result_count
;
1785 static threadref nextthread
;
1786 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1791 if (loopcount
++ > looplimit
)
1794 warning (_("Remote fetch threadlist -infinite loop-."));
1797 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1798 &done
, &result_count
, resultthreadlist
))
1803 /* Clear for later iterations. */
1805 /* Setup to resume next batch of thread references, set nextthread. */
1806 if (result_count
>= 1)
1807 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1809 while (result_count
--)
1810 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1817 remote_newthread_step (threadref
*ref
, void *context
)
1821 ptid
= pid_to_ptid (threadref_to_int (ref
));
1823 if (!in_thread_list (ptid
))
1825 return 1; /* continue iterator */
1828 #define CRAZY_MAX_THREADS 1000
1831 remote_current_thread (ptid_t oldpid
)
1833 struct remote_state
*rs
= get_remote_state ();
1836 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1837 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1838 /* Use strtoul here, so we'll correctly parse values whose highest
1839 bit is set. The protocol carries them as a simple series of
1840 hex digits; in the absence of a sign, strtol will see such
1841 values as positive numbers out of range for signed 'long', and
1842 return LONG_MAX to indicate an overflow. */
1843 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1848 /* Find new threads for info threads command.
1849 * Original version, using John Metzler's thread protocol.
1853 remote_find_new_threads (void)
1855 remote_threadlist_iterator (remote_newthread_step
, 0,
1857 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1858 inferior_ptid
= remote_current_thread (inferior_ptid
);
1862 * Find all threads for info threads command.
1863 * Uses new thread protocol contributed by Cisco.
1864 * Falls back and attempts to use the older method (above)
1865 * if the target doesn't respond to the new method.
1869 remote_threads_info (void)
1871 struct remote_state
*rs
= get_remote_state ();
1875 if (remote_desc
== 0) /* paranoia */
1876 error (_("Command can only be used when connected to the remote target."));
1878 if (use_threadinfo_query
)
1880 putpkt ("qfThreadInfo");
1881 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1883 if (bufp
[0] != '\0') /* q packet recognized */
1885 while (*bufp
++ == 'm') /* reply contains one or more TID */
1889 /* Use strtoul here, so we'll correctly parse values
1890 whose highest bit is set. The protocol carries
1891 them as a simple series of hex digits; in the
1892 absence of a sign, strtol will see such values as
1893 positive numbers out of range for signed 'long',
1894 and return LONG_MAX to indicate an overflow. */
1895 tid
= strtoul (bufp
, &bufp
, 16);
1896 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1897 add_thread (pid_to_ptid (tid
));
1899 while (*bufp
++ == ','); /* comma-separated list */
1900 putpkt ("qsThreadInfo");
1901 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1908 /* Else fall back to old method based on jmetzler protocol. */
1909 use_threadinfo_query
= 0;
1910 remote_find_new_threads ();
1915 * Collect a descriptive string about the given thread.
1916 * The target may say anything it wants to about the thread
1917 * (typically info about its blocked / runnable state, name, etc.).
1918 * This string will appear in the info threads display.
1920 * Optional: targets are not required to implement this function.
1924 remote_threads_extra_info (struct thread_info
*tp
)
1926 struct remote_state
*rs
= get_remote_state ();
1930 struct gdb_ext_thread_info threadinfo
;
1931 static char display_buf
[100]; /* arbitrary... */
1932 int n
= 0; /* position in display_buf */
1934 if (remote_desc
== 0) /* paranoia */
1935 internal_error (__FILE__
, __LINE__
,
1936 _("remote_threads_extra_info"));
1938 if (use_threadextra_query
)
1940 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1943 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1944 if (rs
->buf
[0] != 0)
1946 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1947 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1948 display_buf
[result
] = '\0';
1953 /* If the above query fails, fall back to the old method. */
1954 use_threadextra_query
= 0;
1955 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1956 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1957 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1958 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1959 if (threadinfo
.active
)
1961 if (*threadinfo
.shortname
)
1962 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1963 " Name: %s,", threadinfo
.shortname
);
1964 if (*threadinfo
.display
)
1965 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1966 " State: %s,", threadinfo
.display
);
1967 if (*threadinfo
.more_display
)
1968 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1969 " Priority: %s", threadinfo
.more_display
);
1973 /* For purely cosmetic reasons, clear up trailing commas. */
1974 if (',' == display_buf
[n
-1])
1975 display_buf
[n
-1] = ' ';
1983 /* Restart the remote side; this is an extended protocol operation. */
1986 extended_remote_restart (void)
1988 struct remote_state
*rs
= get_remote_state ();
1990 /* Send the restart command; for reasons I don't understand the
1991 remote side really expects a number after the "R". */
1992 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1995 remote_fileio_reset ();
1997 /* Now query for status so this looks just like we restarted
1998 gdbserver from scratch. */
2000 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2003 /* Clean up connection to a remote debugger. */
2006 remote_close (int quitting
)
2009 serial_close (remote_desc
);
2013 /* Query the remote side for the text, data and bss offsets. */
2018 struct remote_state
*rs
= get_remote_state ();
2021 int lose
, num_segments
= 0, do_sections
, do_segments
;
2022 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
2023 struct section_offsets
*offs
;
2024 struct symfile_segment_data
*data
;
2026 if (symfile_objfile
== NULL
)
2029 putpkt ("qOffsets");
2030 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2033 if (buf
[0] == '\000')
2034 return; /* Return silently. Stub doesn't support
2038 warning (_("Remote failure reply: %s"), buf
);
2042 /* Pick up each field in turn. This used to be done with scanf, but
2043 scanf will make trouble if CORE_ADDR size doesn't match
2044 conversion directives correctly. The following code will work
2045 with any size of CORE_ADDR. */
2046 text_addr
= data_addr
= bss_addr
= 0;
2050 if (strncmp (ptr
, "Text=", 5) == 0)
2053 /* Don't use strtol, could lose on big values. */
2054 while (*ptr
&& *ptr
!= ';')
2055 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2057 if (strncmp (ptr
, ";Data=", 6) == 0)
2060 while (*ptr
&& *ptr
!= ';')
2061 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2066 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2069 while (*ptr
&& *ptr
!= ';')
2070 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2072 if (bss_addr
!= data_addr
)
2073 warning (_("Target reported unsupported offsets: %s"), buf
);
2078 else if (strncmp (ptr
, "TextSeg=", 8) == 0)
2081 /* Don't use strtol, could lose on big values. */
2082 while (*ptr
&& *ptr
!= ';')
2083 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2086 if (strncmp (ptr
, ";DataSeg=", 9) == 0)
2089 while (*ptr
&& *ptr
!= ';')
2090 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2098 error (_("Malformed response to offset query, %s"), buf
);
2099 else if (*ptr
!= '\0')
2100 warning (_("Target reported unsupported offsets: %s"), buf
);
2102 offs
= ((struct section_offsets
*)
2103 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2104 memcpy (offs
, symfile_objfile
->section_offsets
,
2105 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2107 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
2108 do_segments
= (data
!= NULL
);
2109 do_sections
= num_segments
== 0;
2111 if (num_segments
> 0)
2113 segments
[0] = text_addr
;
2114 segments
[1] = data_addr
;
2116 /* If we have two segments, we can still try to relocate everything
2117 by assuming that the .text and .data offsets apply to the whole
2118 text and data segments. Convert the offsets given in the packet
2119 to base addresses for symfile_map_offsets_to_segments. */
2120 else if (data
&& data
->num_segments
== 2)
2122 segments
[0] = data
->segment_bases
[0] + text_addr
;
2123 segments
[1] = data
->segment_bases
[1] + data_addr
;
2126 /* There's no way to relocate by segment. */
2132 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
2133 offs
, num_segments
, segments
);
2135 if (ret
== 0 && !do_sections
)
2136 error (_("Can not handle qOffsets TextSeg response with this symbol file"));
2143 free_symfile_segment_data (data
);
2147 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2149 /* This is a temporary kludge to force data and bss to use the same offsets
2150 because that's what nlmconv does now. The real solution requires changes
2151 to the stub and remote.c that I don't have time to do right now. */
2153 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2154 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2157 objfile_relocate (symfile_objfile
, offs
);
2160 /* Stub for catch_exception. */
2163 remote_start_remote (struct ui_out
*uiout
, void *from_tty_p
)
2165 int from_tty
= * (int *) from_tty_p
;
2167 immediate_quit
++; /* Allow user to interrupt it. */
2169 /* Ack any packet which the remote side has already sent. */
2170 serial_write (remote_desc
, "+", 1);
2172 /* Let the stub know that we want it to return the thread. */
2175 inferior_ptid
= remote_current_thread (inferior_ptid
);
2177 get_offsets (); /* Get text, data & bss offsets. */
2179 putpkt ("?"); /* Initiate a query from remote machine. */
2182 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
2185 /* Open a connection to a remote debugger.
2186 NAME is the filename used for communication. */
2189 remote_open (char *name
, int from_tty
)
2191 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2194 /* Just like remote_open, but with asynchronous support. */
2196 remote_async_open (char *name
, int from_tty
)
2198 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2201 /* Open a connection to a remote debugger using the extended
2202 remote gdb protocol. NAME is the filename used for communication. */
2205 extended_remote_open (char *name
, int from_tty
)
2207 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2211 /* Just like extended_remote_open, but with asynchronous support. */
2213 extended_remote_async_open (char *name
, int from_tty
)
2215 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2216 1 /*extended_p */, 1 /* async_p */);
2219 /* Generic code for opening a connection to a remote target. */
2222 init_all_packet_configs (void)
2225 for (i
= 0; i
< PACKET_MAX
; i
++)
2226 update_packet_config (&remote_protocol_packets
[i
]);
2229 /* Symbol look-up. */
2232 remote_check_symbols (struct objfile
*objfile
)
2234 struct remote_state
*rs
= get_remote_state ();
2235 char *msg
, *reply
, *tmp
;
2236 struct minimal_symbol
*sym
;
2239 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2242 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2243 because we need both at the same time. */
2244 msg
= alloca (get_remote_packet_size ());
2246 /* Invite target to request symbol lookups. */
2248 putpkt ("qSymbol::");
2249 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2250 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2253 while (strncmp (reply
, "qSymbol:", 8) == 0)
2256 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2258 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2260 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2263 CORE_ADDR sym_addr
= SYMBOL_VALUE_ADDRESS (sym
);
2265 /* If this is a function address, return the start of code
2266 instead of any data function descriptor. */
2267 sym_addr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
2271 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2272 paddr_nz (sym_addr
), &reply
[8]);
2276 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2281 static struct serial
*
2282 remote_serial_open (char *name
)
2284 static int udp_warning
= 0;
2286 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2287 of in ser-tcp.c, because it is the remote protocol assuming that the
2288 serial connection is reliable and not the serial connection promising
2290 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2293 The remote protocol may be unreliable over UDP.\n\
2294 Some events may be lost, rendering further debugging impossible."));
2298 return serial_open (name
);
2301 /* This type describes each known response to the qSupported
2303 struct protocol_feature
2305 /* The name of this protocol feature. */
2308 /* The default for this protocol feature. */
2309 enum packet_support default_support
;
2311 /* The function to call when this feature is reported, or after
2312 qSupported processing if the feature is not supported.
2313 The first argument points to this structure. The second
2314 argument indicates whether the packet requested support be
2315 enabled, disabled, or probed (or the default, if this function
2316 is being called at the end of processing and this feature was
2317 not reported). The third argument may be NULL; if not NULL, it
2318 is a NUL-terminated string taken from the packet following
2319 this feature's name and an equals sign. */
2320 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2323 /* The corresponding packet for this feature. Only used if
2324 FUNC is remote_supported_packet. */
2329 remote_supported_packet (const struct protocol_feature
*feature
,
2330 enum packet_support support
,
2331 const char *argument
)
2335 warning (_("Remote qSupported response supplied an unexpected value for"
2336 " \"%s\"."), feature
->name
);
2340 if (remote_protocol_packets
[feature
->packet
].support
2341 == PACKET_SUPPORT_UNKNOWN
)
2342 remote_protocol_packets
[feature
->packet
].support
= support
;
2346 remote_packet_size (const struct protocol_feature
*feature
,
2347 enum packet_support support
, const char *value
)
2349 struct remote_state
*rs
= get_remote_state ();
2354 if (support
!= PACKET_ENABLE
)
2357 if (value
== NULL
|| *value
== '\0')
2359 warning (_("Remote target reported \"%s\" without a size."),
2365 packet_size
= strtol (value
, &value_end
, 16);
2366 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2368 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2369 feature
->name
, value
);
2373 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2375 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2376 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2377 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2380 /* Record the new maximum packet size. */
2381 rs
->explicit_packet_size
= packet_size
;
2384 static struct protocol_feature remote_protocol_features
[] = {
2385 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2386 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2387 PACKET_qXfer_auxv
},
2388 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2389 PACKET_qXfer_features
},
2390 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
2391 PACKET_qXfer_libraries
},
2392 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2393 PACKET_qXfer_memory_map
},
2394 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
2395 PACKET_qXfer_spu_read
},
2396 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
2397 PACKET_qXfer_spu_write
},
2398 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2399 PACKET_QPassSignals
},
2403 remote_query_supported (void)
2405 struct remote_state
*rs
= get_remote_state ();
2408 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2410 /* The packet support flags are handled differently for this packet
2411 than for most others. We treat an error, a disabled packet, and
2412 an empty response identically: any features which must be reported
2413 to be used will be automatically disabled. An empty buffer
2414 accomplishes this, since that is also the representation for a list
2415 containing no features. */
2418 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2420 putpkt ("qSupported");
2421 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2423 /* If an error occured, warn, but do not return - just reset the
2424 buffer to empty and go on to disable features. */
2425 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2428 warning (_("Remote failure reply: %s"), rs
->buf
);
2433 memset (seen
, 0, sizeof (seen
));
2438 enum packet_support is_supported
;
2439 char *p
, *end
, *name_end
, *value
;
2441 /* First separate out this item from the rest of the packet. If
2442 there's another item after this, we overwrite the separator
2443 (terminated strings are much easier to work with). */
2445 end
= strchr (p
, ';');
2448 end
= p
+ strlen (p
);
2458 warning (_("empty item in \"qSupported\" response"));
2463 name_end
= strchr (p
, '=');
2466 /* This is a name=value entry. */
2467 is_supported
= PACKET_ENABLE
;
2468 value
= name_end
+ 1;
2477 is_supported
= PACKET_ENABLE
;
2481 is_supported
= PACKET_DISABLE
;
2485 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2489 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2495 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2496 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2498 const struct protocol_feature
*feature
;
2501 feature
= &remote_protocol_features
[i
];
2502 feature
->func (feature
, is_supported
, value
);
2507 /* If we increased the packet size, make sure to increase the global
2508 buffer size also. We delay this until after parsing the entire
2509 qSupported packet, because this is the same buffer we were
2511 if (rs
->buf_size
< rs
->explicit_packet_size
)
2513 rs
->buf_size
= rs
->explicit_packet_size
;
2514 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2517 /* Handle the defaults for unmentioned features. */
2518 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2521 const struct protocol_feature
*feature
;
2523 feature
= &remote_protocol_features
[i
];
2524 feature
->func (feature
, feature
->default_support
, NULL
);
2530 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2531 int extended_p
, int async_p
)
2533 struct remote_state
*rs
= get_remote_state ();
2535 error (_("To open a remote debug connection, you need to specify what\n"
2536 "serial device is attached to the remote system\n"
2537 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2539 /* See FIXME above. */
2541 wait_forever_enabled_p
= 1;
2543 target_preopen (from_tty
);
2545 unpush_target (target
);
2547 /* Make sure we send the passed signals list the next time we resume. */
2548 xfree (last_pass_packet
);
2549 last_pass_packet
= NULL
;
2551 remote_fileio_reset ();
2552 reopen_exec_file ();
2555 remote_desc
= remote_serial_open (name
);
2557 perror_with_name (name
);
2559 if (baud_rate
!= -1)
2561 if (serial_setbaudrate (remote_desc
, baud_rate
))
2563 /* The requested speed could not be set. Error out to
2564 top level after closing remote_desc. Take care to
2565 set remote_desc to NULL to avoid closing remote_desc
2567 serial_close (remote_desc
);
2569 perror_with_name (name
);
2573 serial_raw (remote_desc
);
2575 /* If there is something sitting in the buffer we might take it as a
2576 response to a command, which would be bad. */
2577 serial_flush_input (remote_desc
);
2581 puts_filtered ("Remote debugging using ");
2582 puts_filtered (name
);
2583 puts_filtered ("\n");
2585 push_target (target
); /* Switch to using remote target now. */
2587 /* Reset the target state; these things will be queried either by
2588 remote_query_supported or as they are needed. */
2589 init_all_packet_configs ();
2590 rs
->explicit_packet_size
= 0;
2592 general_thread
= -2;
2593 continue_thread
= -2;
2595 /* Probe for ability to use "ThreadInfo" query, as required. */
2596 use_threadinfo_query
= 1;
2597 use_threadextra_query
= 1;
2599 /* The first packet we send to the target is the optional "supported
2600 packets" request. If the target can answer this, it will tell us
2601 which later probes to skip. */
2602 remote_query_supported ();
2604 /* Next, if the target can specify a description, read it. We do
2605 this before anything involving memory or registers. */
2606 target_find_description ();
2608 /* Without this, some commands which require an active target (such
2609 as kill) won't work. This variable serves (at least) double duty
2610 as both the pid of the target process (if it has such), and as a
2611 flag indicating that a target is active. These functions should
2612 be split out into seperate variables, especially since GDB will
2613 someday have a notion of debugging several processes. */
2615 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2619 /* With this target we start out by owning the terminal. */
2620 remote_async_terminal_ours_p
= 1;
2622 /* FIXME: cagney/1999-09-23: During the initial connection it is
2623 assumed that the target is already ready and able to respond to
2624 requests. Unfortunately remote_start_remote() eventually calls
2625 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2626 around this. Eventually a mechanism that allows
2627 wait_for_inferior() to expect/get timeouts will be
2629 wait_forever_enabled_p
= 0;
2632 /* First delete any symbols previously loaded from shared libraries. */
2633 no_shared_libraries (NULL
, 0);
2635 /* Start the remote connection. If error() or QUIT, discard this
2636 target (we'd otherwise be in an inconsistent state) and then
2637 propogate the error on up the exception chain. This ensures that
2638 the caller doesn't stumble along blindly assuming that the
2639 function succeeded. The CLI doesn't have this problem but other
2640 UI's, such as MI do.
2642 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2643 this function should return an error indication letting the
2644 caller restore the previous state. Unfortunately the command
2645 ``target remote'' is directly wired to this function making that
2646 impossible. On a positive note, the CLI side of this problem has
2647 been fixed - the function set_cmd_context() makes it possible for
2648 all the ``target ....'' commands to share a common callback
2649 function. See cli-dump.c. */
2651 struct gdb_exception ex
2652 = catch_exception (uiout
, remote_start_remote
, &from_tty
,
2658 wait_forever_enabled_p
= 1;
2659 throw_exception (ex
);
2664 wait_forever_enabled_p
= 1;
2668 /* Tell the remote that we are using the extended protocol. */
2670 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2673 if (exec_bfd
) /* No use without an exec file. */
2674 remote_check_symbols (symfile_objfile
);
2677 /* This takes a program previously attached to and detaches it. After
2678 this is done, GDB can be used to debug some other program. We
2679 better not have left any breakpoints in the target program or it'll
2680 die when it hits one. */
2683 remote_detach (char *args
, int from_tty
)
2685 struct remote_state
*rs
= get_remote_state ();
2688 error (_("Argument given to \"detach\" when remotely debugging."));
2690 /* Tell the remote target to detach. */
2691 strcpy (rs
->buf
, "D");
2693 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2695 if (rs
->buf
[0] == 'E')
2696 error (_("Can't detach process."));
2698 /* Unregister the file descriptor from the event loop. */
2699 if (target_is_async_p ())
2700 serial_async (remote_desc
, NULL
, 0);
2702 target_mourn_inferior ();
2704 puts_filtered ("Ending remote debugging.\n");
2707 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2710 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2713 error (_("Argument given to \"detach\" when remotely debugging."));
2715 /* Unregister the file descriptor from the event loop. */
2716 if (target_is_async_p ())
2717 serial_async (remote_desc
, NULL
, 0);
2719 target_mourn_inferior ();
2721 puts_filtered ("Ending remote debugging.\n");
2724 /* Convert hex digit A to a number. */
2729 if (a
>= '0' && a
<= '9')
2731 else if (a
>= 'a' && a
<= 'f')
2732 return a
- 'a' + 10;
2733 else if (a
>= 'A' && a
<= 'F')
2734 return a
- 'A' + 10;
2736 error (_("Reply contains invalid hex digit %d"), a
);
2740 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2744 for (i
= 0; i
< count
; i
++)
2746 if (hex
[0] == 0 || hex
[1] == 0)
2748 /* Hex string is short, or of uneven length.
2749 Return the count that has been converted so far. */
2752 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2758 /* Convert number NIB to a hex digit. */
2766 return 'a' + nib
- 10;
2770 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2773 /* May use a length, or a nul-terminated string as input. */
2775 count
= strlen ((char *) bin
);
2777 for (i
= 0; i
< count
; i
++)
2779 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2780 *hex
++ = tohex (*bin
++ & 0xf);
2786 /* Check for the availability of vCont. This function should also check
2790 remote_vcont_probe (struct remote_state
*rs
)
2794 strcpy (rs
->buf
, "vCont?");
2796 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2799 /* Make sure that the features we assume are supported. */
2800 if (strncmp (buf
, "vCont", 5) == 0)
2803 int support_s
, support_S
, support_c
, support_C
;
2809 while (p
&& *p
== ';')
2812 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2814 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2816 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2818 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2821 p
= strchr (p
, ';');
2824 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2825 BUF will make packet_ok disable the packet. */
2826 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2830 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2833 /* Resume the remote inferior by using a "vCont" packet. The thread
2834 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2835 resumed thread should be single-stepped and/or signalled. If PTID's
2836 PID is -1, then all threads are resumed; the thread to be stepped and/or
2837 signalled is given in the global INFERIOR_PTID. This function returns
2838 non-zero iff it resumes the inferior.
2840 This function issues a strict subset of all possible vCont commands at the
2844 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2846 struct remote_state
*rs
= get_remote_state ();
2847 int pid
= PIDGET (ptid
);
2848 char *buf
= NULL
, *outbuf
;
2849 struct cleanup
*old_cleanup
;
2851 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2852 remote_vcont_probe (rs
);
2854 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2857 /* If we could generate a wider range of packets, we'd have to worry
2858 about overflowing BUF. Should there be a generic
2859 "multi-part-packet" packet? */
2861 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2863 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2864 don't have any PID numbers the inferior will understand. Make sure
2865 to only send forms that do not specify a PID. */
2866 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2867 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2869 outbuf
= xstrprintf ("vCont;s");
2870 else if (siggnal
!= TARGET_SIGNAL_0
)
2871 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2873 outbuf
= xstrprintf ("vCont;c");
2877 /* Resume all threads, with preference for INFERIOR_PTID. */
2878 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2879 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2880 PIDGET (inferior_ptid
));
2882 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2883 else if (siggnal
!= TARGET_SIGNAL_0
)
2884 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2885 PIDGET (inferior_ptid
));
2887 outbuf
= xstrprintf ("vCont;c");
2891 /* Scheduler locking; resume only PTID. */
2892 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2893 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2895 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2896 else if (siggnal
!= TARGET_SIGNAL_0
)
2897 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2899 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2902 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2903 old_cleanup
= make_cleanup (xfree
, outbuf
);
2907 do_cleanups (old_cleanup
);
2912 /* Tell the remote machine to resume. */
2914 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2916 static int last_sent_step
;
2919 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2921 struct remote_state
*rs
= get_remote_state ();
2923 int pid
= PIDGET (ptid
);
2925 last_sent_signal
= siggnal
;
2926 last_sent_step
= step
;
2928 /* A hook for when we need to do something at the last moment before
2930 if (deprecated_target_resume_hook
)
2931 (*deprecated_target_resume_hook
) ();
2933 /* Update the inferior on signals to silently pass, if they've changed. */
2934 remote_pass_signals ();
2936 /* The vCont packet doesn't need to specify threads via Hc. */
2937 if (remote_vcont_resume (ptid
, step
, siggnal
))
2940 /* All other supported resume packets do use Hc, so call set_thread. */
2942 set_thread (0, 0); /* Run any thread. */
2944 set_thread (pid
, 0); /* Run this thread. */
2947 if (siggnal
!= TARGET_SIGNAL_0
)
2949 buf
[0] = step
? 'S' : 'C';
2950 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2951 buf
[2] = tohex (((int) siggnal
) & 0xf);
2955 strcpy (buf
, step
? "s" : "c");
2960 /* Same as remote_resume, but with async support. */
2962 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2964 remote_resume (ptid
, step
, siggnal
);
2966 /* We are about to start executing the inferior, let's register it
2967 with the event loop. NOTE: this is the one place where all the
2968 execution commands end up. We could alternatively do this in each
2969 of the execution commands in infcmd.c. */
2970 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2971 into infcmd.c in order to allow inferior function calls to work
2972 NOT asynchronously. */
2973 if (target_can_async_p ())
2974 target_async (inferior_event_handler
, 0);
2975 /* Tell the world that the target is now executing. */
2976 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2977 this? Instead, should the client of target just assume (for
2978 async targets) that the target is going to start executing? Is
2979 this information already found in the continuation block? */
2980 if (target_is_async_p ())
2981 target_executing
= 1;
2985 /* Set up the signal handler for SIGINT, while the target is
2986 executing, ovewriting the 'regular' SIGINT signal handler. */
2988 initialize_sigint_signal_handler (void)
2990 sigint_remote_token
=
2991 create_async_signal_handler (async_remote_interrupt
, NULL
);
2992 signal (SIGINT
, handle_remote_sigint
);
2995 /* Signal handler for SIGINT, while the target is executing. */
2997 handle_remote_sigint (int sig
)
2999 signal (sig
, handle_remote_sigint_twice
);
3000 sigint_remote_twice_token
=
3001 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
3002 mark_async_signal_handler_wrapper (sigint_remote_token
);
3005 /* Signal handler for SIGINT, installed after SIGINT has already been
3006 sent once. It will take effect the second time that the user sends
3009 handle_remote_sigint_twice (int sig
)
3011 signal (sig
, handle_sigint
);
3012 sigint_remote_twice_token
=
3013 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
3014 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
3017 /* Perform the real interruption of the target execution, in response
3020 async_remote_interrupt (gdb_client_data arg
)
3023 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3028 /* Perform interrupt, if the first attempt did not succeed. Just give
3029 up on the target alltogether. */
3031 async_remote_interrupt_twice (gdb_client_data arg
)
3034 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
3035 /* Do something only if the target was not killed by the previous
3037 if (target_executing
)
3040 signal (SIGINT
, handle_remote_sigint
);
3044 /* Reinstall the usual SIGINT handlers, after the target has
3047 cleanup_sigint_signal_handler (void *dummy
)
3049 signal (SIGINT
, handle_sigint
);
3050 if (sigint_remote_twice_token
)
3051 delete_async_signal_handler (&sigint_remote_twice_token
);
3052 if (sigint_remote_token
)
3053 delete_async_signal_handler (&sigint_remote_token
);
3056 /* Send ^C to target to halt it. Target will respond, and send us a
3058 static void (*ofunc
) (int);
3060 /* The command line interface's stop routine. This function is installed
3061 as a signal handler for SIGINT. The first time a user requests a
3062 stop, we call remote_stop to send a break or ^C. If there is no
3063 response from the target (it didn't stop when the user requested it),
3064 we ask the user if he'd like to detach from the target. */
3066 remote_interrupt (int signo
)
3068 /* If this doesn't work, try more severe steps. */
3069 signal (signo
, remote_interrupt_twice
);
3072 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3077 /* The user typed ^C twice. */
3080 remote_interrupt_twice (int signo
)
3082 signal (signo
, ofunc
);
3084 signal (signo
, remote_interrupt
);
3087 /* This is the generic stop called via the target vector. When a target
3088 interrupt is requested, either by the command line or the GUI, we
3089 will eventually end up here. */
3093 /* Send a break or a ^C, depending on user preference. */
3095 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
3098 serial_send_break (remote_desc
);
3100 serial_write (remote_desc
, "\003", 1);
3103 /* Ask the user what to do when an interrupt is received. */
3106 interrupt_query (void)
3108 target_terminal_ours ();
3110 if (query ("Interrupted while waiting for the program.\n\
3111 Give up (and stop debugging it)? "))
3113 target_mourn_inferior ();
3114 deprecated_throw_reason (RETURN_QUIT
);
3117 target_terminal_inferior ();
3120 /* Enable/disable target terminal ownership. Most targets can use
3121 terminal groups to control terminal ownership. Remote targets are
3122 different in that explicit transfer of ownership to/from GDB/target
3126 remote_async_terminal_inferior (void)
3128 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3129 sync_execution here. This function should only be called when
3130 GDB is resuming the inferior in the forground. A background
3131 resume (``run&'') should leave GDB in control of the terminal and
3132 consequently should not call this code. */
3133 if (!sync_execution
)
3135 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3136 calls target_terminal_*() idenpotent. The event-loop GDB talking
3137 to an asynchronous target with a synchronous command calls this
3138 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3139 stops trying to transfer the terminal to the target when it
3140 shouldn't this guard can go away. */
3141 if (!remote_async_terminal_ours_p
)
3143 delete_file_handler (input_fd
);
3144 remote_async_terminal_ours_p
= 0;
3145 initialize_sigint_signal_handler ();
3146 /* NOTE: At this point we could also register our selves as the
3147 recipient of all input. Any characters typed could then be
3148 passed on down to the target. */
3152 remote_async_terminal_ours (void)
3154 /* See FIXME in remote_async_terminal_inferior. */
3155 if (!sync_execution
)
3157 /* See FIXME in remote_async_terminal_inferior. */
3158 if (remote_async_terminal_ours_p
)
3160 cleanup_sigint_signal_handler (NULL
);
3161 add_file_handler (input_fd
, stdin_event_handler
, 0);
3162 remote_async_terminal_ours_p
= 1;
3165 /* If nonzero, ignore the next kill. */
3170 remote_console_output (char *msg
)
3174 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3177 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3180 fputs_unfiltered (tb
, gdb_stdtarg
);
3182 gdb_flush (gdb_stdtarg
);
3185 /* Wait until the remote machine stops, then return,
3186 storing status in STATUS just as `wait' would.
3187 Returns "pid", which in the case of a multi-threaded
3188 remote OS, is the thread-id. */
3191 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3193 struct remote_state
*rs
= get_remote_state ();
3194 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3195 ULONGEST thread_num
= -1;
3197 int solibs_changed
= 0;
3199 status
->kind
= TARGET_WAITKIND_EXITED
;
3200 status
->value
.integer
= 0;
3206 ofunc
= signal (SIGINT
, remote_interrupt
);
3207 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3208 signal (SIGINT
, ofunc
);
3212 /* This is a hook for when we need to do something (perhaps the
3213 collection of trace data) every time the target stops. */
3214 if (deprecated_target_wait_loop_hook
)
3215 (*deprecated_target_wait_loop_hook
) ();
3217 remote_stopped_by_watchpoint_p
= 0;
3221 case 'E': /* Error of some sort. */
3222 warning (_("Remote failure reply: %s"), buf
);
3224 case 'F': /* File-I/O request. */
3225 remote_fileio_request (buf
);
3227 case 'T': /* Status with PC, SP, FP, ... */
3229 gdb_byte regs
[MAX_REGISTER_SIZE
];
3231 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3232 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3234 n... = register number
3235 r... = register contents
3237 p
= &buf
[3]; /* after Txx */
3246 /* If the packet contains a register number save it in
3247 pnum and set p1 to point to the character following
3248 it. Otherwise p1 points to p. */
3250 /* If this packet is an awatch packet, don't parse the
3251 'a' as a register number. */
3253 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3255 /* Read the ``P'' register number. */
3256 pnum
= strtol (p
, &p_temp
, 16);
3262 if (p1
== p
) /* No register number present here. */
3264 p1
= strchr (p
, ':');
3266 error (_("Malformed packet(a) (missing colon): %s\n\
3269 if (strncmp (p
, "thread", p1
- p
) == 0)
3271 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3272 record_currthread (thread_num
);
3275 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3276 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3277 || (strncmp (p
, "awatch", p1
- p
) == 0))
3279 remote_stopped_by_watchpoint_p
= 1;
3280 p
= unpack_varlen_hex (++p1
, &addr
);
3281 remote_watch_data_address
= (CORE_ADDR
)addr
;
3283 else if (strncmp (p
, "library", p1
- p
) == 0)
3287 while (*p_temp
&& *p_temp
!= ';')
3295 /* Silently skip unknown optional info. */
3296 p_temp
= strchr (p1
+ 1, ';');
3303 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3307 error (_("Malformed packet(b) (missing colon): %s\n\
3312 error (_("Remote sent bad register number %s: %s\n\
3314 phex_nz (pnum
, 0), p
, buf
);
3316 fieldsize
= hex2bin (p
, regs
,
3317 register_size (current_gdbarch
,
3320 if (fieldsize
< register_size (current_gdbarch
,
3322 warning (_("Remote reply is too short: %s"), buf
);
3323 regcache_raw_supply (get_current_regcache (),
3328 error (_("Remote register badly formatted: %s\nhere: %s"),
3333 case 'S': /* Old style status, just signal only. */
3335 status
->kind
= TARGET_WAITKIND_LOADED
;
3338 status
->kind
= TARGET_WAITKIND_STOPPED
;
3339 status
->value
.sig
= (enum target_signal
)
3340 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3345 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3346 record_currthread (thread_num
);
3349 case 'W': /* Target exited. */
3351 /* The remote process exited. */
3352 status
->kind
= TARGET_WAITKIND_EXITED
;
3353 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3357 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3358 status
->value
.sig
= (enum target_signal
)
3359 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3363 case 'O': /* Console output. */
3364 remote_console_output (buf
+ 1);
3367 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3369 /* Zero length reply means that we tried 'S' or 'C' and
3370 the remote system doesn't support it. */
3371 target_terminal_ours_for_output ();
3373 ("Can't send signals to this remote system. %s not sent.\n",
3374 target_signal_to_name (last_sent_signal
));
3375 last_sent_signal
= TARGET_SIGNAL_0
;
3376 target_terminal_inferior ();
3378 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3379 putpkt ((char *) buf
);
3382 /* else fallthrough */
3384 warning (_("Invalid remote reply: %s"), buf
);
3389 if (thread_num
!= -1)
3391 return pid_to_ptid (thread_num
);
3393 return inferior_ptid
;
3396 /* Async version of remote_wait. */
3398 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3400 struct remote_state
*rs
= get_remote_state ();
3401 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3402 ULONGEST thread_num
= -1;
3404 int solibs_changed
= 0;
3406 status
->kind
= TARGET_WAITKIND_EXITED
;
3407 status
->value
.integer
= 0;
3409 remote_stopped_by_watchpoint_p
= 0;
3415 if (!target_is_async_p ())
3416 ofunc
= signal (SIGINT
, remote_interrupt
);
3417 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3418 _never_ wait for ever -> test on target_is_async_p().
3419 However, before we do that we need to ensure that the caller
3420 knows how to take the target into/out of async mode. */
3421 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3422 if (!target_is_async_p ())
3423 signal (SIGINT
, ofunc
);
3427 /* This is a hook for when we need to do something (perhaps the
3428 collection of trace data) every time the target stops. */
3429 if (deprecated_target_wait_loop_hook
)
3430 (*deprecated_target_wait_loop_hook
) ();
3434 case 'E': /* Error of some sort. */
3435 warning (_("Remote failure reply: %s"), buf
);
3437 case 'F': /* File-I/O request. */
3438 remote_fileio_request (buf
);
3440 case 'T': /* Status with PC, SP, FP, ... */
3442 gdb_byte regs
[MAX_REGISTER_SIZE
];
3444 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3445 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3447 n... = register number
3448 r... = register contents
3450 p
= &buf
[3]; /* after Txx */
3459 /* If the packet contains a register number, save it
3460 in pnum and set p1 to point to the character
3461 following it. Otherwise p1 points to p. */
3463 /* If this packet is an awatch packet, don't parse the 'a'
3464 as a register number. */
3466 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3468 /* Read the register number. */
3469 pnum
= strtol (p
, &p_temp
, 16);
3475 if (p1
== p
) /* No register number present here. */
3477 p1
= strchr (p
, ':');
3479 error (_("Malformed packet(a) (missing colon): %s\n\
3482 if (strncmp (p
, "thread", p1
- p
) == 0)
3484 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3485 record_currthread (thread_num
);
3488 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3489 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3490 || (strncmp (p
, "awatch", p1
- p
) == 0))
3492 remote_stopped_by_watchpoint_p
= 1;
3493 p
= unpack_varlen_hex (++p1
, &addr
);
3494 remote_watch_data_address
= (CORE_ADDR
)addr
;
3496 else if (strncmp (p
, "library", p1
- p
) == 0)
3500 while (*p_temp
&& *p_temp
!= ';')
3508 /* Silently skip unknown optional info. */
3509 p_temp
= strchr (p1
+ 1, ';');
3517 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3520 error (_("Malformed packet(b) (missing colon): %s\n\
3525 error (_("Remote sent bad register number %ld: %s\n\
3529 fieldsize
= hex2bin (p
, regs
,
3530 register_size (current_gdbarch
,
3533 if (fieldsize
< register_size (current_gdbarch
,
3535 warning (_("Remote reply is too short: %s"), buf
);
3536 regcache_raw_supply (get_current_regcache (),
3541 error (_("Remote register badly formatted: %s\nhere: %s"),
3546 case 'S': /* Old style status, just signal only. */
3548 status
->kind
= TARGET_WAITKIND_LOADED
;
3551 status
->kind
= TARGET_WAITKIND_STOPPED
;
3552 status
->value
.sig
= (enum target_signal
)
3553 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3558 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3559 record_currthread (thread_num
);
3562 case 'W': /* Target exited. */
3564 /* The remote process exited. */
3565 status
->kind
= TARGET_WAITKIND_EXITED
;
3566 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3570 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3571 status
->value
.sig
= (enum target_signal
)
3572 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3576 case 'O': /* Console output. */
3577 remote_console_output (buf
+ 1);
3578 /* Return immediately to the event loop. The event loop will
3579 still be waiting on the inferior afterwards. */
3580 status
->kind
= TARGET_WAITKIND_IGNORE
;
3583 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3585 /* Zero length reply means that we tried 'S' or 'C' and
3586 the remote system doesn't support it. */
3587 target_terminal_ours_for_output ();
3589 ("Can't send signals to this remote system. %s not sent.\n",
3590 target_signal_to_name (last_sent_signal
));
3591 last_sent_signal
= TARGET_SIGNAL_0
;
3592 target_terminal_inferior ();
3594 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3595 putpkt ((char *) buf
);
3598 /* else fallthrough */
3600 warning (_("Invalid remote reply: %s"), buf
);
3605 if (thread_num
!= -1)
3607 return pid_to_ptid (thread_num
);
3609 return inferior_ptid
;
3612 /* Fetch a single register using a 'p' packet. */
3615 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3617 struct remote_state
*rs
= get_remote_state ();
3619 char regp
[MAX_REGISTER_SIZE
];
3622 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3625 if (reg
->pnum
== -1)
3630 p
+= hexnumstr (p
, reg
->pnum
);
3632 remote_send (&rs
->buf
, &rs
->buf_size
);
3636 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3640 case PACKET_UNKNOWN
:
3643 error (_("Could not fetch register \"%s\""),
3644 gdbarch_register_name (get_regcache_arch (regcache
), reg
->regnum
));
3647 /* If this register is unfetchable, tell the regcache. */
3650 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3654 /* Otherwise, parse and supply the value. */
3660 error (_("fetch_register_using_p: early buf termination"));
3662 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3665 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3669 /* Fetch the registers included in the target's 'g' packet. */
3672 send_g_packet (void)
3674 struct remote_state
*rs
= get_remote_state ();
3679 sprintf (rs
->buf
, "g");
3680 remote_send (&rs
->buf
, &rs
->buf_size
);
3682 /* We can get out of synch in various cases. If the first character
3683 in the buffer is not a hex character, assume that has happened
3684 and try to fetch another packet to read. */
3685 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3686 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3687 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3688 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3691 fprintf_unfiltered (gdb_stdlog
,
3692 "Bad register packet; fetching a new packet\n");
3693 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3696 buf_len
= strlen (rs
->buf
);
3698 /* Sanity check the received packet. */
3699 if (buf_len
% 2 != 0)
3700 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3706 process_g_packet (struct regcache
*regcache
)
3708 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3709 struct remote_state
*rs
= get_remote_state ();
3710 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3715 buf_len
= strlen (rs
->buf
);
3717 /* Further sanity checks, with knowledge of the architecture. */
3718 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3719 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3721 /* Save the size of the packet sent to us by the target. It is used
3722 as a heuristic when determining the max size of packets that the
3723 target can safely receive. */
3724 if (rsa
->actual_register_packet_size
== 0)
3725 rsa
->actual_register_packet_size
= buf_len
;
3727 /* If this is smaller than we guessed the 'g' packet would be,
3728 update our records. A 'g' reply that doesn't include a register's
3729 value implies either that the register is not available, or that
3730 the 'p' packet must be used. */
3731 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3733 rsa
->sizeof_g_packet
= buf_len
/ 2;
3735 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
3737 if (rsa
->regs
[i
].pnum
== -1)
3740 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3741 rsa
->regs
[i
].in_g_packet
= 0;
3743 rsa
->regs
[i
].in_g_packet
= 1;
3747 regs
= alloca (rsa
->sizeof_g_packet
);
3749 /* Unimplemented registers read as all bits zero. */
3750 memset (regs
, 0, rsa
->sizeof_g_packet
);
3752 /* Reply describes registers byte by byte, each byte encoded as two
3753 hex characters. Suck them all up, then supply them to the
3754 register cacheing/storage mechanism. */
3757 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3759 if (p
[0] == 0 || p
[1] == 0)
3760 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3761 internal_error (__FILE__
, __LINE__
,
3762 "unexpected end of 'g' packet reply");
3764 if (p
[0] == 'x' && p
[1] == 'x')
3765 regs
[i
] = 0; /* 'x' */
3767 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3773 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
3775 struct packet_reg
*r
= &rsa
->regs
[i
];
3778 if (r
->offset
* 2 >= strlen (rs
->buf
))
3779 /* This shouldn't happen - we adjusted in_g_packet above. */
3780 internal_error (__FILE__
, __LINE__
,
3781 "unexpected end of 'g' packet reply");
3782 else if (rs
->buf
[r
->offset
* 2] == 'x')
3784 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3785 /* The register isn't available, mark it as such (at
3786 the same time setting the value to zero). */
3787 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3790 regcache_raw_supply (regcache
, r
->regnum
,
3798 fetch_registers_using_g (struct regcache
*regcache
)
3801 process_g_packet (regcache
);
3805 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3807 struct remote_state
*rs
= get_remote_state ();
3808 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3811 set_thread (PIDGET (inferior_ptid
), 1);
3815 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3816 gdb_assert (reg
!= NULL
);
3818 /* If this register might be in the 'g' packet, try that first -
3819 we are likely to read more than one register. If this is the
3820 first 'g' packet, we might be overly optimistic about its
3821 contents, so fall back to 'p'. */
3822 if (reg
->in_g_packet
)
3824 fetch_registers_using_g (regcache
);
3825 if (reg
->in_g_packet
)
3829 if (fetch_register_using_p (regcache
, reg
))
3832 /* This register is not available. */
3833 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3838 fetch_registers_using_g (regcache
);
3840 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3841 if (!rsa
->regs
[i
].in_g_packet
)
3842 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3844 /* This register is not available. */
3845 regcache_raw_supply (regcache
, i
, NULL
);
3849 /* Prepare to store registers. Since we may send them all (using a
3850 'G' request), we have to read out the ones we don't want to change
3854 remote_prepare_to_store (struct regcache
*regcache
)
3856 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3858 gdb_byte buf
[MAX_REGISTER_SIZE
];
3860 /* Make sure the entire registers array is valid. */
3861 switch (remote_protocol_packets
[PACKET_P
].support
)
3863 case PACKET_DISABLE
:
3864 case PACKET_SUPPORT_UNKNOWN
:
3865 /* Make sure all the necessary registers are cached. */
3866 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3867 if (rsa
->regs
[i
].in_g_packet
)
3868 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3875 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3876 packet was not recognized. */
3879 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3881 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3882 struct remote_state
*rs
= get_remote_state ();
3883 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3884 /* Try storing a single register. */
3885 char *buf
= rs
->buf
;
3886 gdb_byte regp
[MAX_REGISTER_SIZE
];
3889 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3892 if (reg
->pnum
== -1)
3895 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3896 p
= buf
+ strlen (buf
);
3897 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3898 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
3899 remote_send (&rs
->buf
, &rs
->buf_size
);
3901 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3906 error (_("Could not write register \"%s\""),
3907 gdbarch_register_name (gdbarch
, reg
->regnum
));
3908 case PACKET_UNKNOWN
:
3911 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3915 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3916 contents of the register cache buffer. FIXME: ignores errors. */
3919 store_registers_using_G (const struct regcache
*regcache
)
3921 struct remote_state
*rs
= get_remote_state ();
3922 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3926 /* Extract all the registers in the regcache copying them into a
3930 regs
= alloca (rsa
->sizeof_g_packet
);
3931 memset (regs
, 0, rsa
->sizeof_g_packet
);
3932 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3934 struct packet_reg
*r
= &rsa
->regs
[i
];
3936 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3940 /* Command describes registers byte by byte,
3941 each byte encoded as two hex characters. */
3944 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3946 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3947 remote_send (&rs
->buf
, &rs
->buf_size
);
3950 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3951 of the register cache buffer. FIXME: ignores errors. */
3954 remote_store_registers (struct regcache
*regcache
, int regnum
)
3956 struct remote_state
*rs
= get_remote_state ();
3957 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3960 set_thread (PIDGET (inferior_ptid
), 1);
3964 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3965 gdb_assert (reg
!= NULL
);
3967 /* Always prefer to store registers using the 'P' packet if
3968 possible; we often change only a small number of registers.
3969 Sometimes we change a larger number; we'd need help from a
3970 higher layer to know to use 'G'. */
3971 if (store_register_using_P (regcache
, reg
))
3974 /* For now, don't complain if we have no way to write the
3975 register. GDB loses track of unavailable registers too
3976 easily. Some day, this may be an error. We don't have
3977 any way to read the register, either... */
3978 if (!reg
->in_g_packet
)
3981 store_registers_using_G (regcache
);
3985 store_registers_using_G (regcache
);
3987 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3988 if (!rsa
->regs
[i
].in_g_packet
)
3989 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
3990 /* See above for why we do not issue an error here. */
3995 /* Return the number of hex digits in num. */
3998 hexnumlen (ULONGEST num
)
4002 for (i
= 0; num
!= 0; i
++)
4008 /* Set BUF to the minimum number of hex digits representing NUM. */
4011 hexnumstr (char *buf
, ULONGEST num
)
4013 int len
= hexnumlen (num
);
4014 return hexnumnstr (buf
, num
, len
);
4018 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
4021 hexnumnstr (char *buf
, ULONGEST num
, int width
)
4027 for (i
= width
- 1; i
>= 0; i
--)
4029 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
4036 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
4039 remote_address_masked (CORE_ADDR addr
)
4041 int address_size
= remote_address_size
;
4042 /* If "remoteaddresssize" was not set, default to target address size. */
4044 address_size
= gdbarch_addr_bit (current_gdbarch
);
4046 if (address_size
> 0
4047 && address_size
< (sizeof (ULONGEST
) * 8))
4049 /* Only create a mask when that mask can safely be constructed
4050 in a ULONGEST variable. */
4052 mask
= (mask
<< address_size
) - 1;
4058 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
4059 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
4060 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
4061 (which may be more than *OUT_LEN due to escape characters). The
4062 total number of bytes in the output buffer will be at most
4066 remote_escape_output (const gdb_byte
*buffer
, int len
,
4067 gdb_byte
*out_buf
, int *out_len
,
4070 int input_index
, output_index
;
4073 for (input_index
= 0; input_index
< len
; input_index
++)
4075 gdb_byte b
= buffer
[input_index
];
4077 if (b
== '$' || b
== '#' || b
== '}')
4079 /* These must be escaped. */
4080 if (output_index
+ 2 > out_maxlen
)
4082 out_buf
[output_index
++] = '}';
4083 out_buf
[output_index
++] = b
^ 0x20;
4087 if (output_index
+ 1 > out_maxlen
)
4089 out_buf
[output_index
++] = b
;
4093 *out_len
= input_index
;
4094 return output_index
;
4097 /* Convert BUFFER, escaped data LEN bytes long, into binary data
4098 in OUT_BUF. Return the number of bytes written to OUT_BUF.
4099 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
4101 This function reverses remote_escape_output. It allows more
4102 escaped characters than that function does, in particular because
4103 '*' must be escaped to avoid the run-length encoding processing
4104 in reading packets. */
4107 remote_unescape_input (const gdb_byte
*buffer
, int len
,
4108 gdb_byte
*out_buf
, int out_maxlen
)
4110 int input_index
, output_index
;
4115 for (input_index
= 0; input_index
< len
; input_index
++)
4117 gdb_byte b
= buffer
[input_index
];
4119 if (output_index
+ 1 > out_maxlen
)
4121 warning (_("Received too much data from remote target;"
4122 " ignoring overflow."));
4123 return output_index
;
4128 out_buf
[output_index
++] = b
^ 0x20;
4134 out_buf
[output_index
++] = b
;
4138 error (_("Unmatched escape character in target response."));
4140 return output_index
;
4143 /* Determine whether the remote target supports binary downloading.
4144 This is accomplished by sending a no-op memory write of zero length
4145 to the target at the specified address. It does not suffice to send
4146 the whole packet, since many stubs strip the eighth bit and
4147 subsequently compute a wrong checksum, which causes real havoc with
4150 NOTE: This can still lose if the serial line is not eight-bit
4151 clean. In cases like this, the user should clear "remote
4155 check_binary_download (CORE_ADDR addr
)
4157 struct remote_state
*rs
= get_remote_state ();
4159 switch (remote_protocol_packets
[PACKET_X
].support
)
4161 case PACKET_DISABLE
:
4165 case PACKET_SUPPORT_UNKNOWN
:
4171 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4173 p
+= hexnumstr (p
, (ULONGEST
) 0);
4177 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4178 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4180 if (rs
->buf
[0] == '\0')
4183 fprintf_unfiltered (gdb_stdlog
,
4184 "binary downloading NOT suppported by target\n");
4185 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4190 fprintf_unfiltered (gdb_stdlog
,
4191 "binary downloading suppported by target\n");
4192 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4199 /* Write memory data directly to the remote machine.
4200 This does not inform the data cache; the data cache uses this.
4201 HEADER is the starting part of the packet.
4202 MEMADDR is the address in the remote memory space.
4203 MYADDR is the address of the buffer in our space.
4204 LEN is the number of bytes.
4205 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4206 should send data as binary ('X'), or hex-encoded ('M').
4208 The function creates packet of the form
4209 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4211 where encoding of <DATA> is termined by PACKET_FORMAT.
4213 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4216 Returns the number of bytes transferred, or 0 (setting errno) for
4217 error. Only transfer a single packet. */
4220 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4221 const gdb_byte
*myaddr
, int len
,
4222 char packet_format
, int use_length
)
4224 struct remote_state
*rs
= get_remote_state ();
4234 if (packet_format
!= 'X' && packet_format
!= 'M')
4235 internal_error (__FILE__
, __LINE__
,
4236 "remote_write_bytes_aux: bad packet format");
4241 payload_size
= get_memory_write_packet_size ();
4243 /* The packet buffer will be large enough for the payload;
4244 get_memory_packet_size ensures this. */
4247 /* Compute the size of the actual payload by subtracting out the
4248 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4250 payload_size
-= strlen ("$,:#NN");
4252 /* The comma won't be used. */
4254 header_length
= strlen (header
);
4255 payload_size
-= header_length
;
4256 payload_size
-= hexnumlen (memaddr
);
4258 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4260 strcat (rs
->buf
, header
);
4261 p
= rs
->buf
+ strlen (header
);
4263 /* Compute a best guess of the number of bytes actually transfered. */
4264 if (packet_format
== 'X')
4266 /* Best guess at number of bytes that will fit. */
4267 todo
= min (len
, payload_size
);
4269 payload_size
-= hexnumlen (todo
);
4270 todo
= min (todo
, payload_size
);
4274 /* Num bytes that will fit. */
4275 todo
= min (len
, payload_size
/ 2);
4277 payload_size
-= hexnumlen (todo
);
4278 todo
= min (todo
, payload_size
/ 2);
4282 internal_error (__FILE__
, __LINE__
,
4283 _("minumum packet size too small to write data"));
4285 /* If we already need another packet, then try to align the end
4286 of this packet to a useful boundary. */
4287 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4288 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4290 /* Append "<memaddr>". */
4291 memaddr
= remote_address_masked (memaddr
);
4292 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4299 /* Append <len>. Retain the location/size of <len>. It may need to
4300 be adjusted once the packet body has been created. */
4302 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4310 /* Append the packet body. */
4311 if (packet_format
== 'X')
4313 /* Binary mode. Send target system values byte by byte, in
4314 increasing byte addresses. Only escape certain critical
4316 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4319 /* If not all TODO bytes fit, then we'll need another packet. Make
4320 a second try to keep the end of the packet aligned. Don't do
4321 this if the packet is tiny. */
4322 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4326 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4328 if (new_nr_bytes
!= nr_bytes
)
4329 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4334 p
+= payload_length
;
4335 if (use_length
&& nr_bytes
< todo
)
4337 /* Escape chars have filled up the buffer prematurely,
4338 and we have actually sent fewer bytes than planned.
4339 Fix-up the length field of the packet. Use the same
4340 number of characters as before. */
4341 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4342 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4347 /* Normal mode: Send target system values byte by byte, in
4348 increasing byte addresses. Each byte is encoded as a two hex
4350 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4354 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4355 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4357 if (rs
->buf
[0] == 'E')
4359 /* There is no correspondance between what the remote protocol
4360 uses for errors and errno codes. We would like a cleaner way
4361 of representing errors (big enough to include errno codes,
4362 bfd_error codes, and others). But for now just return EIO. */
4367 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4368 fewer bytes than we'd planned. */
4372 /* Write memory data directly to the remote machine.
4373 This does not inform the data cache; the data cache uses this.
4374 MEMADDR is the address in the remote memory space.
4375 MYADDR is the address of the buffer in our space.
4376 LEN is the number of bytes.
4378 Returns number of bytes transferred, or 0 (setting errno) for
4379 error. Only transfer a single packet. */
4382 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4384 char *packet_format
= 0;
4386 /* Check whether the target supports binary download. */
4387 check_binary_download (memaddr
);
4389 switch (remote_protocol_packets
[PACKET_X
].support
)
4392 packet_format
= "X";
4394 case PACKET_DISABLE
:
4395 packet_format
= "M";
4397 case PACKET_SUPPORT_UNKNOWN
:
4398 internal_error (__FILE__
, __LINE__
,
4399 _("remote_write_bytes: bad internal state"));
4401 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4404 return remote_write_bytes_aux (packet_format
,
4405 memaddr
, myaddr
, len
, packet_format
[0], 1);
4408 /* Read memory data directly from the remote machine.
4409 This does not use the data cache; the data cache uses this.
4410 MEMADDR is the address in the remote memory space.
4411 MYADDR is the address of the buffer in our space.
4412 LEN is the number of bytes.
4414 Returns number of bytes transferred, or 0 for error. */
4416 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4417 remote targets) shouldn't attempt to read the entire buffer.
4418 Instead it should read a single packet worth of data and then
4419 return the byte size of that packet to the caller. The caller (its
4420 caller and its callers caller ;-) already contains code for
4421 handling partial reads. */
4424 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4426 struct remote_state
*rs
= get_remote_state ();
4427 int max_buf_size
; /* Max size of packet output buffer. */
4433 max_buf_size
= get_memory_read_packet_size ();
4434 /* The packet buffer will be large enough for the payload;
4435 get_memory_packet_size ensures this. */
4444 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4446 /* construct "m"<memaddr>","<len>" */
4447 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4448 memaddr
= remote_address_masked (memaddr
);
4451 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4453 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4457 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4459 if (rs
->buf
[0] == 'E'
4460 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4461 && rs
->buf
[3] == '\0')
4463 /* There is no correspondance between what the remote
4464 protocol uses for errors and errno codes. We would like
4465 a cleaner way of representing errors (big enough to
4466 include errno codes, bfd_error codes, and others). But
4467 for now just return EIO. */
4472 /* Reply describes memory byte by byte,
4473 each byte encoded as two hex characters. */
4476 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4478 /* Reply is short. This means that we were able to read
4479 only part of what we wanted to. */
4480 return i
+ (origlen
- len
);
4489 /* Read or write LEN bytes from inferior memory at MEMADDR,
4490 transferring to or from debugger address BUFFER. Write to inferior
4491 if SHOULD_WRITE is nonzero. Returns length of data written or
4492 read; 0 for error. TARGET is unused. */
4495 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4496 int should_write
, struct mem_attrib
*attrib
,
4497 struct target_ops
*target
)
4502 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4504 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4509 /* Sends a packet with content determined by the printf format string
4510 FORMAT and the remaining arguments, then gets the reply. Returns
4511 whether the packet was a success, a failure, or unknown. */
4514 remote_send_printf (const char *format
, ...)
4516 struct remote_state
*rs
= get_remote_state ();
4517 int max_size
= get_remote_packet_size ();
4520 va_start (ap
, format
);
4523 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4524 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4526 if (putpkt (rs
->buf
) < 0)
4527 error (_("Communication problem with target."));
4530 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4532 return packet_check_result (rs
->buf
);
4536 restore_remote_timeout (void *p
)
4538 int value
= *(int *)p
;
4539 remote_timeout
= value
;
4542 /* Flash writing can take quite some time. We'll set
4543 effectively infinite timeout for flash operations.
4544 In future, we'll need to decide on a better approach. */
4545 static const int remote_flash_timeout
= 1000;
4548 remote_flash_erase (struct target_ops
*ops
,
4549 ULONGEST address
, LONGEST length
)
4551 int saved_remote_timeout
= remote_timeout
;
4552 enum packet_result ret
;
4554 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4555 &saved_remote_timeout
);
4556 remote_timeout
= remote_flash_timeout
;
4558 ret
= remote_send_printf ("vFlashErase:%s,%s",
4563 case PACKET_UNKNOWN
:
4564 error (_("Remote target does not support flash erase"));
4566 error (_("Error erasing flash with vFlashErase packet"));
4571 do_cleanups (back_to
);
4575 remote_flash_write (struct target_ops
*ops
,
4576 ULONGEST address
, LONGEST length
,
4577 const gdb_byte
*data
)
4579 int saved_remote_timeout
= remote_timeout
;
4581 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4582 &saved_remote_timeout
);
4584 remote_timeout
= remote_flash_timeout
;
4585 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4586 do_cleanups (back_to
);
4592 remote_flash_done (struct target_ops
*ops
)
4594 int saved_remote_timeout
= remote_timeout
;
4596 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4597 &saved_remote_timeout
);
4599 remote_timeout
= remote_flash_timeout
;
4600 ret
= remote_send_printf ("vFlashDone");
4601 do_cleanups (back_to
);
4605 case PACKET_UNKNOWN
:
4606 error (_("Remote target does not support vFlashDone"));
4608 error (_("Error finishing flash operation"));
4615 remote_files_info (struct target_ops
*ignore
)
4617 puts_filtered ("Debugging a target over a serial line.\n");
4620 /* Stuff for dealing with the packets which are part of this protocol.
4621 See comment at top of file for details. */
4623 /* Read a single character from the remote end. */
4626 readchar (int timeout
)
4630 ch
= serial_readchar (remote_desc
, timeout
);
4635 switch ((enum serial_rc
) ch
)
4638 target_mourn_inferior ();
4639 error (_("Remote connection closed"));
4642 perror_with_name (_("Remote communication error"));
4644 case SERIAL_TIMEOUT
:
4650 /* Send the command in *BUF to the remote machine, and read the reply
4651 into *BUF. Report an error if we get an error reply. Resize
4652 *BUF using xrealloc if necessary to hold the result, and update
4656 remote_send (char **buf
,
4660 getpkt (buf
, sizeof_buf
, 0);
4662 if ((*buf
)[0] == 'E')
4663 error (_("Remote failure reply: %s"), *buf
);
4666 /* Display a null-terminated packet on stdout, for debugging, using C
4670 print_packet (char *buf
)
4672 puts_filtered ("\"");
4673 fputstr_filtered (buf
, '"', gdb_stdout
);
4674 puts_filtered ("\"");
4680 return putpkt_binary (buf
, strlen (buf
));
4683 /* Send a packet to the remote machine, with error checking. The data
4684 of the packet is in BUF. The string in BUF can be at most
4685 get_remote_packet_size () - 5 to account for the $, # and checksum,
4686 and for a possible /0 if we are debugging (remote_debug) and want
4687 to print the sent packet as a string. */
4690 putpkt_binary (char *buf
, int cnt
)
4693 unsigned char csum
= 0;
4694 char *buf2
= alloca (cnt
+ 6);
4700 /* Copy the packet into buffer BUF2, encapsulating it
4701 and giving it a checksum. */
4706 for (i
= 0; i
< cnt
; i
++)
4712 *p
++ = tohex ((csum
>> 4) & 0xf);
4713 *p
++ = tohex (csum
& 0xf);
4715 /* Send it over and over until we get a positive ack. */
4719 int started_error_output
= 0;
4724 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4725 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4726 fprintf_unfiltered (gdb_stdlog
, "...");
4727 gdb_flush (gdb_stdlog
);
4729 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4730 perror_with_name (_("putpkt: write failed"));
4732 /* Read until either a timeout occurs (-2) or '+' is read. */
4735 ch
= readchar (remote_timeout
);
4743 case SERIAL_TIMEOUT
:
4745 if (started_error_output
)
4747 putchar_unfiltered ('\n');
4748 started_error_output
= 0;
4757 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4761 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4762 case SERIAL_TIMEOUT
:
4766 break; /* Retransmit buffer. */
4770 fprintf_unfiltered (gdb_stdlog
,
4771 "Packet instead of Ack, ignoring it\n");
4772 /* It's probably an old response sent because an ACK
4773 was lost. Gobble up the packet and ack it so it
4774 doesn't get retransmitted when we resend this
4777 serial_write (remote_desc
, "+", 1);
4778 continue; /* Now, go look for +. */
4783 if (!started_error_output
)
4785 started_error_output
= 1;
4786 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4788 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4792 break; /* Here to retransmit. */
4796 /* This is wrong. If doing a long backtrace, the user should be
4797 able to get out next time we call QUIT, without anything as
4798 violent as interrupt_query. If we want to provide a way out of
4799 here without getting to the next QUIT, it should be based on
4800 hitting ^C twice as in remote_wait. */
4810 /* Come here after finding the start of a frame when we expected an
4811 ack. Do our best to discard the rest of this packet. */
4820 c
= readchar (remote_timeout
);
4823 case SERIAL_TIMEOUT
:
4824 /* Nothing we can do. */
4827 /* Discard the two bytes of checksum and stop. */
4828 c
= readchar (remote_timeout
);
4830 c
= readchar (remote_timeout
);
4833 case '*': /* Run length encoding. */
4834 /* Discard the repeat count. */
4835 c
= readchar (remote_timeout
);
4840 /* A regular character. */
4846 /* Come here after finding the start of the frame. Collect the rest
4847 into *BUF, verifying the checksum, length, and handling run-length
4848 compression. NUL terminate the buffer. If there is not enough room,
4849 expand *BUF using xrealloc.
4851 Returns -1 on error, number of characters in buffer (ignoring the
4852 trailing NULL) on success. (could be extended to return one of the
4853 SERIAL status indications). */
4856 read_frame (char **buf_p
,
4869 c
= readchar (remote_timeout
);
4872 case SERIAL_TIMEOUT
:
4874 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4878 fputs_filtered ("Saw new packet start in middle of old one\n",
4880 return -1; /* Start a new packet, count retries. */
4883 unsigned char pktcsum
;
4889 check_0
= readchar (remote_timeout
);
4891 check_1
= readchar (remote_timeout
);
4893 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4896 fputs_filtered ("Timeout in checksum, retrying\n",
4900 else if (check_0
< 0 || check_1
< 0)
4903 fputs_filtered ("Communication error in checksum\n",
4908 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4909 if (csum
== pktcsum
)
4914 fprintf_filtered (gdb_stdlog
,
4915 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4917 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4918 fputs_filtered ("\n", gdb_stdlog
);
4920 /* Number of characters in buffer ignoring trailing
4924 case '*': /* Run length encoding. */
4929 c
= readchar (remote_timeout
);
4931 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4933 /* The character before ``*'' is repeated. */
4935 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4937 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4939 /* Make some more room in the buffer. */
4940 *sizeof_buf
+= repeat
;
4941 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4945 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4951 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4955 if (bc
>= *sizeof_buf
- 1)
4957 /* Make some more room in the buffer. */
4959 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4970 /* Read a packet from the remote machine, with error checking, and
4971 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4972 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4973 rather than timing out; this is used (in synchronous mode) to wait
4974 for a target that is is executing user code to stop. */
4975 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4976 don't have to change all the calls to getpkt to deal with the
4977 return value, because at the moment I don't know what the right
4978 thing to do it for those. */
4986 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4990 /* Read a packet from the remote machine, with error checking, and
4991 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4992 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4993 rather than timing out; this is used (in synchronous mode) to wait
4994 for a target that is is executing user code to stop. If FOREVER ==
4995 0, this function is allowed to time out gracefully and return an
4996 indication of this to the caller. Otherwise return the number
4999 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
5006 strcpy (*buf
, "timeout");
5010 timeout
= watchdog
> 0 ? watchdog
: -1;
5014 timeout
= remote_timeout
;
5018 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
5020 /* This can loop forever if the remote side sends us characters
5021 continuously, but if it pauses, we'll get a zero from
5022 readchar because of timeout. Then we'll count that as a
5025 /* Note that we will only wait forever prior to the start of a
5026 packet. After that, we expect characters to arrive at a
5027 brisk pace. They should show up within remote_timeout
5032 c
= readchar (timeout
);
5034 if (c
== SERIAL_TIMEOUT
)
5036 if (forever
) /* Watchdog went off? Kill the target. */
5039 target_mourn_inferior ();
5040 error (_("Watchdog timeout has expired. Target detached."));
5043 fputs_filtered ("Timed out.\n", gdb_stdlog
);
5049 /* We've found the start of a packet, now collect the data. */
5051 val
= read_frame (buf
, sizeof_buf
);
5057 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
5058 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
5059 fprintf_unfiltered (gdb_stdlog
, "\n");
5061 serial_write (remote_desc
, "+", 1);
5065 /* Try the whole thing again. */
5067 serial_write (remote_desc
, "-", 1);
5070 /* We have tried hard enough, and just can't receive the packet.
5073 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
5074 serial_write (remote_desc
, "+", 1);
5081 /* For some mysterious reason, wait_for_inferior calls kill instead of
5082 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5086 target_mourn_inferior ();
5090 /* Use catch_errors so the user can quit from gdb even when we aren't on
5091 speaking terms with the remote system. */
5092 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5094 /* Don't wait for it to die. I'm not really sure it matters whether
5095 we do or not. For the existing stubs, kill is a noop. */
5096 target_mourn_inferior ();
5099 /* Async version of remote_kill. */
5101 remote_async_kill (void)
5103 /* Unregister the file descriptor from the event loop. */
5104 if (target_is_async_p ())
5105 serial_async (remote_desc
, NULL
, 0);
5107 /* For some mysterious reason, wait_for_inferior calls kill instead of
5108 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5112 target_mourn_inferior ();
5116 /* Use catch_errors so the user can quit from gdb even when we
5117 aren't on speaking terms with the remote system. */
5118 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5120 /* Don't wait for it to die. I'm not really sure it matters whether
5121 we do or not. For the existing stubs, kill is a noop. */
5122 target_mourn_inferior ();
5128 remote_mourn_1 (&remote_ops
);
5132 remote_async_mourn (void)
5134 remote_mourn_1 (&remote_async_ops
);
5138 extended_remote_mourn (void)
5140 /* We do _not_ want to mourn the target like this; this will
5141 remove the extended remote target from the target stack,
5142 and the next time the user says "run" it'll fail.
5144 FIXME: What is the right thing to do here? */
5146 remote_mourn_1 (&extended_remote_ops
);
5150 /* Worker function for remote_mourn. */
5152 remote_mourn_1 (struct target_ops
*target
)
5154 unpush_target (target
);
5155 generic_mourn_inferior ();
5158 /* In the extended protocol we want to be able to do things like
5159 "run" and have them basically work as expected. So we need
5160 a special create_inferior function.
5162 FIXME: One day add support for changing the exec file
5163 we're debugging, arguments and an environment. */
5166 extended_remote_create_inferior (char *exec_file
, char *args
,
5167 char **env
, int from_tty
)
5169 /* Rip out the breakpoints; we'll reinsert them after restarting
5170 the remote server. */
5171 remove_breakpoints ();
5173 /* Now restart the remote server. */
5174 extended_remote_restart ();
5176 /* NOTE: We don't need to recheck for a target description here; but
5177 if we gain the ability to switch the remote executable we may
5178 need to, if for instance we are running a process which requested
5179 different emulated hardware from the operating system. A
5180 concrete example of this is ARM GNU/Linux, where some binaries
5181 will have a legacy FPA coprocessor emulated and others may have
5182 access to a hardware VFP unit. */
5184 /* Now put the breakpoints back in. This way we're safe if the
5185 restart function works via a unix fork on the remote side. */
5186 insert_breakpoints ();
5188 /* Clean up from the last time we were running. */
5189 clear_proceed_status ();
5192 /* Async version of extended_remote_create_inferior. */
5194 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5195 char **env
, int from_tty
)
5197 /* Rip out the breakpoints; we'll reinsert them after restarting
5198 the remote server. */
5199 remove_breakpoints ();
5201 /* If running asynchronously, register the target file descriptor
5202 with the event loop. */
5203 if (target_can_async_p ())
5204 target_async (inferior_event_handler
, 0);
5206 /* Now restart the remote server. */
5207 extended_remote_restart ();
5209 /* NOTE: We don't need to recheck for a target description here; but
5210 if we gain the ability to switch the remote executable we may
5211 need to, if for instance we are running a process which requested
5212 different emulated hardware from the operating system. A
5213 concrete example of this is ARM GNU/Linux, where some binaries
5214 will have a legacy FPA coprocessor emulated and others may have
5215 access to a hardware VFP unit. */
5217 /* Now put the breakpoints back in. This way we're safe if the
5218 restart function works via a unix fork on the remote side. */
5219 insert_breakpoints ();
5221 /* Clean up from the last time we were running. */
5222 clear_proceed_status ();
5226 /* Insert a breakpoint. On targets that have software breakpoint
5227 support, we ask the remote target to do the work; on targets
5228 which don't, we insert a traditional memory breakpoint. */
5231 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5233 CORE_ADDR addr
= bp_tgt
->placed_address
;
5234 struct remote_state
*rs
= get_remote_state ();
5236 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5237 If it succeeds, then set the support to PACKET_ENABLE. If it
5238 fails, and the user has explicitly requested the Z support then
5239 report an error, otherwise, mark it disabled and go on. */
5241 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5248 gdbarch_breakpoint_from_pc
5249 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5250 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5251 p
+= hexnumstr (p
, addr
);
5252 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5255 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5257 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5263 case PACKET_UNKNOWN
:
5268 return memory_insert_breakpoint (bp_tgt
);
5272 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5274 CORE_ADDR addr
= bp_tgt
->placed_address
;
5275 struct remote_state
*rs
= get_remote_state ();
5278 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5286 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5287 p
+= hexnumstr (p
, addr
);
5288 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5291 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5293 return (rs
->buf
[0] == 'E');
5296 return memory_remove_breakpoint (bp_tgt
);
5300 watchpoint_to_Z_packet (int type
)
5305 return Z_PACKET_WRITE_WP
;
5308 return Z_PACKET_READ_WP
;
5311 return Z_PACKET_ACCESS_WP
;
5314 internal_error (__FILE__
, __LINE__
,
5315 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5320 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5322 struct remote_state
*rs
= get_remote_state ();
5324 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5326 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5329 sprintf (rs
->buf
, "Z%x,", packet
);
5330 p
= strchr (rs
->buf
, '\0');
5331 addr
= remote_address_masked (addr
);
5332 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5333 sprintf (p
, ",%x", len
);
5336 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5338 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5341 case PACKET_UNKNOWN
:
5346 internal_error (__FILE__
, __LINE__
,
5347 _("remote_insert_watchpoint: reached end of function"));
5352 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5354 struct remote_state
*rs
= get_remote_state ();
5356 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5358 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5361 sprintf (rs
->buf
, "z%x,", packet
);
5362 p
= strchr (rs
->buf
, '\0');
5363 addr
= remote_address_masked (addr
);
5364 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5365 sprintf (p
, ",%x", len
);
5367 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5369 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5372 case PACKET_UNKNOWN
:
5377 internal_error (__FILE__
, __LINE__
,
5378 _("remote_remove_watchpoint: reached end of function"));
5382 int remote_hw_watchpoint_limit
= -1;
5383 int remote_hw_breakpoint_limit
= -1;
5386 remote_check_watch_resources (int type
, int cnt
, int ot
)
5388 if (type
== bp_hardware_breakpoint
)
5390 if (remote_hw_breakpoint_limit
== 0)
5392 else if (remote_hw_breakpoint_limit
< 0)
5394 else if (cnt
<= remote_hw_breakpoint_limit
)
5399 if (remote_hw_watchpoint_limit
== 0)
5401 else if (remote_hw_watchpoint_limit
< 0)
5405 else if (cnt
<= remote_hw_watchpoint_limit
)
5412 remote_stopped_by_watchpoint (void)
5414 return remote_stopped_by_watchpoint_p
;
5418 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5421 if (remote_stopped_by_watchpoint ())
5423 *addr_p
= remote_watch_data_address
;
5432 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5435 struct remote_state
*rs
= get_remote_state ();
5438 /* The length field should be set to the size of a breakpoint
5439 instruction, even though we aren't inserting one ourselves. */
5441 gdbarch_breakpoint_from_pc
5442 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5444 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5451 addr
= remote_address_masked (bp_tgt
->placed_address
);
5452 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5453 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5456 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5458 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5461 case PACKET_UNKNOWN
:
5466 internal_error (__FILE__
, __LINE__
,
5467 _("remote_insert_hw_breakpoint: reached end of function"));
5472 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5475 struct remote_state
*rs
= get_remote_state ();
5478 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5485 addr
= remote_address_masked (bp_tgt
->placed_address
);
5486 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5487 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5490 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5492 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5495 case PACKET_UNKNOWN
:
5500 internal_error (__FILE__
, __LINE__
,
5501 _("remote_remove_hw_breakpoint: reached end of function"));
5504 /* Some targets are only capable of doing downloads, and afterwards
5505 they switch to the remote serial protocol. This function provides
5506 a clean way to get from the download target to the remote target.
5507 It's basically just a wrapper so that we don't have to expose any
5508 of the internal workings of remote.c.
5510 Prior to calling this routine, you should shutdown the current
5511 target code, else you will get the "A program is being debugged
5512 already..." message. Usually a call to pop_target() suffices. */
5515 push_remote_target (char *name
, int from_tty
)
5517 printf_filtered (_("Switching to remote protocol\n"));
5518 remote_open (name
, from_tty
);
5521 /* Table used by the crc32 function to calcuate the checksum. */
5523 static unsigned long crc32_table
[256] =
5526 static unsigned long
5527 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5529 if (!crc32_table
[1])
5531 /* Initialize the CRC table and the decoding table. */
5535 for (i
= 0; i
< 256; i
++)
5537 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5538 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5545 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5551 /* compare-sections command
5553 With no arguments, compares each loadable section in the exec bfd
5554 with the same memory range on the target, and reports mismatches.
5555 Useful for verifying the image on the target against the exec file.
5556 Depends on the target understanding the new "qCRC:" request. */
5558 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5559 target method (target verify memory) and generic version of the
5560 actual command. This will allow other high-level code (especially
5561 generic_load()) to make use of this target functionality. */
5564 compare_sections_command (char *args
, int from_tty
)
5566 struct remote_state
*rs
= get_remote_state ();
5568 unsigned long host_crc
, target_crc
;
5569 extern bfd
*exec_bfd
;
5570 struct cleanup
*old_chain
;
5573 const char *sectname
;
5580 error (_("command cannot be used without an exec file"));
5581 if (!current_target
.to_shortname
||
5582 strcmp (current_target
.to_shortname
, "remote") != 0)
5583 error (_("command can only be used with remote target"));
5585 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5587 if (!(s
->flags
& SEC_LOAD
))
5588 continue; /* skip non-loadable section */
5590 size
= bfd_get_section_size (s
);
5592 continue; /* skip zero-length section */
5594 sectname
= bfd_get_section_name (exec_bfd
, s
);
5595 if (args
&& strcmp (args
, sectname
) != 0)
5596 continue; /* not the section selected by user */
5598 matched
= 1; /* do this section */
5600 /* FIXME: assumes lma can fit into long. */
5601 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5602 (long) lma
, (long) size
);
5605 /* Be clever; compute the host_crc before waiting for target
5607 sectdata
= xmalloc (size
);
5608 old_chain
= make_cleanup (xfree
, sectdata
);
5609 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5610 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5612 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5613 if (rs
->buf
[0] == 'E')
5614 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5615 sectname
, paddr (lma
), paddr (lma
+ size
));
5616 if (rs
->buf
[0] != 'C')
5617 error (_("remote target does not support this operation"));
5619 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5620 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5622 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5623 sectname
, paddr (lma
), paddr (lma
+ size
));
5624 if (host_crc
== target_crc
)
5625 printf_filtered ("matched.\n");
5628 printf_filtered ("MIS-MATCHED!\n");
5632 do_cleanups (old_chain
);
5635 warning (_("One or more sections of the remote executable does not match\n\
5636 the loaded file\n"));
5637 if (args
&& !matched
)
5638 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5641 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5642 into remote target. The number of bytes written to the remote
5643 target is returned, or -1 for error. */
5646 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
5647 const char *annex
, const gdb_byte
*writebuf
,
5648 ULONGEST offset
, LONGEST len
,
5649 struct packet_config
*packet
)
5654 struct remote_state
*rs
= get_remote_state ();
5655 int max_size
= get_memory_write_packet_size ();
5657 if (packet
->support
== PACKET_DISABLE
)
5660 /* Insert header. */
5661 i
= snprintf (rs
->buf
, max_size
,
5662 "qXfer:%s:write:%s:%s:",
5663 object_name
, annex
? annex
: "",
5664 phex_nz (offset
, sizeof offset
));
5665 max_size
-= (i
+ 1);
5667 /* Escape as much data as fits into rs->buf. */
5668 buf_len
= remote_escape_output
5669 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
5671 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
5672 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
5673 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5676 unpack_varlen_hex (rs
->buf
, &n
);
5680 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5681 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5682 number of bytes read is returned, or 0 for EOF, or -1 for error.
5683 The number of bytes read may be less than LEN without indicating an
5684 EOF. PACKET is checked and updated to indicate whether the remote
5685 target supports this object. */
5688 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5690 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5691 struct packet_config
*packet
)
5693 static char *finished_object
;
5694 static char *finished_annex
;
5695 static ULONGEST finished_offset
;
5697 struct remote_state
*rs
= get_remote_state ();
5698 unsigned int total
= 0;
5699 LONGEST i
, n
, packet_len
;
5701 if (packet
->support
== PACKET_DISABLE
)
5704 /* Check whether we've cached an end-of-object packet that matches
5706 if (finished_object
)
5708 if (strcmp (object_name
, finished_object
) == 0
5709 && strcmp (annex
? annex
: "", finished_annex
) == 0
5710 && offset
== finished_offset
)
5713 /* Otherwise, we're now reading something different. Discard
5715 xfree (finished_object
);
5716 xfree (finished_annex
);
5717 finished_object
= NULL
;
5718 finished_annex
= NULL
;
5721 /* Request only enough to fit in a single packet. The actual data
5722 may not, since we don't know how much of it will need to be escaped;
5723 the target is free to respond with slightly less data. We subtract
5724 five to account for the response type and the protocol frame. */
5725 n
= min (get_remote_packet_size () - 5, len
);
5726 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5727 object_name
, annex
? annex
: "",
5728 phex_nz (offset
, sizeof offset
),
5729 phex_nz (n
, sizeof n
));
5730 i
= putpkt (rs
->buf
);
5735 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5736 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5739 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5740 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5742 /* 'm' means there is (or at least might be) more data after this
5743 batch. That does not make sense unless there's at least one byte
5744 of data in this reply. */
5745 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5746 error (_("Remote qXfer reply contained no data."));
5748 /* Got some data. */
5749 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5751 /* 'l' is an EOF marker, possibly including a final block of data,
5752 or possibly empty. If we have the final block of a non-empty
5753 object, record this fact to bypass a subsequent partial read. */
5754 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
5756 finished_object
= xstrdup (object_name
);
5757 finished_annex
= xstrdup (annex
? annex
: "");
5758 finished_offset
= offset
+ i
;
5765 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5766 const char *annex
, gdb_byte
*readbuf
,
5767 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5769 struct remote_state
*rs
= get_remote_state ();
5774 /* Handle memory using the standard memory routines. */
5775 if (object
== TARGET_OBJECT_MEMORY
)
5780 if (writebuf
!= NULL
)
5781 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5783 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5787 else if (xfered
== 0 && errno
== 0)
5793 /* Handle SPU memory using qxfer packets. */
5794 if (object
== TARGET_OBJECT_SPU
)
5797 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
5798 &remote_protocol_packets
5799 [PACKET_qXfer_spu_read
]);
5801 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
5802 &remote_protocol_packets
5803 [PACKET_qXfer_spu_write
]);
5806 /* Only handle flash writes. */
5807 if (writebuf
!= NULL
)
5813 case TARGET_OBJECT_FLASH
:
5814 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5818 else if (xfered
== 0 && errno
== 0)
5828 /* Map pre-existing objects onto letters. DO NOT do this for new
5829 objects!!! Instead specify new query packets. */
5832 case TARGET_OBJECT_AVR
:
5836 case TARGET_OBJECT_AUXV
:
5837 gdb_assert (annex
== NULL
);
5838 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5839 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5841 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5842 return remote_read_qxfer
5843 (ops
, "features", annex
, readbuf
, offset
, len
,
5844 &remote_protocol_packets
[PACKET_qXfer_features
]);
5846 case TARGET_OBJECT_LIBRARIES
:
5847 return remote_read_qxfer
5848 (ops
, "libraries", annex
, readbuf
, offset
, len
,
5849 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
5851 case TARGET_OBJECT_MEMORY_MAP
:
5852 gdb_assert (annex
== NULL
);
5853 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5854 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5860 /* Note: a zero OFFSET and LEN can be used to query the minimum
5862 if (offset
== 0 && len
== 0)
5863 return (get_remote_packet_size ());
5864 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5865 large enough let the caller deal with it. */
5866 if (len
< get_remote_packet_size ())
5868 len
= get_remote_packet_size ();
5870 /* Except for querying the minimum buffer size, target must be open. */
5872 error (_("remote query is only available after target open"));
5874 gdb_assert (annex
!= NULL
);
5875 gdb_assert (readbuf
!= NULL
);
5881 /* We used one buffer char for the remote protocol q command and
5882 another for the query type. As the remote protocol encapsulation
5883 uses 4 chars plus one extra in case we are debugging
5884 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5887 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5889 /* Bad caller may have sent forbidden characters. */
5890 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5895 gdb_assert (annex
[i
] == '\0');
5897 i
= putpkt (rs
->buf
);
5901 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5902 strcpy ((char *) readbuf
, rs
->buf
);
5904 return strlen ((char *) readbuf
);
5908 remote_rcmd (char *command
,
5909 struct ui_file
*outbuf
)
5911 struct remote_state
*rs
= get_remote_state ();
5915 error (_("remote rcmd is only available after target open"));
5917 /* Send a NULL command across as an empty command. */
5918 if (command
== NULL
)
5921 /* The query prefix. */
5922 strcpy (rs
->buf
, "qRcmd,");
5923 p
= strchr (rs
->buf
, '\0');
5925 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5926 error (_("\"monitor\" command ``%s'' is too long."), command
);
5928 /* Encode the actual command. */
5929 bin2hex ((gdb_byte
*) command
, p
, 0);
5931 if (putpkt (rs
->buf
) < 0)
5932 error (_("Communication problem with target."));
5934 /* get/display the response */
5939 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5941 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5944 error (_("Target does not support this command."));
5945 if (buf
[0] == 'O' && buf
[1] != 'K')
5947 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5950 if (strcmp (buf
, "OK") == 0)
5952 if (strlen (buf
) == 3 && buf
[0] == 'E'
5953 && isdigit (buf
[1]) && isdigit (buf
[2]))
5955 error (_("Protocol error with Rcmd"));
5957 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5959 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5960 fputc_unfiltered (c
, outbuf
);
5966 static VEC(mem_region_s
) *
5967 remote_memory_map (struct target_ops
*ops
)
5969 VEC(mem_region_s
) *result
= NULL
;
5970 char *text
= target_read_stralloc (¤t_target
,
5971 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5975 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5976 result
= parse_memory_map (text
);
5977 do_cleanups (back_to
);
5984 packet_command (char *args
, int from_tty
)
5986 struct remote_state
*rs
= get_remote_state ();
5989 error (_("command can only be used with remote target"));
5992 error (_("remote-packet command requires packet text as argument"));
5994 puts_filtered ("sending: ");
5995 print_packet (args
);
5996 puts_filtered ("\n");
5999 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6000 puts_filtered ("received: ");
6001 print_packet (rs
->buf
);
6002 puts_filtered ("\n");
6006 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
6008 static void display_thread_info (struct gdb_ext_thread_info
*info
);
6010 static void threadset_test_cmd (char *cmd
, int tty
);
6012 static void threadalive_test (char *cmd
, int tty
);
6014 static void threadlist_test_cmd (char *cmd
, int tty
);
6016 int get_and_display_threadinfo (threadref
*ref
);
6018 static void threadinfo_test_cmd (char *cmd
, int tty
);
6020 static int thread_display_step (threadref
*ref
, void *context
);
6022 static void threadlist_update_test_cmd (char *cmd
, int tty
);
6024 static void init_remote_threadtests (void);
6026 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
6029 threadset_test_cmd (char *cmd
, int tty
)
6031 int sample_thread
= SAMPLE_THREAD
;
6033 printf_filtered (_("Remote threadset test\n"));
6034 set_thread (sample_thread
, 1);
6039 threadalive_test (char *cmd
, int tty
)
6041 int sample_thread
= SAMPLE_THREAD
;
6043 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
6044 printf_filtered ("PASS: Thread alive test\n");
6046 printf_filtered ("FAIL: Thread alive test\n");
6049 void output_threadid (char *title
, threadref
*ref
);
6052 output_threadid (char *title
, threadref
*ref
)
6056 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
6058 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
6062 threadlist_test_cmd (char *cmd
, int tty
)
6065 threadref nextthread
;
6066 int done
, result_count
;
6067 threadref threadlist
[3];
6069 printf_filtered ("Remote Threadlist test\n");
6070 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
6071 &result_count
, &threadlist
[0]))
6072 printf_filtered ("FAIL: threadlist test\n");
6075 threadref
*scan
= threadlist
;
6076 threadref
*limit
= scan
+ result_count
;
6078 while (scan
< limit
)
6079 output_threadid (" thread ", scan
++);
6084 display_thread_info (struct gdb_ext_thread_info
*info
)
6086 output_threadid ("Threadid: ", &info
->threadid
);
6087 printf_filtered ("Name: %s\n ", info
->shortname
);
6088 printf_filtered ("State: %s\n", info
->display
);
6089 printf_filtered ("other: %s\n\n", info
->more_display
);
6093 get_and_display_threadinfo (threadref
*ref
)
6097 struct gdb_ext_thread_info threadinfo
;
6099 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
6100 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
6101 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
6102 display_thread_info (&threadinfo
);
6107 threadinfo_test_cmd (char *cmd
, int tty
)
6109 int athread
= SAMPLE_THREAD
;
6113 int_to_threadref (&thread
, athread
);
6114 printf_filtered ("Remote Threadinfo test\n");
6115 if (!get_and_display_threadinfo (&thread
))
6116 printf_filtered ("FAIL cannot get thread info\n");
6120 thread_display_step (threadref
*ref
, void *context
)
6122 /* output_threadid(" threadstep ",ref); *//* simple test */
6123 return get_and_display_threadinfo (ref
);
6127 threadlist_update_test_cmd (char *cmd
, int tty
)
6129 printf_filtered ("Remote Threadlist update test\n");
6130 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
6134 init_remote_threadtests (void)
6136 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
6137 Fetch and print the remote list of thread identifiers, one pkt only"));
6138 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
6139 _("Fetch and display info about one thread"));
6140 add_com ("tset", class_obscure
, threadset_test_cmd
,
6141 _("Test setting to a different thread"));
6142 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
6143 _("Iterate through updating all remote thread info"));
6144 add_com ("talive", class_obscure
, threadalive_test
,
6145 _(" Remote thread alive test "));
6150 /* Convert a thread ID to a string. Returns the string in a static
6154 remote_pid_to_str (ptid_t ptid
)
6156 static char buf
[32];
6158 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
6162 /* Get the address of the thread local variable in OBJFILE which is
6163 stored at OFFSET within the thread local storage for thread PTID. */
6166 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
6168 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
6170 struct remote_state
*rs
= get_remote_state ();
6172 enum packet_result result
;
6174 strcpy (p
, "qGetTLSAddr:");
6176 p
+= hexnumstr (p
, PIDGET (ptid
));
6178 p
+= hexnumstr (p
, offset
);
6180 p
+= hexnumstr (p
, lm
);
6184 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6185 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6186 if (result
== PACKET_OK
)
6190 unpack_varlen_hex (rs
->buf
, &result
);
6193 else if (result
== PACKET_UNKNOWN
)
6194 throw_error (TLS_GENERIC_ERROR
,
6195 _("Remote target doesn't support qGetTLSAddr packet"));
6197 throw_error (TLS_GENERIC_ERROR
,
6198 _("Remote target failed to process qGetTLSAddr request"));
6201 throw_error (TLS_GENERIC_ERROR
,
6202 _("TLS not supported or disabled on this target"));
6207 /* Support for inferring a target description based on the current
6208 architecture and the size of a 'g' packet. While the 'g' packet
6209 can have any size (since optional registers can be left off the
6210 end), some sizes are easily recognizable given knowledge of the
6211 approximate architecture. */
6213 struct remote_g_packet_guess
6216 const struct target_desc
*tdesc
;
6218 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6219 DEF_VEC_O(remote_g_packet_guess_s
);
6221 struct remote_g_packet_data
6223 VEC(remote_g_packet_guess_s
) *guesses
;
6226 static struct gdbarch_data
*remote_g_packet_data_handle
;
6229 remote_g_packet_data_init (struct obstack
*obstack
)
6231 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6235 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6236 const struct target_desc
*tdesc
)
6238 struct remote_g_packet_data
*data
6239 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6240 struct remote_g_packet_guess new_guess
, *guess
;
6243 gdb_assert (tdesc
!= NULL
);
6246 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6248 if (guess
->bytes
== bytes
)
6249 internal_error (__FILE__
, __LINE__
,
6250 "Duplicate g packet description added for size %d",
6253 new_guess
.bytes
= bytes
;
6254 new_guess
.tdesc
= tdesc
;
6255 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6258 static const struct target_desc
*
6259 remote_read_description (struct target_ops
*target
)
6261 struct remote_g_packet_data
*data
6262 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6264 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6266 struct remote_g_packet_guess
*guess
;
6268 int bytes
= send_g_packet ();
6271 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6273 if (guess
->bytes
== bytes
)
6274 return guess
->tdesc
;
6276 /* We discard the g packet. A minor optimization would be to
6277 hold on to it, and fill the register cache once we have selected
6278 an architecture, but it's too tricky to do safely. */
6284 /* Remote file transfer support. This is host-initiated I/O, not
6285 target-initiated; for target-initiated, see remote-fileio.c. */
6287 /* If *LEFT is at least the length of STRING, copy STRING to
6288 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6289 decrease *LEFT. Otherwise raise an error. */
6292 remote_buffer_add_string (char **buffer
, int *left
, char *string
)
6294 int len
= strlen (string
);
6297 error (_("Packet too long for target."));
6299 memcpy (*buffer
, string
, len
);
6303 /* NUL-terminate the buffer as a convenience, if there is
6309 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
6310 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6311 decrease *LEFT. Otherwise raise an error. */
6314 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
6317 if (2 * len
> *left
)
6318 error (_("Packet too long for target."));
6320 bin2hex (bytes
, *buffer
, len
);
6324 /* NUL-terminate the buffer as a convenience, if there is
6330 /* If *LEFT is large enough, convert VALUE to hex and add it to
6331 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6332 decrease *LEFT. Otherwise raise an error. */
6335 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
6337 int len
= hexnumlen (value
);
6340 error (_("Packet too long for target."));
6342 hexnumstr (*buffer
, value
);
6346 /* NUL-terminate the buffer as a convenience, if there is
6352 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
6353 value, *REMOTE_ERRNO to the remote error number or zero if none
6354 was included, and *ATTACHMENT to point to the start of the annex
6355 if any. The length of the packet isn't needed here; there may
6356 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
6358 Return 0 if the packet could be parsed, -1 if it could not. If
6359 -1 is returned, the other variables may not be initialized. */
6362 remote_hostio_parse_result (char *buffer
, int *retcode
,
6363 int *remote_errno
, char **attachment
)
6370 if (buffer
[0] != 'F')
6374 *retcode
= strtol (&buffer
[1], &p
, 16);
6375 if (errno
!= 0 || p
== &buffer
[1])
6378 /* Check for ",errno". */
6382 *remote_errno
= strtol (p
+ 1, &p2
, 16);
6383 if (errno
!= 0 || p
+ 1 == p2
)
6388 /* Check for ";attachment". If there is no attachment, the
6389 packet should end here. */
6392 *attachment
= p
+ 1;
6395 else if (*p
== '\0')
6401 /* Send a prepared I/O packet to the target and read its response.
6402 The prepared packet is in the global RS->BUF before this function
6403 is called, and the answer is there when we return.
6405 COMMAND_BYTES is the length of the request to send, which may include
6406 binary data. WHICH_PACKET is the packet configuration to check
6407 before attempting a packet. If an error occurs, *REMOTE_ERRNO
6408 is set to the error number and -1 is returned. Otherwise the value
6409 returned by the function is returned.
6411 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
6412 attachment is expected; an error will be reported if there's a
6413 mismatch. If one is found, *ATTACHMENT will be set to point into
6414 the packet buffer and *ATTACHMENT_LEN will be set to the
6415 attachment's length. */
6418 remote_hostio_send_command (int command_bytes
, int which_packet
,
6419 int *remote_errno
, char **attachment
,
6420 int *attachment_len
)
6422 struct remote_state
*rs
= get_remote_state ();
6423 int ret
, bytes_read
;
6424 char *attachment_tmp
;
6426 if (remote_protocol_packets
[which_packet
].support
== PACKET_DISABLE
)
6428 *remote_errno
= FILEIO_ENOSYS
;
6432 putpkt_binary (rs
->buf
, command_bytes
);
6433 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
6435 /* If it timed out, something is wrong. Don't try to parse the
6439 *remote_errno
= FILEIO_EINVAL
;
6443 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
6446 *remote_errno
= FILEIO_EINVAL
;
6448 case PACKET_UNKNOWN
:
6449 *remote_errno
= FILEIO_ENOSYS
;
6455 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
6458 *remote_errno
= FILEIO_EINVAL
;
6462 /* Make sure we saw an attachment if and only if we expected one. */
6463 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
6464 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
6466 *remote_errno
= FILEIO_EINVAL
;
6470 /* If an attachment was found, it must point into the packet buffer;
6471 work out how many bytes there were. */
6472 if (attachment_tmp
!= NULL
)
6474 *attachment
= attachment_tmp
;
6475 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
6481 /* Open FILENAME on the remote target, using FLAGS and MODE. Return a
6482 remote file descriptor, or -1 if an error occurs (and set
6486 remote_hostio_open (const char *filename
, int flags
, int mode
,
6489 struct remote_state
*rs
= get_remote_state ();
6491 int left
= get_remote_packet_size () - 1;
6493 remote_buffer_add_string (&p
, &left
, "vFile:open:");
6495 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
6497 remote_buffer_add_string (&p
, &left
, ",");
6499 remote_buffer_add_int (&p
, &left
, flags
);
6500 remote_buffer_add_string (&p
, &left
, ",");
6502 remote_buffer_add_int (&p
, &left
, mode
);
6504 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
6505 remote_errno
, NULL
, NULL
);
6508 /* Write up to LEN bytes from WRITE_BUF to FD on the remote target.
6509 Return the number of bytes written, or -1 if an error occurs (and
6510 set *REMOTE_ERRNO). */
6513 remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
6514 ULONGEST offset
, int *remote_errno
)
6516 struct remote_state
*rs
= get_remote_state ();
6518 int left
= get_remote_packet_size ();
6521 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
6523 remote_buffer_add_int (&p
, &left
, fd
);
6524 remote_buffer_add_string (&p
, &left
, ",");
6526 remote_buffer_add_int (&p
, &left
, offset
);
6527 remote_buffer_add_string (&p
, &left
, ",");
6529 p
+= remote_escape_output (write_buf
, len
, p
, &out_len
,
6530 get_remote_packet_size () - (p
- rs
->buf
));
6532 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
6533 remote_errno
, NULL
, NULL
);
6536 /* Read up to LEN bytes FD on the remote target into READ_BUF
6537 Return the number of bytes read, or -1 if an error occurs (and
6538 set *REMOTE_ERRNO). */
6541 remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
6542 ULONGEST offset
, int *remote_errno
)
6544 struct remote_state
*rs
= get_remote_state ();
6547 int left
= get_remote_packet_size ();
6548 int ret
, attachment_len
;
6551 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
6553 remote_buffer_add_int (&p
, &left
, fd
);
6554 remote_buffer_add_string (&p
, &left
, ",");
6556 remote_buffer_add_int (&p
, &left
, len
);
6557 remote_buffer_add_string (&p
, &left
, ",");
6559 remote_buffer_add_int (&p
, &left
, offset
);
6561 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
6562 remote_errno
, &attachment
,
6568 read_len
= remote_unescape_input (attachment
, attachment_len
,
6570 if (read_len
!= ret
)
6571 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
6576 /* Close FD on the remote target. Return 0, or -1 if an error occurs
6577 (and set *REMOTE_ERRNO). */
6580 remote_hostio_close (int fd
, int *remote_errno
)
6582 struct remote_state
*rs
= get_remote_state ();
6584 int left
= get_remote_packet_size () - 1;
6586 remote_buffer_add_string (&p
, &left
, "vFile:close:");
6588 remote_buffer_add_int (&p
, &left
, fd
);
6590 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
6591 remote_errno
, NULL
, NULL
);
6594 /* Unlink FILENAME on the remote target. Return 0, or -1 if an error
6595 occurs (and set *REMOTE_ERRNO). */
6598 remote_hostio_unlink (const char *filename
, int *remote_errno
)
6600 struct remote_state
*rs
= get_remote_state ();
6602 int left
= get_remote_packet_size () - 1;
6604 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
6606 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
6609 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
6610 remote_errno
, NULL
, NULL
);
6614 remote_fileio_errno_to_host (int errnum
)
6638 case FILEIO_ENOTDIR
:
6658 case FILEIO_ENAMETOOLONG
:
6659 return ENAMETOOLONG
;
6665 remote_hostio_error (int errnum
)
6667 int host_error
= remote_fileio_errno_to_host (errnum
);
6669 if (host_error
== -1)
6670 error (_("Unknown remote I/O error %d"), errnum
);
6672 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
6676 fclose_cleanup (void *file
)
6682 remote_hostio_close_cleanup (void *opaque
)
6684 int fd
= *(int *) opaque
;
6687 remote_hostio_close (fd
, &remote_errno
);
6691 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
6693 struct cleanup
*back_to
, *close_cleanup
;
6694 int retcode
, fd
, remote_errno
, bytes
, io_size
;
6697 int bytes_in_buffer
;
6702 error (_("command can only be used with remote target"));
6704 file
= fopen (local_file
, "rb");
6706 perror_with_name (local_file
);
6707 back_to
= make_cleanup (fclose_cleanup
, file
);
6709 fd
= remote_hostio_open (remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
6711 0700, &remote_errno
);
6713 remote_hostio_error (remote_errno
);
6715 /* Send up to this many bytes at once. They won't all fit in the
6716 remote packet limit, so we'll transfer slightly fewer. */
6717 io_size
= get_remote_packet_size ();
6718 buffer
= xmalloc (io_size
);
6719 make_cleanup (xfree
, buffer
);
6721 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
6723 bytes_in_buffer
= 0;
6726 while (bytes_in_buffer
|| !saw_eof
)
6730 bytes
= fread (buffer
+ bytes_in_buffer
, 1, io_size
- bytes_in_buffer
,
6735 error (_("Error reading %s."), local_file
);
6738 /* EOF. Unless there is something still in the
6739 buffer from the last iteration, we are done. */
6741 if (bytes_in_buffer
== 0)
6749 bytes
+= bytes_in_buffer
;
6750 bytes_in_buffer
= 0;
6752 retcode
= remote_hostio_pwrite (fd
, buffer
, bytes
, offset
, &remote_errno
);
6755 remote_hostio_error (remote_errno
);
6756 else if (retcode
== 0)
6757 error (_("Remote write of %d bytes returned 0!"), bytes
);
6758 else if (retcode
< bytes
)
6760 /* Short write. Save the rest of the read data for the next
6762 bytes_in_buffer
= bytes
- retcode
;
6763 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
6769 discard_cleanups (close_cleanup
);
6770 if (remote_hostio_close (fd
, &remote_errno
))
6771 remote_hostio_error (remote_errno
);
6774 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
6775 do_cleanups (back_to
);
6779 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
6781 struct cleanup
*back_to
, *close_cleanup
;
6782 int retcode
, fd
, remote_errno
, bytes
, io_size
;
6788 error (_("command can only be used with remote target"));
6790 fd
= remote_hostio_open (remote_file
, FILEIO_O_RDONLY
, 0, &remote_errno
);
6792 remote_hostio_error (remote_errno
);
6794 file
= fopen (local_file
, "wb");
6796 perror_with_name (local_file
);
6797 back_to
= make_cleanup (fclose_cleanup
, file
);
6799 /* Send up to this many bytes at once. They won't all fit in the
6800 remote packet limit, so we'll transfer slightly fewer. */
6801 io_size
= get_remote_packet_size ();
6802 buffer
= xmalloc (io_size
);
6803 make_cleanup (xfree
, buffer
);
6805 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
6810 bytes
= remote_hostio_pread (fd
, buffer
, io_size
, offset
, &remote_errno
);
6812 /* Success, but no bytes, means end-of-file. */
6815 remote_hostio_error (remote_errno
);
6819 bytes
= fwrite (buffer
, 1, bytes
, file
);
6821 perror_with_name (local_file
);
6824 discard_cleanups (close_cleanup
);
6825 if (remote_hostio_close (fd
, &remote_errno
))
6826 remote_hostio_error (remote_errno
);
6829 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
6830 do_cleanups (back_to
);
6834 remote_file_delete (const char *remote_file
, int from_tty
)
6836 int retcode
, remote_errno
;
6839 error (_("command can only be used with remote target"));
6841 retcode
= remote_hostio_unlink (remote_file
, &remote_errno
);
6843 remote_hostio_error (remote_errno
);
6846 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
6850 remote_put_command (char *args
, int from_tty
)
6852 struct cleanup
*back_to
;
6855 argv
= buildargv (args
);
6858 back_to
= make_cleanup_freeargv (argv
);
6859 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
6860 error (_("Invalid parameters to remote put"));
6862 remote_file_put (argv
[0], argv
[1], from_tty
);
6864 do_cleanups (back_to
);
6868 remote_get_command (char *args
, int from_tty
)
6870 struct cleanup
*back_to
;
6873 argv
= buildargv (args
);
6876 back_to
= make_cleanup_freeargv (argv
);
6877 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
6878 error (_("Invalid parameters to remote get"));
6880 remote_file_get (argv
[0], argv
[1], from_tty
);
6882 do_cleanups (back_to
);
6886 remote_delete_command (char *args
, int from_tty
)
6888 struct cleanup
*back_to
;
6891 argv
= buildargv (args
);
6894 back_to
= make_cleanup_freeargv (argv
);
6895 if (argv
[0] == NULL
|| argv
[1] != NULL
)
6896 error (_("Invalid parameters to remote delete"));
6898 remote_file_delete (argv
[0], from_tty
);
6900 do_cleanups (back_to
);
6904 remote_command (char *args
, int from_tty
)
6906 help_list (remote_cmdlist
, "remote ", -1, gdb_stdout
);
6910 init_remote_ops (void)
6912 remote_ops
.to_shortname
= "remote";
6913 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6915 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6916 Specify the serial device it is connected to\n\
6917 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6918 remote_ops
.to_open
= remote_open
;
6919 remote_ops
.to_close
= remote_close
;
6920 remote_ops
.to_detach
= remote_detach
;
6921 remote_ops
.to_disconnect
= remote_disconnect
;
6922 remote_ops
.to_resume
= remote_resume
;
6923 remote_ops
.to_wait
= remote_wait
;
6924 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6925 remote_ops
.to_store_registers
= remote_store_registers
;
6926 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6927 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6928 remote_ops
.to_files_info
= remote_files_info
;
6929 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6930 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6931 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6932 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6933 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6934 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6935 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6936 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6937 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6938 remote_ops
.to_kill
= remote_kill
;
6939 remote_ops
.to_load
= generic_load
;
6940 remote_ops
.to_mourn_inferior
= remote_mourn
;
6941 remote_ops
.to_thread_alive
= remote_thread_alive
;
6942 remote_ops
.to_find_new_threads
= remote_threads_info
;
6943 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6944 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6945 remote_ops
.to_stop
= remote_stop
;
6946 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6947 remote_ops
.to_rcmd
= remote_rcmd
;
6948 remote_ops
.to_log_command
= serial_log_command
;
6949 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6950 remote_ops
.to_stratum
= process_stratum
;
6951 remote_ops
.to_has_all_memory
= 1;
6952 remote_ops
.to_has_memory
= 1;
6953 remote_ops
.to_has_stack
= 1;
6954 remote_ops
.to_has_registers
= 1;
6955 remote_ops
.to_has_execution
= 1;
6956 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6957 remote_ops
.to_magic
= OPS_MAGIC
;
6958 remote_ops
.to_memory_map
= remote_memory_map
;
6959 remote_ops
.to_flash_erase
= remote_flash_erase
;
6960 remote_ops
.to_flash_done
= remote_flash_done
;
6961 remote_ops
.to_read_description
= remote_read_description
;
6964 /* Set up the extended remote vector by making a copy of the standard
6965 remote vector and adding to it. */
6968 init_extended_remote_ops (void)
6970 extended_remote_ops
= remote_ops
;
6972 extended_remote_ops
.to_shortname
= "extended-remote";
6973 extended_remote_ops
.to_longname
=
6974 "Extended remote serial target in gdb-specific protocol";
6975 extended_remote_ops
.to_doc
=
6976 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6977 Specify the serial device it is connected to (e.g. /dev/ttya).",
6978 extended_remote_ops
.to_open
= extended_remote_open
;
6979 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6980 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6984 remote_can_async_p (void)
6986 /* We're async whenever the serial device is. */
6987 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6991 remote_is_async_p (void)
6993 /* We're async whenever the serial device is. */
6994 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6997 /* Pass the SERIAL event on and up to the client. One day this code
6998 will be able to delay notifying the client of an event until the
6999 point where an entire packet has been received. */
7001 static void (*async_client_callback
) (enum inferior_event_type event_type
,
7003 static void *async_client_context
;
7004 static serial_event_ftype remote_async_serial_handler
;
7007 remote_async_serial_handler (struct serial
*scb
, void *context
)
7009 /* Don't propogate error information up to the client. Instead let
7010 the client find out about the error by querying the target. */
7011 async_client_callback (INF_REG_EVENT
, async_client_context
);
7015 remote_async (void (*callback
) (enum inferior_event_type event_type
,
7016 void *context
), void *context
)
7018 if (current_target
.to_async_mask_value
== 0)
7019 internal_error (__FILE__
, __LINE__
,
7020 _("Calling remote_async when async is masked"));
7022 if (callback
!= NULL
)
7024 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
7025 async_client_callback
= callback
;
7026 async_client_context
= context
;
7029 serial_async (remote_desc
, NULL
, NULL
);
7032 /* Target async and target extended-async.
7034 This are temporary targets, until it is all tested. Eventually
7035 async support will be incorporated int the usual 'remote'
7039 init_remote_async_ops (void)
7041 remote_async_ops
.to_shortname
= "async";
7042 remote_async_ops
.to_longname
=
7043 "Remote serial target in async version of the gdb-specific protocol";
7044 remote_async_ops
.to_doc
=
7045 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
7046 Specify the serial device it is connected to (e.g. /dev/ttya).";
7047 remote_async_ops
.to_open
= remote_async_open
;
7048 remote_async_ops
.to_close
= remote_close
;
7049 remote_async_ops
.to_detach
= remote_detach
;
7050 remote_async_ops
.to_disconnect
= remote_disconnect
;
7051 remote_async_ops
.to_resume
= remote_async_resume
;
7052 remote_async_ops
.to_wait
= remote_async_wait
;
7053 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
7054 remote_async_ops
.to_store_registers
= remote_store_registers
;
7055 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
7056 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
7057 remote_async_ops
.to_files_info
= remote_files_info
;
7058 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
7059 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
7060 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
7061 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
7062 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
7063 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
7064 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
7065 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
7066 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
7067 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
7068 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
7069 remote_async_ops
.to_kill
= remote_async_kill
;
7070 remote_async_ops
.to_load
= generic_load
;
7071 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
7072 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
7073 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
7074 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
7075 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
7076 remote_async_ops
.to_stop
= remote_stop
;
7077 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
7078 remote_async_ops
.to_rcmd
= remote_rcmd
;
7079 remote_async_ops
.to_stratum
= process_stratum
;
7080 remote_async_ops
.to_has_all_memory
= 1;
7081 remote_async_ops
.to_has_memory
= 1;
7082 remote_async_ops
.to_has_stack
= 1;
7083 remote_async_ops
.to_has_registers
= 1;
7084 remote_async_ops
.to_has_execution
= 1;
7085 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
7086 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
7087 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
7088 remote_async_ops
.to_async
= remote_async
;
7089 remote_async_ops
.to_async_mask_value
= 1;
7090 remote_async_ops
.to_magic
= OPS_MAGIC
;
7091 remote_async_ops
.to_memory_map
= remote_memory_map
;
7092 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
7093 remote_async_ops
.to_flash_done
= remote_flash_done
;
7094 remote_async_ops
.to_read_description
= remote_read_description
;
7097 /* Set up the async extended remote vector by making a copy of the standard
7098 remote vector and adding to it. */
7101 init_extended_async_remote_ops (void)
7103 extended_async_remote_ops
= remote_async_ops
;
7105 extended_async_remote_ops
.to_shortname
= "extended-async";
7106 extended_async_remote_ops
.to_longname
=
7107 "Extended remote serial target in async gdb-specific protocol";
7108 extended_async_remote_ops
.to_doc
=
7109 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
7110 Specify the serial device it is connected to (e.g. /dev/ttya).",
7111 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
7112 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
7113 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
7117 set_remote_cmd (char *args
, int from_tty
)
7119 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
7123 show_remote_cmd (char *args
, int from_tty
)
7125 /* We can't just use cmd_show_list here, because we want to skip
7126 the redundant "show remote Z-packet" and the legacy aliases. */
7127 struct cleanup
*showlist_chain
;
7128 struct cmd_list_element
*list
= remote_show_cmdlist
;
7130 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
7131 for (; list
!= NULL
; list
= list
->next
)
7132 if (strcmp (list
->name
, "Z-packet") == 0)
7134 else if (list
->type
== not_set_cmd
)
7135 /* Alias commands are exactly like the original, except they
7136 don't have the normal type. */
7140 struct cleanup
*option_chain
7141 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
7142 ui_out_field_string (uiout
, "name", list
->name
);
7143 ui_out_text (uiout
, ": ");
7144 if (list
->type
== show_cmd
)
7145 do_setshow_command ((char *) NULL
, from_tty
, list
);
7147 cmd_func (list
, NULL
, from_tty
);
7148 /* Close the tuple. */
7149 do_cleanups (option_chain
);
7152 /* Close the tuple. */
7153 do_cleanups (showlist_chain
);
7157 /* Function to be called whenever a new objfile (shlib) is detected. */
7159 remote_new_objfile (struct objfile
*objfile
)
7161 if (remote_desc
!= 0) /* Have a remote connection. */
7162 remote_check_symbols (objfile
);
7166 _initialize_remote (void)
7168 struct remote_state
*rs
;
7170 /* architecture specific data */
7171 remote_gdbarch_data_handle
=
7172 gdbarch_data_register_post_init (init_remote_state
);
7173 remote_g_packet_data_handle
=
7174 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
7176 /* Initialize the per-target state. At the moment there is only one
7177 of these, not one per target. Only one target is active at a
7178 time. The default buffer size is unimportant; it will be expanded
7179 whenever a larger buffer is needed. */
7180 rs
= get_remote_state_raw ();
7182 rs
->buf
= xmalloc (rs
->buf_size
);
7185 add_target (&remote_ops
);
7187 init_extended_remote_ops ();
7188 add_target (&extended_remote_ops
);
7190 init_remote_async_ops ();
7191 add_target (&remote_async_ops
);
7193 init_extended_async_remote_ops ();
7194 add_target (&extended_async_remote_ops
);
7196 /* Hook into new objfile notification. */
7197 observer_attach_new_objfile (remote_new_objfile
);
7200 init_remote_threadtests ();
7203 /* set/show remote ... */
7205 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
7206 Remote protocol specific variables\n\
7207 Configure various remote-protocol specific variables such as\n\
7208 the packets being used"),
7209 &remote_set_cmdlist
, "set remote ",
7210 0 /* allow-unknown */, &setlist
);
7211 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
7212 Remote protocol specific variables\n\
7213 Configure various remote-protocol specific variables such as\n\
7214 the packets being used"),
7215 &remote_show_cmdlist
, "show remote ",
7216 0 /* allow-unknown */, &showlist
);
7218 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
7219 Compare section data on target to the exec file.\n\
7220 Argument is a single section name (default: all loaded sections)."),
7223 add_cmd ("packet", class_maintenance
, packet_command
, _("\
7224 Send an arbitrary packet to a remote target.\n\
7225 maintenance packet TEXT\n\
7226 If GDB is talking to an inferior via the GDB serial protocol, then\n\
7227 this command sends the string TEXT to the inferior, and displays the\n\
7228 response packet. GDB supplies the initial `$' character, and the\n\
7229 terminating `#' character and checksum."),
7232 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
7233 Set whether to send break if interrupted."), _("\
7234 Show whether to send break if interrupted."), _("\
7235 If set, a break, instead of a cntrl-c, is sent to the remote target."),
7236 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
7237 &setlist
, &showlist
);
7239 /* Install commands for configuring memory read/write packets. */
7241 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
7242 Set the maximum number of bytes per memory write packet (deprecated)."),
7244 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
7245 Show the maximum number of bytes per memory write packet (deprecated)."),
7247 add_cmd ("memory-write-packet-size", no_class
,
7248 set_memory_write_packet_size
, _("\
7249 Set the maximum number of bytes per memory-write packet.\n\
7250 Specify the number of bytes in a packet or 0 (zero) for the\n\
7251 default packet size. The actual limit is further reduced\n\
7252 dependent on the target. Specify ``fixed'' to disable the\n\
7253 further restriction and ``limit'' to enable that restriction."),
7254 &remote_set_cmdlist
);
7255 add_cmd ("memory-read-packet-size", no_class
,
7256 set_memory_read_packet_size
, _("\
7257 Set the maximum number of bytes per memory-read packet.\n\
7258 Specify the number of bytes in a packet or 0 (zero) for the\n\
7259 default packet size. The actual limit is further reduced\n\
7260 dependent on the target. Specify ``fixed'' to disable the\n\
7261 further restriction and ``limit'' to enable that restriction."),
7262 &remote_set_cmdlist
);
7263 add_cmd ("memory-write-packet-size", no_class
,
7264 show_memory_write_packet_size
,
7265 _("Show the maximum number of bytes per memory-write packet."),
7266 &remote_show_cmdlist
);
7267 add_cmd ("memory-read-packet-size", no_class
,
7268 show_memory_read_packet_size
,
7269 _("Show the maximum number of bytes per memory-read packet."),
7270 &remote_show_cmdlist
);
7272 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
7273 &remote_hw_watchpoint_limit
, _("\
7274 Set the maximum number of target hardware watchpoints."), _("\
7275 Show the maximum number of target hardware watchpoints."), _("\
7276 Specify a negative limit for unlimited."),
7277 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
7278 &remote_set_cmdlist
, &remote_show_cmdlist
);
7279 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
7280 &remote_hw_breakpoint_limit
, _("\
7281 Set the maximum number of target hardware breakpoints."), _("\
7282 Show the maximum number of target hardware breakpoints."), _("\
7283 Specify a negative limit for unlimited."),
7284 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
7285 &remote_set_cmdlist
, &remote_show_cmdlist
);
7287 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
7288 &remote_address_size
, _("\
7289 Set the maximum size of the address (in bits) in a memory packet."), _("\
7290 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
7292 NULL
, /* FIXME: i18n: */
7293 &setlist
, &showlist
);
7295 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
7296 "X", "binary-download", 1);
7298 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
7299 "vCont", "verbose-resume", 0);
7301 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
7302 "QPassSignals", "pass-signals", 0);
7304 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
7305 "qSymbol", "symbol-lookup", 0);
7307 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
7308 "P", "set-register", 1);
7310 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
7311 "p", "fetch-register", 1);
7313 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
7314 "Z0", "software-breakpoint", 0);
7316 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
7317 "Z1", "hardware-breakpoint", 0);
7319 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
7320 "Z2", "write-watchpoint", 0);
7322 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
7323 "Z3", "read-watchpoint", 0);
7325 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
7326 "Z4", "access-watchpoint", 0);
7328 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
7329 "qXfer:auxv:read", "read-aux-vector", 0);
7331 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
7332 "qXfer:features:read", "target-features", 0);
7334 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
7335 "qXfer:libraries:read", "library-info", 0);
7337 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
7338 "qXfer:memory-map:read", "memory-map", 0);
7340 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
7341 "qXfer:spu:read", "read-spu-object", 0);
7343 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
7344 "qXfer:spu:write", "write-spu-object", 0);
7346 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
7347 "qGetTLSAddr", "get-thread-local-storage-address",
7350 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
7351 "qSupported", "supported-packets", 0);
7353 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
7354 "vFile:open", "hostio-open", 0);
7356 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
7357 "vFile:pread", "hostio-pread", 0);
7359 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
7360 "vFile:pwrite", "hostio-pwrite", 0);
7362 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
7363 "vFile:close", "hostio-close", 0);
7365 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
7366 "vFile:unlink", "hostio-unlink", 0);
7368 /* Keep the old ``set remote Z-packet ...'' working. Each individual
7369 Z sub-packet has its own set and show commands, but users may
7370 have sets to this variable in their .gdbinit files (or in their
7372 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
7373 &remote_Z_packet_detect
, _("\
7374 Set use of remote protocol `Z' packets"), _("\
7375 Show use of remote protocol `Z' packets "), _("\
7376 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
7378 set_remote_protocol_Z_packet_cmd
,
7379 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
7380 &remote_set_cmdlist
, &remote_show_cmdlist
);
7382 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
7383 Manipulate files on the remote system\n\
7384 Transfer files to and from the remote target system."),
7385 &remote_cmdlist
, "remote ",
7386 0 /* allow-unknown */, &cmdlist
);
7388 add_cmd ("put", class_files
, remote_put_command
,
7389 _("Copy a local file to the remote system."),
7392 add_cmd ("get", class_files
, remote_get_command
,
7393 _("Copy a remote file to the local system."),
7396 add_cmd ("delete", class_files
, remote_delete_command
,
7397 _("Delete a remote file."),
7400 /* Eventually initialize fileio. See fileio.c */
7401 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);