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 /* If the user hit C-c before this packet, or between packets,
3208 pretend that it was hit right here. */
3212 remote_interrupt (SIGINT
);
3214 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3215 signal (SIGINT
, ofunc
);
3219 /* This is a hook for when we need to do something (perhaps the
3220 collection of trace data) every time the target stops. */
3221 if (deprecated_target_wait_loop_hook
)
3222 (*deprecated_target_wait_loop_hook
) ();
3224 remote_stopped_by_watchpoint_p
= 0;
3228 case 'E': /* Error of some sort. */
3229 warning (_("Remote failure reply: %s"), buf
);
3231 case 'F': /* File-I/O request. */
3232 remote_fileio_request (buf
);
3234 case 'T': /* Status with PC, SP, FP, ... */
3236 gdb_byte regs
[MAX_REGISTER_SIZE
];
3238 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3239 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3241 n... = register number
3242 r... = register contents
3244 p
= &buf
[3]; /* after Txx */
3253 /* If the packet contains a register number save it in
3254 pnum and set p1 to point to the character following
3255 it. Otherwise p1 points to p. */
3257 /* If this packet is an awatch packet, don't parse the
3258 'a' as a register number. */
3260 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3262 /* Read the ``P'' register number. */
3263 pnum
= strtol (p
, &p_temp
, 16);
3269 if (p1
== p
) /* No register number present here. */
3271 p1
= strchr (p
, ':');
3273 error (_("Malformed packet(a) (missing colon): %s\n\
3276 if (strncmp (p
, "thread", p1
- p
) == 0)
3278 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3279 record_currthread (thread_num
);
3282 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3283 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3284 || (strncmp (p
, "awatch", p1
- p
) == 0))
3286 remote_stopped_by_watchpoint_p
= 1;
3287 p
= unpack_varlen_hex (++p1
, &addr
);
3288 remote_watch_data_address
= (CORE_ADDR
)addr
;
3290 else if (strncmp (p
, "library", p1
- p
) == 0)
3294 while (*p_temp
&& *p_temp
!= ';')
3302 /* Silently skip unknown optional info. */
3303 p_temp
= strchr (p1
+ 1, ';');
3310 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3314 error (_("Malformed packet(b) (missing colon): %s\n\
3319 error (_("Remote sent bad register number %s: %s\n\
3321 phex_nz (pnum
, 0), p
, buf
);
3323 fieldsize
= hex2bin (p
, regs
,
3324 register_size (current_gdbarch
,
3327 if (fieldsize
< register_size (current_gdbarch
,
3329 warning (_("Remote reply is too short: %s"), buf
);
3330 regcache_raw_supply (get_current_regcache (),
3335 error (_("Remote register badly formatted: %s\nhere: %s"),
3340 case 'S': /* Old style status, just signal only. */
3342 status
->kind
= TARGET_WAITKIND_LOADED
;
3345 status
->kind
= TARGET_WAITKIND_STOPPED
;
3346 status
->value
.sig
= (enum target_signal
)
3347 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3352 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3353 record_currthread (thread_num
);
3356 case 'W': /* Target exited. */
3358 /* The remote process exited. */
3359 status
->kind
= TARGET_WAITKIND_EXITED
;
3360 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3364 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3365 status
->value
.sig
= (enum target_signal
)
3366 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3370 case 'O': /* Console output. */
3371 remote_console_output (buf
+ 1);
3374 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3376 /* Zero length reply means that we tried 'S' or 'C' and
3377 the remote system doesn't support it. */
3378 target_terminal_ours_for_output ();
3380 ("Can't send signals to this remote system. %s not sent.\n",
3381 target_signal_to_name (last_sent_signal
));
3382 last_sent_signal
= TARGET_SIGNAL_0
;
3383 target_terminal_inferior ();
3385 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3386 putpkt ((char *) buf
);
3389 /* else fallthrough */
3391 warning (_("Invalid remote reply: %s"), buf
);
3396 if (thread_num
!= -1)
3398 return pid_to_ptid (thread_num
);
3400 return inferior_ptid
;
3403 /* Async version of remote_wait. */
3405 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3407 struct remote_state
*rs
= get_remote_state ();
3408 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3409 ULONGEST thread_num
= -1;
3411 int solibs_changed
= 0;
3413 status
->kind
= TARGET_WAITKIND_EXITED
;
3414 status
->value
.integer
= 0;
3416 remote_stopped_by_watchpoint_p
= 0;
3422 if (!target_is_async_p ())
3424 ofunc
= signal (SIGINT
, remote_interrupt
);
3425 /* If the user hit C-c before this packet, or between packets,
3426 pretend that it was hit right here. */
3430 remote_interrupt (SIGINT
);
3433 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3434 _never_ wait for ever -> test on target_is_async_p().
3435 However, before we do that we need to ensure that the caller
3436 knows how to take the target into/out of async mode. */
3437 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3438 if (!target_is_async_p ())
3439 signal (SIGINT
, ofunc
);
3443 /* This is a hook for when we need to do something (perhaps the
3444 collection of trace data) every time the target stops. */
3445 if (deprecated_target_wait_loop_hook
)
3446 (*deprecated_target_wait_loop_hook
) ();
3450 case 'E': /* Error of some sort. */
3451 warning (_("Remote failure reply: %s"), buf
);
3453 case 'F': /* File-I/O request. */
3454 remote_fileio_request (buf
);
3456 case 'T': /* Status with PC, SP, FP, ... */
3458 gdb_byte regs
[MAX_REGISTER_SIZE
];
3460 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3461 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3463 n... = register number
3464 r... = register contents
3466 p
= &buf
[3]; /* after Txx */
3475 /* If the packet contains a register number, save it
3476 in pnum and set p1 to point to the character
3477 following it. Otherwise p1 points to p. */
3479 /* If this packet is an awatch packet, don't parse the 'a'
3480 as a register number. */
3482 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3484 /* Read the register number. */
3485 pnum
= strtol (p
, &p_temp
, 16);
3491 if (p1
== p
) /* No register number present here. */
3493 p1
= strchr (p
, ':');
3495 error (_("Malformed packet(a) (missing colon): %s\n\
3498 if (strncmp (p
, "thread", p1
- p
) == 0)
3500 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3501 record_currthread (thread_num
);
3504 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3505 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3506 || (strncmp (p
, "awatch", p1
- p
) == 0))
3508 remote_stopped_by_watchpoint_p
= 1;
3509 p
= unpack_varlen_hex (++p1
, &addr
);
3510 remote_watch_data_address
= (CORE_ADDR
)addr
;
3512 else if (strncmp (p
, "library", p1
- p
) == 0)
3516 while (*p_temp
&& *p_temp
!= ';')
3524 /* Silently skip unknown optional info. */
3525 p_temp
= strchr (p1
+ 1, ';');
3533 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3536 error (_("Malformed packet(b) (missing colon): %s\n\
3541 error (_("Remote sent bad register number %ld: %s\n\
3545 fieldsize
= hex2bin (p
, regs
,
3546 register_size (current_gdbarch
,
3549 if (fieldsize
< register_size (current_gdbarch
,
3551 warning (_("Remote reply is too short: %s"), buf
);
3552 regcache_raw_supply (get_current_regcache (),
3557 error (_("Remote register badly formatted: %s\nhere: %s"),
3562 case 'S': /* Old style status, just signal only. */
3564 status
->kind
= TARGET_WAITKIND_LOADED
;
3567 status
->kind
= TARGET_WAITKIND_STOPPED
;
3568 status
->value
.sig
= (enum target_signal
)
3569 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3574 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3575 record_currthread (thread_num
);
3578 case 'W': /* Target exited. */
3580 /* The remote process exited. */
3581 status
->kind
= TARGET_WAITKIND_EXITED
;
3582 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3586 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3587 status
->value
.sig
= (enum target_signal
)
3588 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3592 case 'O': /* Console output. */
3593 remote_console_output (buf
+ 1);
3594 /* Return immediately to the event loop. The event loop will
3595 still be waiting on the inferior afterwards. */
3596 status
->kind
= TARGET_WAITKIND_IGNORE
;
3599 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3601 /* Zero length reply means that we tried 'S' or 'C' and
3602 the remote system doesn't support it. */
3603 target_terminal_ours_for_output ();
3605 ("Can't send signals to this remote system. %s not sent.\n",
3606 target_signal_to_name (last_sent_signal
));
3607 last_sent_signal
= TARGET_SIGNAL_0
;
3608 target_terminal_inferior ();
3610 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3611 putpkt ((char *) buf
);
3614 /* else fallthrough */
3616 warning (_("Invalid remote reply: %s"), buf
);
3621 if (thread_num
!= -1)
3623 return pid_to_ptid (thread_num
);
3625 return inferior_ptid
;
3628 /* Fetch a single register using a 'p' packet. */
3631 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3633 struct remote_state
*rs
= get_remote_state ();
3635 char regp
[MAX_REGISTER_SIZE
];
3638 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3641 if (reg
->pnum
== -1)
3646 p
+= hexnumstr (p
, reg
->pnum
);
3648 remote_send (&rs
->buf
, &rs
->buf_size
);
3652 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3656 case PACKET_UNKNOWN
:
3659 error (_("Could not fetch register \"%s\""),
3660 gdbarch_register_name (get_regcache_arch (regcache
), reg
->regnum
));
3663 /* If this register is unfetchable, tell the regcache. */
3666 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3670 /* Otherwise, parse and supply the value. */
3676 error (_("fetch_register_using_p: early buf termination"));
3678 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3681 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3685 /* Fetch the registers included in the target's 'g' packet. */
3688 send_g_packet (void)
3690 struct remote_state
*rs
= get_remote_state ();
3695 sprintf (rs
->buf
, "g");
3696 remote_send (&rs
->buf
, &rs
->buf_size
);
3698 /* We can get out of synch in various cases. If the first character
3699 in the buffer is not a hex character, assume that has happened
3700 and try to fetch another packet to read. */
3701 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3702 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3703 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3704 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3707 fprintf_unfiltered (gdb_stdlog
,
3708 "Bad register packet; fetching a new packet\n");
3709 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3712 buf_len
= strlen (rs
->buf
);
3714 /* Sanity check the received packet. */
3715 if (buf_len
% 2 != 0)
3716 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3722 process_g_packet (struct regcache
*regcache
)
3724 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3725 struct remote_state
*rs
= get_remote_state ();
3726 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3731 buf_len
= strlen (rs
->buf
);
3733 /* Further sanity checks, with knowledge of the architecture. */
3734 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3735 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3737 /* Save the size of the packet sent to us by the target. It is used
3738 as a heuristic when determining the max size of packets that the
3739 target can safely receive. */
3740 if (rsa
->actual_register_packet_size
== 0)
3741 rsa
->actual_register_packet_size
= buf_len
;
3743 /* If this is smaller than we guessed the 'g' packet would be,
3744 update our records. A 'g' reply that doesn't include a register's
3745 value implies either that the register is not available, or that
3746 the 'p' packet must be used. */
3747 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3749 rsa
->sizeof_g_packet
= buf_len
/ 2;
3751 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
3753 if (rsa
->regs
[i
].pnum
== -1)
3756 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3757 rsa
->regs
[i
].in_g_packet
= 0;
3759 rsa
->regs
[i
].in_g_packet
= 1;
3763 regs
= alloca (rsa
->sizeof_g_packet
);
3765 /* Unimplemented registers read as all bits zero. */
3766 memset (regs
, 0, rsa
->sizeof_g_packet
);
3768 /* Reply describes registers byte by byte, each byte encoded as two
3769 hex characters. Suck them all up, then supply them to the
3770 register cacheing/storage mechanism. */
3773 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3775 if (p
[0] == 0 || p
[1] == 0)
3776 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3777 internal_error (__FILE__
, __LINE__
,
3778 "unexpected end of 'g' packet reply");
3780 if (p
[0] == 'x' && p
[1] == 'x')
3781 regs
[i
] = 0; /* 'x' */
3783 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3789 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
3791 struct packet_reg
*r
= &rsa
->regs
[i
];
3794 if (r
->offset
* 2 >= strlen (rs
->buf
))
3795 /* This shouldn't happen - we adjusted in_g_packet above. */
3796 internal_error (__FILE__
, __LINE__
,
3797 "unexpected end of 'g' packet reply");
3798 else if (rs
->buf
[r
->offset
* 2] == 'x')
3800 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3801 /* The register isn't available, mark it as such (at
3802 the same time setting the value to zero). */
3803 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3806 regcache_raw_supply (regcache
, r
->regnum
,
3814 fetch_registers_using_g (struct regcache
*regcache
)
3817 process_g_packet (regcache
);
3821 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3823 struct remote_state
*rs
= get_remote_state ();
3824 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3827 set_thread (PIDGET (inferior_ptid
), 1);
3831 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3832 gdb_assert (reg
!= NULL
);
3834 /* If this register might be in the 'g' packet, try that first -
3835 we are likely to read more than one register. If this is the
3836 first 'g' packet, we might be overly optimistic about its
3837 contents, so fall back to 'p'. */
3838 if (reg
->in_g_packet
)
3840 fetch_registers_using_g (regcache
);
3841 if (reg
->in_g_packet
)
3845 if (fetch_register_using_p (regcache
, reg
))
3848 /* This register is not available. */
3849 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3854 fetch_registers_using_g (regcache
);
3856 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3857 if (!rsa
->regs
[i
].in_g_packet
)
3858 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3860 /* This register is not available. */
3861 regcache_raw_supply (regcache
, i
, NULL
);
3865 /* Prepare to store registers. Since we may send them all (using a
3866 'G' request), we have to read out the ones we don't want to change
3870 remote_prepare_to_store (struct regcache
*regcache
)
3872 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3874 gdb_byte buf
[MAX_REGISTER_SIZE
];
3876 /* Make sure the entire registers array is valid. */
3877 switch (remote_protocol_packets
[PACKET_P
].support
)
3879 case PACKET_DISABLE
:
3880 case PACKET_SUPPORT_UNKNOWN
:
3881 /* Make sure all the necessary registers are cached. */
3882 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3883 if (rsa
->regs
[i
].in_g_packet
)
3884 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3891 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3892 packet was not recognized. */
3895 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3897 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3898 struct remote_state
*rs
= get_remote_state ();
3899 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3900 /* Try storing a single register. */
3901 char *buf
= rs
->buf
;
3902 gdb_byte regp
[MAX_REGISTER_SIZE
];
3905 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3908 if (reg
->pnum
== -1)
3911 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3912 p
= buf
+ strlen (buf
);
3913 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3914 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
3915 remote_send (&rs
->buf
, &rs
->buf_size
);
3917 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3922 error (_("Could not write register \"%s\""),
3923 gdbarch_register_name (gdbarch
, reg
->regnum
));
3924 case PACKET_UNKNOWN
:
3927 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3931 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3932 contents of the register cache buffer. FIXME: ignores errors. */
3935 store_registers_using_G (const struct regcache
*regcache
)
3937 struct remote_state
*rs
= get_remote_state ();
3938 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3942 /* Extract all the registers in the regcache copying them into a
3946 regs
= alloca (rsa
->sizeof_g_packet
);
3947 memset (regs
, 0, rsa
->sizeof_g_packet
);
3948 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
3950 struct packet_reg
*r
= &rsa
->regs
[i
];
3952 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3956 /* Command describes registers byte by byte,
3957 each byte encoded as two hex characters. */
3960 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3962 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3963 remote_send (&rs
->buf
, &rs
->buf_size
);
3966 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3967 of the register cache buffer. FIXME: ignores errors. */
3970 remote_store_registers (struct regcache
*regcache
, int regnum
)
3972 struct remote_state
*rs
= get_remote_state ();
3973 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3976 set_thread (PIDGET (inferior_ptid
), 1);
3980 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3981 gdb_assert (reg
!= NULL
);
3983 /* Always prefer to store registers using the 'P' packet if
3984 possible; we often change only a small number of registers.
3985 Sometimes we change a larger number; we'd need help from a
3986 higher layer to know to use 'G'. */
3987 if (store_register_using_P (regcache
, reg
))
3990 /* For now, don't complain if we have no way to write the
3991 register. GDB loses track of unavailable registers too
3992 easily. Some day, this may be an error. We don't have
3993 any way to read the register, either... */
3994 if (!reg
->in_g_packet
)
3997 store_registers_using_G (regcache
);
4001 store_registers_using_G (regcache
);
4003 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
4004 if (!rsa
->regs
[i
].in_g_packet
)
4005 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
4006 /* See above for why we do not issue an error here. */
4011 /* Return the number of hex digits in num. */
4014 hexnumlen (ULONGEST num
)
4018 for (i
= 0; num
!= 0; i
++)
4024 /* Set BUF to the minimum number of hex digits representing NUM. */
4027 hexnumstr (char *buf
, ULONGEST num
)
4029 int len
= hexnumlen (num
);
4030 return hexnumnstr (buf
, num
, len
);
4034 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
4037 hexnumnstr (char *buf
, ULONGEST num
, int width
)
4043 for (i
= width
- 1; i
>= 0; i
--)
4045 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
4052 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
4055 remote_address_masked (CORE_ADDR addr
)
4057 int address_size
= remote_address_size
;
4058 /* If "remoteaddresssize" was not set, default to target address size. */
4060 address_size
= gdbarch_addr_bit (current_gdbarch
);
4062 if (address_size
> 0
4063 && address_size
< (sizeof (ULONGEST
) * 8))
4065 /* Only create a mask when that mask can safely be constructed
4066 in a ULONGEST variable. */
4068 mask
= (mask
<< address_size
) - 1;
4074 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
4075 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
4076 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
4077 (which may be more than *OUT_LEN due to escape characters). The
4078 total number of bytes in the output buffer will be at most
4082 remote_escape_output (const gdb_byte
*buffer
, int len
,
4083 gdb_byte
*out_buf
, int *out_len
,
4086 int input_index
, output_index
;
4089 for (input_index
= 0; input_index
< len
; input_index
++)
4091 gdb_byte b
= buffer
[input_index
];
4093 if (b
== '$' || b
== '#' || b
== '}')
4095 /* These must be escaped. */
4096 if (output_index
+ 2 > out_maxlen
)
4098 out_buf
[output_index
++] = '}';
4099 out_buf
[output_index
++] = b
^ 0x20;
4103 if (output_index
+ 1 > out_maxlen
)
4105 out_buf
[output_index
++] = b
;
4109 *out_len
= input_index
;
4110 return output_index
;
4113 /* Convert BUFFER, escaped data LEN bytes long, into binary data
4114 in OUT_BUF. Return the number of bytes written to OUT_BUF.
4115 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
4117 This function reverses remote_escape_output. It allows more
4118 escaped characters than that function does, in particular because
4119 '*' must be escaped to avoid the run-length encoding processing
4120 in reading packets. */
4123 remote_unescape_input (const gdb_byte
*buffer
, int len
,
4124 gdb_byte
*out_buf
, int out_maxlen
)
4126 int input_index
, output_index
;
4131 for (input_index
= 0; input_index
< len
; input_index
++)
4133 gdb_byte b
= buffer
[input_index
];
4135 if (output_index
+ 1 > out_maxlen
)
4137 warning (_("Received too much data from remote target;"
4138 " ignoring overflow."));
4139 return output_index
;
4144 out_buf
[output_index
++] = b
^ 0x20;
4150 out_buf
[output_index
++] = b
;
4154 error (_("Unmatched escape character in target response."));
4156 return output_index
;
4159 /* Determine whether the remote target supports binary downloading.
4160 This is accomplished by sending a no-op memory write of zero length
4161 to the target at the specified address. It does not suffice to send
4162 the whole packet, since many stubs strip the eighth bit and
4163 subsequently compute a wrong checksum, which causes real havoc with
4166 NOTE: This can still lose if the serial line is not eight-bit
4167 clean. In cases like this, the user should clear "remote
4171 check_binary_download (CORE_ADDR addr
)
4173 struct remote_state
*rs
= get_remote_state ();
4175 switch (remote_protocol_packets
[PACKET_X
].support
)
4177 case PACKET_DISABLE
:
4181 case PACKET_SUPPORT_UNKNOWN
:
4187 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4189 p
+= hexnumstr (p
, (ULONGEST
) 0);
4193 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4194 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4196 if (rs
->buf
[0] == '\0')
4199 fprintf_unfiltered (gdb_stdlog
,
4200 "binary downloading NOT suppported by target\n");
4201 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4206 fprintf_unfiltered (gdb_stdlog
,
4207 "binary downloading suppported by target\n");
4208 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4215 /* Write memory data directly to the remote machine.
4216 This does not inform the data cache; the data cache uses this.
4217 HEADER is the starting part of the packet.
4218 MEMADDR is the address in the remote memory space.
4219 MYADDR is the address of the buffer in our space.
4220 LEN is the number of bytes.
4221 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4222 should send data as binary ('X'), or hex-encoded ('M').
4224 The function creates packet of the form
4225 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4227 where encoding of <DATA> is termined by PACKET_FORMAT.
4229 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4232 Returns the number of bytes transferred, or 0 (setting errno) for
4233 error. Only transfer a single packet. */
4236 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4237 const gdb_byte
*myaddr
, int len
,
4238 char packet_format
, int use_length
)
4240 struct remote_state
*rs
= get_remote_state ();
4250 if (packet_format
!= 'X' && packet_format
!= 'M')
4251 internal_error (__FILE__
, __LINE__
,
4252 "remote_write_bytes_aux: bad packet format");
4257 payload_size
= get_memory_write_packet_size ();
4259 /* The packet buffer will be large enough for the payload;
4260 get_memory_packet_size ensures this. */
4263 /* Compute the size of the actual payload by subtracting out the
4264 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4266 payload_size
-= strlen ("$,:#NN");
4268 /* The comma won't be used. */
4270 header_length
= strlen (header
);
4271 payload_size
-= header_length
;
4272 payload_size
-= hexnumlen (memaddr
);
4274 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4276 strcat (rs
->buf
, header
);
4277 p
= rs
->buf
+ strlen (header
);
4279 /* Compute a best guess of the number of bytes actually transfered. */
4280 if (packet_format
== 'X')
4282 /* Best guess at number of bytes that will fit. */
4283 todo
= min (len
, payload_size
);
4285 payload_size
-= hexnumlen (todo
);
4286 todo
= min (todo
, payload_size
);
4290 /* Num bytes that will fit. */
4291 todo
= min (len
, payload_size
/ 2);
4293 payload_size
-= hexnumlen (todo
);
4294 todo
= min (todo
, payload_size
/ 2);
4298 internal_error (__FILE__
, __LINE__
,
4299 _("minumum packet size too small to write data"));
4301 /* If we already need another packet, then try to align the end
4302 of this packet to a useful boundary. */
4303 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4304 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4306 /* Append "<memaddr>". */
4307 memaddr
= remote_address_masked (memaddr
);
4308 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4315 /* Append <len>. Retain the location/size of <len>. It may need to
4316 be adjusted once the packet body has been created. */
4318 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4326 /* Append the packet body. */
4327 if (packet_format
== 'X')
4329 /* Binary mode. Send target system values byte by byte, in
4330 increasing byte addresses. Only escape certain critical
4332 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4335 /* If not all TODO bytes fit, then we'll need another packet. Make
4336 a second try to keep the end of the packet aligned. Don't do
4337 this if the packet is tiny. */
4338 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4342 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4344 if (new_nr_bytes
!= nr_bytes
)
4345 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4350 p
+= payload_length
;
4351 if (use_length
&& nr_bytes
< todo
)
4353 /* Escape chars have filled up the buffer prematurely,
4354 and we have actually sent fewer bytes than planned.
4355 Fix-up the length field of the packet. Use the same
4356 number of characters as before. */
4357 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4358 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4363 /* Normal mode: Send target system values byte by byte, in
4364 increasing byte addresses. Each byte is encoded as a two hex
4366 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4370 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4371 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4373 if (rs
->buf
[0] == 'E')
4375 /* There is no correspondance between what the remote protocol
4376 uses for errors and errno codes. We would like a cleaner way
4377 of representing errors (big enough to include errno codes,
4378 bfd_error codes, and others). But for now just return EIO. */
4383 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4384 fewer bytes than we'd planned. */
4388 /* Write memory data directly to the remote machine.
4389 This does not inform the data cache; the data cache uses this.
4390 MEMADDR is the address in the remote memory space.
4391 MYADDR is the address of the buffer in our space.
4392 LEN is the number of bytes.
4394 Returns number of bytes transferred, or 0 (setting errno) for
4395 error. Only transfer a single packet. */
4398 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4400 char *packet_format
= 0;
4402 /* Check whether the target supports binary download. */
4403 check_binary_download (memaddr
);
4405 switch (remote_protocol_packets
[PACKET_X
].support
)
4408 packet_format
= "X";
4410 case PACKET_DISABLE
:
4411 packet_format
= "M";
4413 case PACKET_SUPPORT_UNKNOWN
:
4414 internal_error (__FILE__
, __LINE__
,
4415 _("remote_write_bytes: bad internal state"));
4417 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4420 return remote_write_bytes_aux (packet_format
,
4421 memaddr
, myaddr
, len
, packet_format
[0], 1);
4424 /* Read memory data directly from the remote machine.
4425 This does not use the data cache; the data cache uses this.
4426 MEMADDR is the address in the remote memory space.
4427 MYADDR is the address of the buffer in our space.
4428 LEN is the number of bytes.
4430 Returns number of bytes transferred, or 0 for error. */
4432 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4433 remote targets) shouldn't attempt to read the entire buffer.
4434 Instead it should read a single packet worth of data and then
4435 return the byte size of that packet to the caller. The caller (its
4436 caller and its callers caller ;-) already contains code for
4437 handling partial reads. */
4440 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4442 struct remote_state
*rs
= get_remote_state ();
4443 int max_buf_size
; /* Max size of packet output buffer. */
4449 max_buf_size
= get_memory_read_packet_size ();
4450 /* The packet buffer will be large enough for the payload;
4451 get_memory_packet_size ensures this. */
4460 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4462 /* construct "m"<memaddr>","<len>" */
4463 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4464 memaddr
= remote_address_masked (memaddr
);
4467 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4469 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4473 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4475 if (rs
->buf
[0] == 'E'
4476 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4477 && rs
->buf
[3] == '\0')
4479 /* There is no correspondance between what the remote
4480 protocol uses for errors and errno codes. We would like
4481 a cleaner way of representing errors (big enough to
4482 include errno codes, bfd_error codes, and others). But
4483 for now just return EIO. */
4488 /* Reply describes memory byte by byte,
4489 each byte encoded as two hex characters. */
4492 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4494 /* Reply is short. This means that we were able to read
4495 only part of what we wanted to. */
4496 return i
+ (origlen
- len
);
4505 /* Read or write LEN bytes from inferior memory at MEMADDR,
4506 transferring to or from debugger address BUFFER. Write to inferior
4507 if SHOULD_WRITE is nonzero. Returns length of data written or
4508 read; 0 for error. TARGET is unused. */
4511 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4512 int should_write
, struct mem_attrib
*attrib
,
4513 struct target_ops
*target
)
4518 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4520 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4525 /* Sends a packet with content determined by the printf format string
4526 FORMAT and the remaining arguments, then gets the reply. Returns
4527 whether the packet was a success, a failure, or unknown. */
4530 remote_send_printf (const char *format
, ...)
4532 struct remote_state
*rs
= get_remote_state ();
4533 int max_size
= get_remote_packet_size ();
4536 va_start (ap
, format
);
4539 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4540 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4542 if (putpkt (rs
->buf
) < 0)
4543 error (_("Communication problem with target."));
4546 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4548 return packet_check_result (rs
->buf
);
4552 restore_remote_timeout (void *p
)
4554 int value
= *(int *)p
;
4555 remote_timeout
= value
;
4558 /* Flash writing can take quite some time. We'll set
4559 effectively infinite timeout for flash operations.
4560 In future, we'll need to decide on a better approach. */
4561 static const int remote_flash_timeout
= 1000;
4564 remote_flash_erase (struct target_ops
*ops
,
4565 ULONGEST address
, LONGEST length
)
4567 int saved_remote_timeout
= remote_timeout
;
4568 enum packet_result ret
;
4570 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4571 &saved_remote_timeout
);
4572 remote_timeout
= remote_flash_timeout
;
4574 ret
= remote_send_printf ("vFlashErase:%s,%s",
4579 case PACKET_UNKNOWN
:
4580 error (_("Remote target does not support flash erase"));
4582 error (_("Error erasing flash with vFlashErase packet"));
4587 do_cleanups (back_to
);
4591 remote_flash_write (struct target_ops
*ops
,
4592 ULONGEST address
, LONGEST length
,
4593 const gdb_byte
*data
)
4595 int saved_remote_timeout
= remote_timeout
;
4597 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4598 &saved_remote_timeout
);
4600 remote_timeout
= remote_flash_timeout
;
4601 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4602 do_cleanups (back_to
);
4608 remote_flash_done (struct target_ops
*ops
)
4610 int saved_remote_timeout
= remote_timeout
;
4612 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4613 &saved_remote_timeout
);
4615 remote_timeout
= remote_flash_timeout
;
4616 ret
= remote_send_printf ("vFlashDone");
4617 do_cleanups (back_to
);
4621 case PACKET_UNKNOWN
:
4622 error (_("Remote target does not support vFlashDone"));
4624 error (_("Error finishing flash operation"));
4631 remote_files_info (struct target_ops
*ignore
)
4633 puts_filtered ("Debugging a target over a serial line.\n");
4636 /* Stuff for dealing with the packets which are part of this protocol.
4637 See comment at top of file for details. */
4639 /* Read a single character from the remote end. */
4642 readchar (int timeout
)
4646 ch
= serial_readchar (remote_desc
, timeout
);
4651 switch ((enum serial_rc
) ch
)
4654 target_mourn_inferior ();
4655 error (_("Remote connection closed"));
4658 perror_with_name (_("Remote communication error"));
4660 case SERIAL_TIMEOUT
:
4666 /* Send the command in *BUF to the remote machine, and read the reply
4667 into *BUF. Report an error if we get an error reply. Resize
4668 *BUF using xrealloc if necessary to hold the result, and update
4672 remote_send (char **buf
,
4676 getpkt (buf
, sizeof_buf
, 0);
4678 if ((*buf
)[0] == 'E')
4679 error (_("Remote failure reply: %s"), *buf
);
4682 /* Display a null-terminated packet on stdout, for debugging, using C
4686 print_packet (char *buf
)
4688 puts_filtered ("\"");
4689 fputstr_filtered (buf
, '"', gdb_stdout
);
4690 puts_filtered ("\"");
4696 return putpkt_binary (buf
, strlen (buf
));
4699 /* Send a packet to the remote machine, with error checking. The data
4700 of the packet is in BUF. The string in BUF can be at most
4701 get_remote_packet_size () - 5 to account for the $, # and checksum,
4702 and for a possible /0 if we are debugging (remote_debug) and want
4703 to print the sent packet as a string. */
4706 putpkt_binary (char *buf
, int cnt
)
4709 unsigned char csum
= 0;
4710 char *buf2
= alloca (cnt
+ 6);
4716 /* Copy the packet into buffer BUF2, encapsulating it
4717 and giving it a checksum. */
4722 for (i
= 0; i
< cnt
; i
++)
4728 *p
++ = tohex ((csum
>> 4) & 0xf);
4729 *p
++ = tohex (csum
& 0xf);
4731 /* Send it over and over until we get a positive ack. */
4735 int started_error_output
= 0;
4740 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4741 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4742 fprintf_unfiltered (gdb_stdlog
, "...");
4743 gdb_flush (gdb_stdlog
);
4745 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4746 perror_with_name (_("putpkt: write failed"));
4748 /* Read until either a timeout occurs (-2) or '+' is read. */
4751 ch
= readchar (remote_timeout
);
4759 case SERIAL_TIMEOUT
:
4761 if (started_error_output
)
4763 putchar_unfiltered ('\n');
4764 started_error_output
= 0;
4773 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4777 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4778 case SERIAL_TIMEOUT
:
4782 break; /* Retransmit buffer. */
4786 fprintf_unfiltered (gdb_stdlog
,
4787 "Packet instead of Ack, ignoring it\n");
4788 /* It's probably an old response sent because an ACK
4789 was lost. Gobble up the packet and ack it so it
4790 doesn't get retransmitted when we resend this
4793 serial_write (remote_desc
, "+", 1);
4794 continue; /* Now, go look for +. */
4799 if (!started_error_output
)
4801 started_error_output
= 1;
4802 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4804 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4808 break; /* Here to retransmit. */
4812 /* This is wrong. If doing a long backtrace, the user should be
4813 able to get out next time we call QUIT, without anything as
4814 violent as interrupt_query. If we want to provide a way out of
4815 here without getting to the next QUIT, it should be based on
4816 hitting ^C twice as in remote_wait. */
4826 /* Come here after finding the start of a frame when we expected an
4827 ack. Do our best to discard the rest of this packet. */
4836 c
= readchar (remote_timeout
);
4839 case SERIAL_TIMEOUT
:
4840 /* Nothing we can do. */
4843 /* Discard the two bytes of checksum and stop. */
4844 c
= readchar (remote_timeout
);
4846 c
= readchar (remote_timeout
);
4849 case '*': /* Run length encoding. */
4850 /* Discard the repeat count. */
4851 c
= readchar (remote_timeout
);
4856 /* A regular character. */
4862 /* Come here after finding the start of the frame. Collect the rest
4863 into *BUF, verifying the checksum, length, and handling run-length
4864 compression. NUL terminate the buffer. If there is not enough room,
4865 expand *BUF using xrealloc.
4867 Returns -1 on error, number of characters in buffer (ignoring the
4868 trailing NULL) on success. (could be extended to return one of the
4869 SERIAL status indications). */
4872 read_frame (char **buf_p
,
4885 c
= readchar (remote_timeout
);
4888 case SERIAL_TIMEOUT
:
4890 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4894 fputs_filtered ("Saw new packet start in middle of old one\n",
4896 return -1; /* Start a new packet, count retries. */
4899 unsigned char pktcsum
;
4905 check_0
= readchar (remote_timeout
);
4907 check_1
= readchar (remote_timeout
);
4909 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4912 fputs_filtered ("Timeout in checksum, retrying\n",
4916 else if (check_0
< 0 || check_1
< 0)
4919 fputs_filtered ("Communication error in checksum\n",
4924 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4925 if (csum
== pktcsum
)
4930 fprintf_filtered (gdb_stdlog
,
4931 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4933 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4934 fputs_filtered ("\n", gdb_stdlog
);
4936 /* Number of characters in buffer ignoring trailing
4940 case '*': /* Run length encoding. */
4945 c
= readchar (remote_timeout
);
4947 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4949 /* The character before ``*'' is repeated. */
4951 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4953 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4955 /* Make some more room in the buffer. */
4956 *sizeof_buf
+= repeat
;
4957 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4961 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4967 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4971 if (bc
>= *sizeof_buf
- 1)
4973 /* Make some more room in the buffer. */
4975 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4986 /* Read a packet from the remote machine, with error checking, and
4987 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4988 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4989 rather than timing out; this is used (in synchronous mode) to wait
4990 for a target that is is executing user code to stop. */
4991 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4992 don't have to change all the calls to getpkt to deal with the
4993 return value, because at the moment I don't know what the right
4994 thing to do it for those. */
5002 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
5006 /* Read a packet from the remote machine, with error checking, and
5007 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
5008 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
5009 rather than timing out; this is used (in synchronous mode) to wait
5010 for a target that is is executing user code to stop. If FOREVER ==
5011 0, this function is allowed to time out gracefully and return an
5012 indication of this to the caller. Otherwise return the number
5015 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
5022 strcpy (*buf
, "timeout");
5026 timeout
= watchdog
> 0 ? watchdog
: -1;
5030 timeout
= remote_timeout
;
5034 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
5036 /* This can loop forever if the remote side sends us characters
5037 continuously, but if it pauses, we'll get a zero from
5038 readchar because of timeout. Then we'll count that as a
5041 /* Note that we will only wait forever prior to the start of a
5042 packet. After that, we expect characters to arrive at a
5043 brisk pace. They should show up within remote_timeout
5048 c
= readchar (timeout
);
5050 if (c
== SERIAL_TIMEOUT
)
5052 if (forever
) /* Watchdog went off? Kill the target. */
5055 target_mourn_inferior ();
5056 error (_("Watchdog timeout has expired. Target detached."));
5059 fputs_filtered ("Timed out.\n", gdb_stdlog
);
5065 /* We've found the start of a packet, now collect the data. */
5067 val
= read_frame (buf
, sizeof_buf
);
5073 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
5074 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
5075 fprintf_unfiltered (gdb_stdlog
, "\n");
5077 serial_write (remote_desc
, "+", 1);
5081 /* Try the whole thing again. */
5083 serial_write (remote_desc
, "-", 1);
5086 /* We have tried hard enough, and just can't receive the packet.
5089 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
5090 serial_write (remote_desc
, "+", 1);
5097 /* For some mysterious reason, wait_for_inferior calls kill instead of
5098 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5102 target_mourn_inferior ();
5106 /* Use catch_errors so the user can quit from gdb even when we aren't on
5107 speaking terms with the remote system. */
5108 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5110 /* Don't wait for it to die. I'm not really sure it matters whether
5111 we do or not. For the existing stubs, kill is a noop. */
5112 target_mourn_inferior ();
5115 /* Async version of remote_kill. */
5117 remote_async_kill (void)
5119 /* Unregister the file descriptor from the event loop. */
5120 if (target_is_async_p ())
5121 serial_async (remote_desc
, NULL
, 0);
5123 /* For some mysterious reason, wait_for_inferior calls kill instead of
5124 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5128 target_mourn_inferior ();
5132 /* Use catch_errors so the user can quit from gdb even when we
5133 aren't on speaking terms with the remote system. */
5134 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5136 /* Don't wait for it to die. I'm not really sure it matters whether
5137 we do or not. For the existing stubs, kill is a noop. */
5138 target_mourn_inferior ();
5144 remote_mourn_1 (&remote_ops
);
5148 remote_async_mourn (void)
5150 remote_mourn_1 (&remote_async_ops
);
5154 extended_remote_mourn (void)
5156 /* We do _not_ want to mourn the target like this; this will
5157 remove the extended remote target from the target stack,
5158 and the next time the user says "run" it'll fail.
5160 FIXME: What is the right thing to do here? */
5162 remote_mourn_1 (&extended_remote_ops
);
5166 /* Worker function for remote_mourn. */
5168 remote_mourn_1 (struct target_ops
*target
)
5170 unpush_target (target
);
5171 generic_mourn_inferior ();
5174 /* In the extended protocol we want to be able to do things like
5175 "run" and have them basically work as expected. So we need
5176 a special create_inferior function.
5178 FIXME: One day add support for changing the exec file
5179 we're debugging, arguments and an environment. */
5182 extended_remote_create_inferior (char *exec_file
, char *args
,
5183 char **env
, int from_tty
)
5185 /* Rip out the breakpoints; we'll reinsert them after restarting
5186 the remote server. */
5187 remove_breakpoints ();
5189 /* Now restart the remote server. */
5190 extended_remote_restart ();
5192 /* NOTE: We don't need to recheck for a target description here; but
5193 if we gain the ability to switch the remote executable we may
5194 need to, if for instance we are running a process which requested
5195 different emulated hardware from the operating system. A
5196 concrete example of this is ARM GNU/Linux, where some binaries
5197 will have a legacy FPA coprocessor emulated and others may have
5198 access to a hardware VFP unit. */
5200 /* Now put the breakpoints back in. This way we're safe if the
5201 restart function works via a unix fork on the remote side. */
5202 insert_breakpoints ();
5204 /* Clean up from the last time we were running. */
5205 clear_proceed_status ();
5208 /* Async version of extended_remote_create_inferior. */
5210 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5211 char **env
, int from_tty
)
5213 /* Rip out the breakpoints; we'll reinsert them after restarting
5214 the remote server. */
5215 remove_breakpoints ();
5217 /* If running asynchronously, register the target file descriptor
5218 with the event loop. */
5219 if (target_can_async_p ())
5220 target_async (inferior_event_handler
, 0);
5222 /* Now restart the remote server. */
5223 extended_remote_restart ();
5225 /* NOTE: We don't need to recheck for a target description here; but
5226 if we gain the ability to switch the remote executable we may
5227 need to, if for instance we are running a process which requested
5228 different emulated hardware from the operating system. A
5229 concrete example of this is ARM GNU/Linux, where some binaries
5230 will have a legacy FPA coprocessor emulated and others may have
5231 access to a hardware VFP unit. */
5233 /* Now put the breakpoints back in. This way we're safe if the
5234 restart function works via a unix fork on the remote side. */
5235 insert_breakpoints ();
5237 /* Clean up from the last time we were running. */
5238 clear_proceed_status ();
5242 /* Insert a breakpoint. On targets that have software breakpoint
5243 support, we ask the remote target to do the work; on targets
5244 which don't, we insert a traditional memory breakpoint. */
5247 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5249 CORE_ADDR addr
= bp_tgt
->placed_address
;
5250 struct remote_state
*rs
= get_remote_state ();
5252 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5253 If it succeeds, then set the support to PACKET_ENABLE. If it
5254 fails, and the user has explicitly requested the Z support then
5255 report an error, otherwise, mark it disabled and go on. */
5257 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5264 gdbarch_breakpoint_from_pc
5265 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5266 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5267 p
+= hexnumstr (p
, addr
);
5268 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5271 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5273 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5279 case PACKET_UNKNOWN
:
5284 return memory_insert_breakpoint (bp_tgt
);
5288 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5290 CORE_ADDR addr
= bp_tgt
->placed_address
;
5291 struct remote_state
*rs
= get_remote_state ();
5294 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5302 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5303 p
+= hexnumstr (p
, addr
);
5304 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5307 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5309 return (rs
->buf
[0] == 'E');
5312 return memory_remove_breakpoint (bp_tgt
);
5316 watchpoint_to_Z_packet (int type
)
5321 return Z_PACKET_WRITE_WP
;
5324 return Z_PACKET_READ_WP
;
5327 return Z_PACKET_ACCESS_WP
;
5330 internal_error (__FILE__
, __LINE__
,
5331 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5336 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5338 struct remote_state
*rs
= get_remote_state ();
5340 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5342 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5345 sprintf (rs
->buf
, "Z%x,", packet
);
5346 p
= strchr (rs
->buf
, '\0');
5347 addr
= remote_address_masked (addr
);
5348 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5349 sprintf (p
, ",%x", len
);
5352 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5354 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5357 case PACKET_UNKNOWN
:
5362 internal_error (__FILE__
, __LINE__
,
5363 _("remote_insert_watchpoint: reached end of function"));
5368 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5370 struct remote_state
*rs
= get_remote_state ();
5372 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5374 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5377 sprintf (rs
->buf
, "z%x,", packet
);
5378 p
= strchr (rs
->buf
, '\0');
5379 addr
= remote_address_masked (addr
);
5380 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5381 sprintf (p
, ",%x", len
);
5383 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5385 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5388 case PACKET_UNKNOWN
:
5393 internal_error (__FILE__
, __LINE__
,
5394 _("remote_remove_watchpoint: reached end of function"));
5398 int remote_hw_watchpoint_limit
= -1;
5399 int remote_hw_breakpoint_limit
= -1;
5402 remote_check_watch_resources (int type
, int cnt
, int ot
)
5404 if (type
== bp_hardware_breakpoint
)
5406 if (remote_hw_breakpoint_limit
== 0)
5408 else if (remote_hw_breakpoint_limit
< 0)
5410 else if (cnt
<= remote_hw_breakpoint_limit
)
5415 if (remote_hw_watchpoint_limit
== 0)
5417 else if (remote_hw_watchpoint_limit
< 0)
5421 else if (cnt
<= remote_hw_watchpoint_limit
)
5428 remote_stopped_by_watchpoint (void)
5430 return remote_stopped_by_watchpoint_p
;
5434 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5437 if (remote_stopped_by_watchpoint ())
5439 *addr_p
= remote_watch_data_address
;
5448 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5451 struct remote_state
*rs
= get_remote_state ();
5454 /* The length field should be set to the size of a breakpoint
5455 instruction, even though we aren't inserting one ourselves. */
5457 gdbarch_breakpoint_from_pc
5458 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5460 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5467 addr
= remote_address_masked (bp_tgt
->placed_address
);
5468 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5469 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5472 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5474 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5477 case PACKET_UNKNOWN
:
5482 internal_error (__FILE__
, __LINE__
,
5483 _("remote_insert_hw_breakpoint: reached end of function"));
5488 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5491 struct remote_state
*rs
= get_remote_state ();
5494 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5501 addr
= remote_address_masked (bp_tgt
->placed_address
);
5502 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5503 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5506 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5508 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5511 case PACKET_UNKNOWN
:
5516 internal_error (__FILE__
, __LINE__
,
5517 _("remote_remove_hw_breakpoint: reached end of function"));
5520 /* Some targets are only capable of doing downloads, and afterwards
5521 they switch to the remote serial protocol. This function provides
5522 a clean way to get from the download target to the remote target.
5523 It's basically just a wrapper so that we don't have to expose any
5524 of the internal workings of remote.c.
5526 Prior to calling this routine, you should shutdown the current
5527 target code, else you will get the "A program is being debugged
5528 already..." message. Usually a call to pop_target() suffices. */
5531 push_remote_target (char *name
, int from_tty
)
5533 printf_filtered (_("Switching to remote protocol\n"));
5534 remote_open (name
, from_tty
);
5537 /* Table used by the crc32 function to calcuate the checksum. */
5539 static unsigned long crc32_table
[256] =
5542 static unsigned long
5543 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5545 if (!crc32_table
[1])
5547 /* Initialize the CRC table and the decoding table. */
5551 for (i
= 0; i
< 256; i
++)
5553 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5554 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5561 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5567 /* compare-sections command
5569 With no arguments, compares each loadable section in the exec bfd
5570 with the same memory range on the target, and reports mismatches.
5571 Useful for verifying the image on the target against the exec file.
5572 Depends on the target understanding the new "qCRC:" request. */
5574 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5575 target method (target verify memory) and generic version of the
5576 actual command. This will allow other high-level code (especially
5577 generic_load()) to make use of this target functionality. */
5580 compare_sections_command (char *args
, int from_tty
)
5582 struct remote_state
*rs
= get_remote_state ();
5584 unsigned long host_crc
, target_crc
;
5585 extern bfd
*exec_bfd
;
5586 struct cleanup
*old_chain
;
5589 const char *sectname
;
5596 error (_("command cannot be used without an exec file"));
5597 if (!current_target
.to_shortname
||
5598 strcmp (current_target
.to_shortname
, "remote") != 0)
5599 error (_("command can only be used with remote target"));
5601 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5603 if (!(s
->flags
& SEC_LOAD
))
5604 continue; /* skip non-loadable section */
5606 size
= bfd_get_section_size (s
);
5608 continue; /* skip zero-length section */
5610 sectname
= bfd_get_section_name (exec_bfd
, s
);
5611 if (args
&& strcmp (args
, sectname
) != 0)
5612 continue; /* not the section selected by user */
5614 matched
= 1; /* do this section */
5616 /* FIXME: assumes lma can fit into long. */
5617 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5618 (long) lma
, (long) size
);
5621 /* Be clever; compute the host_crc before waiting for target
5623 sectdata
= xmalloc (size
);
5624 old_chain
= make_cleanup (xfree
, sectdata
);
5625 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5626 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5628 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5629 if (rs
->buf
[0] == 'E')
5630 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5631 sectname
, paddr (lma
), paddr (lma
+ size
));
5632 if (rs
->buf
[0] != 'C')
5633 error (_("remote target does not support this operation"));
5635 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5636 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5638 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5639 sectname
, paddr (lma
), paddr (lma
+ size
));
5640 if (host_crc
== target_crc
)
5641 printf_filtered ("matched.\n");
5644 printf_filtered ("MIS-MATCHED!\n");
5648 do_cleanups (old_chain
);
5651 warning (_("One or more sections of the remote executable does not match\n\
5652 the loaded file\n"));
5653 if (args
&& !matched
)
5654 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5657 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5658 into remote target. The number of bytes written to the remote
5659 target is returned, or -1 for error. */
5662 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
5663 const char *annex
, const gdb_byte
*writebuf
,
5664 ULONGEST offset
, LONGEST len
,
5665 struct packet_config
*packet
)
5670 struct remote_state
*rs
= get_remote_state ();
5671 int max_size
= get_memory_write_packet_size ();
5673 if (packet
->support
== PACKET_DISABLE
)
5676 /* Insert header. */
5677 i
= snprintf (rs
->buf
, max_size
,
5678 "qXfer:%s:write:%s:%s:",
5679 object_name
, annex
? annex
: "",
5680 phex_nz (offset
, sizeof offset
));
5681 max_size
-= (i
+ 1);
5683 /* Escape as much data as fits into rs->buf. */
5684 buf_len
= remote_escape_output
5685 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
5687 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
5688 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
5689 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5692 unpack_varlen_hex (rs
->buf
, &n
);
5696 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5697 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5698 number of bytes read is returned, or 0 for EOF, or -1 for error.
5699 The number of bytes read may be less than LEN without indicating an
5700 EOF. PACKET is checked and updated to indicate whether the remote
5701 target supports this object. */
5704 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5706 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5707 struct packet_config
*packet
)
5709 static char *finished_object
;
5710 static char *finished_annex
;
5711 static ULONGEST finished_offset
;
5713 struct remote_state
*rs
= get_remote_state ();
5714 unsigned int total
= 0;
5715 LONGEST i
, n
, packet_len
;
5717 if (packet
->support
== PACKET_DISABLE
)
5720 /* Check whether we've cached an end-of-object packet that matches
5722 if (finished_object
)
5724 if (strcmp (object_name
, finished_object
) == 0
5725 && strcmp (annex
? annex
: "", finished_annex
) == 0
5726 && offset
== finished_offset
)
5729 /* Otherwise, we're now reading something different. Discard
5731 xfree (finished_object
);
5732 xfree (finished_annex
);
5733 finished_object
= NULL
;
5734 finished_annex
= NULL
;
5737 /* Request only enough to fit in a single packet. The actual data
5738 may not, since we don't know how much of it will need to be escaped;
5739 the target is free to respond with slightly less data. We subtract
5740 five to account for the response type and the protocol frame. */
5741 n
= min (get_remote_packet_size () - 5, len
);
5742 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5743 object_name
, annex
? annex
: "",
5744 phex_nz (offset
, sizeof offset
),
5745 phex_nz (n
, sizeof n
));
5746 i
= putpkt (rs
->buf
);
5751 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5752 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5755 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5756 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5758 /* 'm' means there is (or at least might be) more data after this
5759 batch. That does not make sense unless there's at least one byte
5760 of data in this reply. */
5761 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5762 error (_("Remote qXfer reply contained no data."));
5764 /* Got some data. */
5765 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5767 /* 'l' is an EOF marker, possibly including a final block of data,
5768 or possibly empty. If we have the final block of a non-empty
5769 object, record this fact to bypass a subsequent partial read. */
5770 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
5772 finished_object
= xstrdup (object_name
);
5773 finished_annex
= xstrdup (annex
? annex
: "");
5774 finished_offset
= offset
+ i
;
5781 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5782 const char *annex
, gdb_byte
*readbuf
,
5783 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5785 struct remote_state
*rs
= get_remote_state ();
5790 /* Handle memory using the standard memory routines. */
5791 if (object
== TARGET_OBJECT_MEMORY
)
5796 if (writebuf
!= NULL
)
5797 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5799 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5803 else if (xfered
== 0 && errno
== 0)
5809 /* Handle SPU memory using qxfer packets. */
5810 if (object
== TARGET_OBJECT_SPU
)
5813 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
5814 &remote_protocol_packets
5815 [PACKET_qXfer_spu_read
]);
5817 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
5818 &remote_protocol_packets
5819 [PACKET_qXfer_spu_write
]);
5822 /* Only handle flash writes. */
5823 if (writebuf
!= NULL
)
5829 case TARGET_OBJECT_FLASH
:
5830 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5834 else if (xfered
== 0 && errno
== 0)
5844 /* Map pre-existing objects onto letters. DO NOT do this for new
5845 objects!!! Instead specify new query packets. */
5848 case TARGET_OBJECT_AVR
:
5852 case TARGET_OBJECT_AUXV
:
5853 gdb_assert (annex
== NULL
);
5854 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5855 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5857 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5858 return remote_read_qxfer
5859 (ops
, "features", annex
, readbuf
, offset
, len
,
5860 &remote_protocol_packets
[PACKET_qXfer_features
]);
5862 case TARGET_OBJECT_LIBRARIES
:
5863 return remote_read_qxfer
5864 (ops
, "libraries", annex
, readbuf
, offset
, len
,
5865 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
5867 case TARGET_OBJECT_MEMORY_MAP
:
5868 gdb_assert (annex
== NULL
);
5869 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5870 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5876 /* Note: a zero OFFSET and LEN can be used to query the minimum
5878 if (offset
== 0 && len
== 0)
5879 return (get_remote_packet_size ());
5880 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5881 large enough let the caller deal with it. */
5882 if (len
< get_remote_packet_size ())
5884 len
= get_remote_packet_size ();
5886 /* Except for querying the minimum buffer size, target must be open. */
5888 error (_("remote query is only available after target open"));
5890 gdb_assert (annex
!= NULL
);
5891 gdb_assert (readbuf
!= NULL
);
5897 /* We used one buffer char for the remote protocol q command and
5898 another for the query type. As the remote protocol encapsulation
5899 uses 4 chars plus one extra in case we are debugging
5900 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5903 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5905 /* Bad caller may have sent forbidden characters. */
5906 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5911 gdb_assert (annex
[i
] == '\0');
5913 i
= putpkt (rs
->buf
);
5917 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5918 strcpy ((char *) readbuf
, rs
->buf
);
5920 return strlen ((char *) readbuf
);
5924 remote_rcmd (char *command
,
5925 struct ui_file
*outbuf
)
5927 struct remote_state
*rs
= get_remote_state ();
5931 error (_("remote rcmd is only available after target open"));
5933 /* Send a NULL command across as an empty command. */
5934 if (command
== NULL
)
5937 /* The query prefix. */
5938 strcpy (rs
->buf
, "qRcmd,");
5939 p
= strchr (rs
->buf
, '\0');
5941 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5942 error (_("\"monitor\" command ``%s'' is too long."), command
);
5944 /* Encode the actual command. */
5945 bin2hex ((gdb_byte
*) command
, p
, 0);
5947 if (putpkt (rs
->buf
) < 0)
5948 error (_("Communication problem with target."));
5950 /* get/display the response */
5955 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5957 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5960 error (_("Target does not support this command."));
5961 if (buf
[0] == 'O' && buf
[1] != 'K')
5963 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5966 if (strcmp (buf
, "OK") == 0)
5968 if (strlen (buf
) == 3 && buf
[0] == 'E'
5969 && isdigit (buf
[1]) && isdigit (buf
[2]))
5971 error (_("Protocol error with Rcmd"));
5973 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5975 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5976 fputc_unfiltered (c
, outbuf
);
5982 static VEC(mem_region_s
) *
5983 remote_memory_map (struct target_ops
*ops
)
5985 VEC(mem_region_s
) *result
= NULL
;
5986 char *text
= target_read_stralloc (¤t_target
,
5987 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5991 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5992 result
= parse_memory_map (text
);
5993 do_cleanups (back_to
);
6000 packet_command (char *args
, int from_tty
)
6002 struct remote_state
*rs
= get_remote_state ();
6005 error (_("command can only be used with remote target"));
6008 error (_("remote-packet command requires packet text as argument"));
6010 puts_filtered ("sending: ");
6011 print_packet (args
);
6012 puts_filtered ("\n");
6015 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6016 puts_filtered ("received: ");
6017 print_packet (rs
->buf
);
6018 puts_filtered ("\n");
6022 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
6024 static void display_thread_info (struct gdb_ext_thread_info
*info
);
6026 static void threadset_test_cmd (char *cmd
, int tty
);
6028 static void threadalive_test (char *cmd
, int tty
);
6030 static void threadlist_test_cmd (char *cmd
, int tty
);
6032 int get_and_display_threadinfo (threadref
*ref
);
6034 static void threadinfo_test_cmd (char *cmd
, int tty
);
6036 static int thread_display_step (threadref
*ref
, void *context
);
6038 static void threadlist_update_test_cmd (char *cmd
, int tty
);
6040 static void init_remote_threadtests (void);
6042 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
6045 threadset_test_cmd (char *cmd
, int tty
)
6047 int sample_thread
= SAMPLE_THREAD
;
6049 printf_filtered (_("Remote threadset test\n"));
6050 set_thread (sample_thread
, 1);
6055 threadalive_test (char *cmd
, int tty
)
6057 int sample_thread
= SAMPLE_THREAD
;
6059 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
6060 printf_filtered ("PASS: Thread alive test\n");
6062 printf_filtered ("FAIL: Thread alive test\n");
6065 void output_threadid (char *title
, threadref
*ref
);
6068 output_threadid (char *title
, threadref
*ref
)
6072 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
6074 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
6078 threadlist_test_cmd (char *cmd
, int tty
)
6081 threadref nextthread
;
6082 int done
, result_count
;
6083 threadref threadlist
[3];
6085 printf_filtered ("Remote Threadlist test\n");
6086 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
6087 &result_count
, &threadlist
[0]))
6088 printf_filtered ("FAIL: threadlist test\n");
6091 threadref
*scan
= threadlist
;
6092 threadref
*limit
= scan
+ result_count
;
6094 while (scan
< limit
)
6095 output_threadid (" thread ", scan
++);
6100 display_thread_info (struct gdb_ext_thread_info
*info
)
6102 output_threadid ("Threadid: ", &info
->threadid
);
6103 printf_filtered ("Name: %s\n ", info
->shortname
);
6104 printf_filtered ("State: %s\n", info
->display
);
6105 printf_filtered ("other: %s\n\n", info
->more_display
);
6109 get_and_display_threadinfo (threadref
*ref
)
6113 struct gdb_ext_thread_info threadinfo
;
6115 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
6116 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
6117 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
6118 display_thread_info (&threadinfo
);
6123 threadinfo_test_cmd (char *cmd
, int tty
)
6125 int athread
= SAMPLE_THREAD
;
6129 int_to_threadref (&thread
, athread
);
6130 printf_filtered ("Remote Threadinfo test\n");
6131 if (!get_and_display_threadinfo (&thread
))
6132 printf_filtered ("FAIL cannot get thread info\n");
6136 thread_display_step (threadref
*ref
, void *context
)
6138 /* output_threadid(" threadstep ",ref); *//* simple test */
6139 return get_and_display_threadinfo (ref
);
6143 threadlist_update_test_cmd (char *cmd
, int tty
)
6145 printf_filtered ("Remote Threadlist update test\n");
6146 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
6150 init_remote_threadtests (void)
6152 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
6153 Fetch and print the remote list of thread identifiers, one pkt only"));
6154 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
6155 _("Fetch and display info about one thread"));
6156 add_com ("tset", class_obscure
, threadset_test_cmd
,
6157 _("Test setting to a different thread"));
6158 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
6159 _("Iterate through updating all remote thread info"));
6160 add_com ("talive", class_obscure
, threadalive_test
,
6161 _(" Remote thread alive test "));
6166 /* Convert a thread ID to a string. Returns the string in a static
6170 remote_pid_to_str (ptid_t ptid
)
6172 static char buf
[32];
6174 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
6178 /* Get the address of the thread local variable in OBJFILE which is
6179 stored at OFFSET within the thread local storage for thread PTID. */
6182 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
6184 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
6186 struct remote_state
*rs
= get_remote_state ();
6188 enum packet_result result
;
6190 strcpy (p
, "qGetTLSAddr:");
6192 p
+= hexnumstr (p
, PIDGET (ptid
));
6194 p
+= hexnumstr (p
, offset
);
6196 p
+= hexnumstr (p
, lm
);
6200 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6201 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6202 if (result
== PACKET_OK
)
6206 unpack_varlen_hex (rs
->buf
, &result
);
6209 else if (result
== PACKET_UNKNOWN
)
6210 throw_error (TLS_GENERIC_ERROR
,
6211 _("Remote target doesn't support qGetTLSAddr packet"));
6213 throw_error (TLS_GENERIC_ERROR
,
6214 _("Remote target failed to process qGetTLSAddr request"));
6217 throw_error (TLS_GENERIC_ERROR
,
6218 _("TLS not supported or disabled on this target"));
6223 /* Support for inferring a target description based on the current
6224 architecture and the size of a 'g' packet. While the 'g' packet
6225 can have any size (since optional registers can be left off the
6226 end), some sizes are easily recognizable given knowledge of the
6227 approximate architecture. */
6229 struct remote_g_packet_guess
6232 const struct target_desc
*tdesc
;
6234 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6235 DEF_VEC_O(remote_g_packet_guess_s
);
6237 struct remote_g_packet_data
6239 VEC(remote_g_packet_guess_s
) *guesses
;
6242 static struct gdbarch_data
*remote_g_packet_data_handle
;
6245 remote_g_packet_data_init (struct obstack
*obstack
)
6247 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6251 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6252 const struct target_desc
*tdesc
)
6254 struct remote_g_packet_data
*data
6255 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6256 struct remote_g_packet_guess new_guess
, *guess
;
6259 gdb_assert (tdesc
!= NULL
);
6262 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6264 if (guess
->bytes
== bytes
)
6265 internal_error (__FILE__
, __LINE__
,
6266 "Duplicate g packet description added for size %d",
6269 new_guess
.bytes
= bytes
;
6270 new_guess
.tdesc
= tdesc
;
6271 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6274 static const struct target_desc
*
6275 remote_read_description (struct target_ops
*target
)
6277 struct remote_g_packet_data
*data
6278 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6280 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6282 struct remote_g_packet_guess
*guess
;
6284 int bytes
= send_g_packet ();
6287 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6289 if (guess
->bytes
== bytes
)
6290 return guess
->tdesc
;
6292 /* We discard the g packet. A minor optimization would be to
6293 hold on to it, and fill the register cache once we have selected
6294 an architecture, but it's too tricky to do safely. */
6300 /* Remote file transfer support. This is host-initiated I/O, not
6301 target-initiated; for target-initiated, see remote-fileio.c. */
6303 /* If *LEFT is at least the length of STRING, copy STRING to
6304 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6305 decrease *LEFT. Otherwise raise an error. */
6308 remote_buffer_add_string (char **buffer
, int *left
, char *string
)
6310 int len
= strlen (string
);
6313 error (_("Packet too long for target."));
6315 memcpy (*buffer
, string
, len
);
6319 /* NUL-terminate the buffer as a convenience, if there is
6325 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
6326 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6327 decrease *LEFT. Otherwise raise an error. */
6330 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
6333 if (2 * len
> *left
)
6334 error (_("Packet too long for target."));
6336 bin2hex (bytes
, *buffer
, len
);
6340 /* NUL-terminate the buffer as a convenience, if there is
6346 /* If *LEFT is large enough, convert VALUE to hex and add it to
6347 *BUFFER, update *BUFFER to point to the new end of the buffer, and
6348 decrease *LEFT. Otherwise raise an error. */
6351 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
6353 int len
= hexnumlen (value
);
6356 error (_("Packet too long for target."));
6358 hexnumstr (*buffer
, value
);
6362 /* NUL-terminate the buffer as a convenience, if there is
6368 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
6369 value, *REMOTE_ERRNO to the remote error number or zero if none
6370 was included, and *ATTACHMENT to point to the start of the annex
6371 if any. The length of the packet isn't needed here; there may
6372 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
6374 Return 0 if the packet could be parsed, -1 if it could not. If
6375 -1 is returned, the other variables may not be initialized. */
6378 remote_hostio_parse_result (char *buffer
, int *retcode
,
6379 int *remote_errno
, char **attachment
)
6386 if (buffer
[0] != 'F')
6390 *retcode
= strtol (&buffer
[1], &p
, 16);
6391 if (errno
!= 0 || p
== &buffer
[1])
6394 /* Check for ",errno". */
6398 *remote_errno
= strtol (p
+ 1, &p2
, 16);
6399 if (errno
!= 0 || p
+ 1 == p2
)
6404 /* Check for ";attachment". If there is no attachment, the
6405 packet should end here. */
6408 *attachment
= p
+ 1;
6411 else if (*p
== '\0')
6417 /* Send a prepared I/O packet to the target and read its response.
6418 The prepared packet is in the global RS->BUF before this function
6419 is called, and the answer is there when we return.
6421 COMMAND_BYTES is the length of the request to send, which may include
6422 binary data. WHICH_PACKET is the packet configuration to check
6423 before attempting a packet. If an error occurs, *REMOTE_ERRNO
6424 is set to the error number and -1 is returned. Otherwise the value
6425 returned by the function is returned.
6427 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
6428 attachment is expected; an error will be reported if there's a
6429 mismatch. If one is found, *ATTACHMENT will be set to point into
6430 the packet buffer and *ATTACHMENT_LEN will be set to the
6431 attachment's length. */
6434 remote_hostio_send_command (int command_bytes
, int which_packet
,
6435 int *remote_errno
, char **attachment
,
6436 int *attachment_len
)
6438 struct remote_state
*rs
= get_remote_state ();
6439 int ret
, bytes_read
;
6440 char *attachment_tmp
;
6442 if (remote_protocol_packets
[which_packet
].support
== PACKET_DISABLE
)
6444 *remote_errno
= FILEIO_ENOSYS
;
6448 putpkt_binary (rs
->buf
, command_bytes
);
6449 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
6451 /* If it timed out, something is wrong. Don't try to parse the
6455 *remote_errno
= FILEIO_EINVAL
;
6459 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
6462 *remote_errno
= FILEIO_EINVAL
;
6464 case PACKET_UNKNOWN
:
6465 *remote_errno
= FILEIO_ENOSYS
;
6471 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
6474 *remote_errno
= FILEIO_EINVAL
;
6478 /* Make sure we saw an attachment if and only if we expected one. */
6479 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
6480 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
6482 *remote_errno
= FILEIO_EINVAL
;
6486 /* If an attachment was found, it must point into the packet buffer;
6487 work out how many bytes there were. */
6488 if (attachment_tmp
!= NULL
)
6490 *attachment
= attachment_tmp
;
6491 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
6497 /* Open FILENAME on the remote target, using FLAGS and MODE. Return a
6498 remote file descriptor, or -1 if an error occurs (and set
6502 remote_hostio_open (const char *filename
, int flags
, int mode
,
6505 struct remote_state
*rs
= get_remote_state ();
6507 int left
= get_remote_packet_size () - 1;
6509 remote_buffer_add_string (&p
, &left
, "vFile:open:");
6511 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
6513 remote_buffer_add_string (&p
, &left
, ",");
6515 remote_buffer_add_int (&p
, &left
, flags
);
6516 remote_buffer_add_string (&p
, &left
, ",");
6518 remote_buffer_add_int (&p
, &left
, mode
);
6520 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
6521 remote_errno
, NULL
, NULL
);
6524 /* Write up to LEN bytes from WRITE_BUF to FD on the remote target.
6525 Return the number of bytes written, or -1 if an error occurs (and
6526 set *REMOTE_ERRNO). */
6529 remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
6530 ULONGEST offset
, int *remote_errno
)
6532 struct remote_state
*rs
= get_remote_state ();
6534 int left
= get_remote_packet_size ();
6537 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
6539 remote_buffer_add_int (&p
, &left
, fd
);
6540 remote_buffer_add_string (&p
, &left
, ",");
6542 remote_buffer_add_int (&p
, &left
, offset
);
6543 remote_buffer_add_string (&p
, &left
, ",");
6545 p
+= remote_escape_output (write_buf
, len
, p
, &out_len
,
6546 get_remote_packet_size () - (p
- rs
->buf
));
6548 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
6549 remote_errno
, NULL
, NULL
);
6552 /* Read up to LEN bytes FD on the remote target into READ_BUF
6553 Return the number of bytes read, or -1 if an error occurs (and
6554 set *REMOTE_ERRNO). */
6557 remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
6558 ULONGEST offset
, int *remote_errno
)
6560 struct remote_state
*rs
= get_remote_state ();
6563 int left
= get_remote_packet_size ();
6564 int ret
, attachment_len
;
6567 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
6569 remote_buffer_add_int (&p
, &left
, fd
);
6570 remote_buffer_add_string (&p
, &left
, ",");
6572 remote_buffer_add_int (&p
, &left
, len
);
6573 remote_buffer_add_string (&p
, &left
, ",");
6575 remote_buffer_add_int (&p
, &left
, offset
);
6577 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
6578 remote_errno
, &attachment
,
6584 read_len
= remote_unescape_input (attachment
, attachment_len
,
6586 if (read_len
!= ret
)
6587 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
6592 /* Close FD on the remote target. Return 0, or -1 if an error occurs
6593 (and set *REMOTE_ERRNO). */
6596 remote_hostio_close (int fd
, int *remote_errno
)
6598 struct remote_state
*rs
= get_remote_state ();
6600 int left
= get_remote_packet_size () - 1;
6602 remote_buffer_add_string (&p
, &left
, "vFile:close:");
6604 remote_buffer_add_int (&p
, &left
, fd
);
6606 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
6607 remote_errno
, NULL
, NULL
);
6610 /* Unlink FILENAME on the remote target. Return 0, or -1 if an error
6611 occurs (and set *REMOTE_ERRNO). */
6614 remote_hostio_unlink (const char *filename
, int *remote_errno
)
6616 struct remote_state
*rs
= get_remote_state ();
6618 int left
= get_remote_packet_size () - 1;
6620 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
6622 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
6625 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
6626 remote_errno
, NULL
, NULL
);
6630 remote_fileio_errno_to_host (int errnum
)
6654 case FILEIO_ENOTDIR
:
6674 case FILEIO_ENAMETOOLONG
:
6675 return ENAMETOOLONG
;
6681 remote_hostio_error (int errnum
)
6683 int host_error
= remote_fileio_errno_to_host (errnum
);
6685 if (host_error
== -1)
6686 error (_("Unknown remote I/O error %d"), errnum
);
6688 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
6692 fclose_cleanup (void *file
)
6698 remote_hostio_close_cleanup (void *opaque
)
6700 int fd
= *(int *) opaque
;
6703 remote_hostio_close (fd
, &remote_errno
);
6707 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
6709 struct cleanup
*back_to
, *close_cleanup
;
6710 int retcode
, fd
, remote_errno
, bytes
, io_size
;
6713 int bytes_in_buffer
;
6718 error (_("command can only be used with remote target"));
6720 file
= fopen (local_file
, "rb");
6722 perror_with_name (local_file
);
6723 back_to
= make_cleanup (fclose_cleanup
, file
);
6725 fd
= remote_hostio_open (remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
6727 0700, &remote_errno
);
6729 remote_hostio_error (remote_errno
);
6731 /* Send up to this many bytes at once. They won't all fit in the
6732 remote packet limit, so we'll transfer slightly fewer. */
6733 io_size
= get_remote_packet_size ();
6734 buffer
= xmalloc (io_size
);
6735 make_cleanup (xfree
, buffer
);
6737 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
6739 bytes_in_buffer
= 0;
6742 while (bytes_in_buffer
|| !saw_eof
)
6746 bytes
= fread (buffer
+ bytes_in_buffer
, 1, io_size
- bytes_in_buffer
,
6751 error (_("Error reading %s."), local_file
);
6754 /* EOF. Unless there is something still in the
6755 buffer from the last iteration, we are done. */
6757 if (bytes_in_buffer
== 0)
6765 bytes
+= bytes_in_buffer
;
6766 bytes_in_buffer
= 0;
6768 retcode
= remote_hostio_pwrite (fd
, buffer
, bytes
, offset
, &remote_errno
);
6771 remote_hostio_error (remote_errno
);
6772 else if (retcode
== 0)
6773 error (_("Remote write of %d bytes returned 0!"), bytes
);
6774 else if (retcode
< bytes
)
6776 /* Short write. Save the rest of the read data for the next
6778 bytes_in_buffer
= bytes
- retcode
;
6779 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
6785 discard_cleanups (close_cleanup
);
6786 if (remote_hostio_close (fd
, &remote_errno
))
6787 remote_hostio_error (remote_errno
);
6790 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
6791 do_cleanups (back_to
);
6795 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
6797 struct cleanup
*back_to
, *close_cleanup
;
6798 int retcode
, fd
, remote_errno
, bytes
, io_size
;
6804 error (_("command can only be used with remote target"));
6806 fd
= remote_hostio_open (remote_file
, FILEIO_O_RDONLY
, 0, &remote_errno
);
6808 remote_hostio_error (remote_errno
);
6810 file
= fopen (local_file
, "wb");
6812 perror_with_name (local_file
);
6813 back_to
= make_cleanup (fclose_cleanup
, file
);
6815 /* Send up to this many bytes at once. They won't all fit in the
6816 remote packet limit, so we'll transfer slightly fewer. */
6817 io_size
= get_remote_packet_size ();
6818 buffer
= xmalloc (io_size
);
6819 make_cleanup (xfree
, buffer
);
6821 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
6826 bytes
= remote_hostio_pread (fd
, buffer
, io_size
, offset
, &remote_errno
);
6828 /* Success, but no bytes, means end-of-file. */
6831 remote_hostio_error (remote_errno
);
6835 bytes
= fwrite (buffer
, 1, bytes
, file
);
6837 perror_with_name (local_file
);
6840 discard_cleanups (close_cleanup
);
6841 if (remote_hostio_close (fd
, &remote_errno
))
6842 remote_hostio_error (remote_errno
);
6845 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
6846 do_cleanups (back_to
);
6850 remote_file_delete (const char *remote_file
, int from_tty
)
6852 int retcode
, remote_errno
;
6855 error (_("command can only be used with remote target"));
6857 retcode
= remote_hostio_unlink (remote_file
, &remote_errno
);
6859 remote_hostio_error (remote_errno
);
6862 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
6866 remote_put_command (char *args
, int from_tty
)
6868 struct cleanup
*back_to
;
6871 argv
= buildargv (args
);
6874 back_to
= make_cleanup_freeargv (argv
);
6875 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
6876 error (_("Invalid parameters to remote put"));
6878 remote_file_put (argv
[0], argv
[1], from_tty
);
6880 do_cleanups (back_to
);
6884 remote_get_command (char *args
, int from_tty
)
6886 struct cleanup
*back_to
;
6889 argv
= buildargv (args
);
6892 back_to
= make_cleanup_freeargv (argv
);
6893 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
6894 error (_("Invalid parameters to remote get"));
6896 remote_file_get (argv
[0], argv
[1], from_tty
);
6898 do_cleanups (back_to
);
6902 remote_delete_command (char *args
, int from_tty
)
6904 struct cleanup
*back_to
;
6907 argv
= buildargv (args
);
6910 back_to
= make_cleanup_freeargv (argv
);
6911 if (argv
[0] == NULL
|| argv
[1] != NULL
)
6912 error (_("Invalid parameters to remote delete"));
6914 remote_file_delete (argv
[0], from_tty
);
6916 do_cleanups (back_to
);
6920 remote_command (char *args
, int from_tty
)
6922 help_list (remote_cmdlist
, "remote ", -1, gdb_stdout
);
6926 init_remote_ops (void)
6928 remote_ops
.to_shortname
= "remote";
6929 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6931 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6932 Specify the serial device it is connected to\n\
6933 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6934 remote_ops
.to_open
= remote_open
;
6935 remote_ops
.to_close
= remote_close
;
6936 remote_ops
.to_detach
= remote_detach
;
6937 remote_ops
.to_disconnect
= remote_disconnect
;
6938 remote_ops
.to_resume
= remote_resume
;
6939 remote_ops
.to_wait
= remote_wait
;
6940 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6941 remote_ops
.to_store_registers
= remote_store_registers
;
6942 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6943 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6944 remote_ops
.to_files_info
= remote_files_info
;
6945 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6946 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6947 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6948 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6949 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6950 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6951 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6952 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6953 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6954 remote_ops
.to_kill
= remote_kill
;
6955 remote_ops
.to_load
= generic_load
;
6956 remote_ops
.to_mourn_inferior
= remote_mourn
;
6957 remote_ops
.to_thread_alive
= remote_thread_alive
;
6958 remote_ops
.to_find_new_threads
= remote_threads_info
;
6959 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6960 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6961 remote_ops
.to_stop
= remote_stop
;
6962 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6963 remote_ops
.to_rcmd
= remote_rcmd
;
6964 remote_ops
.to_log_command
= serial_log_command
;
6965 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6966 remote_ops
.to_stratum
= process_stratum
;
6967 remote_ops
.to_has_all_memory
= 1;
6968 remote_ops
.to_has_memory
= 1;
6969 remote_ops
.to_has_stack
= 1;
6970 remote_ops
.to_has_registers
= 1;
6971 remote_ops
.to_has_execution
= 1;
6972 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6973 remote_ops
.to_magic
= OPS_MAGIC
;
6974 remote_ops
.to_memory_map
= remote_memory_map
;
6975 remote_ops
.to_flash_erase
= remote_flash_erase
;
6976 remote_ops
.to_flash_done
= remote_flash_done
;
6977 remote_ops
.to_read_description
= remote_read_description
;
6980 /* Set up the extended remote vector by making a copy of the standard
6981 remote vector and adding to it. */
6984 init_extended_remote_ops (void)
6986 extended_remote_ops
= remote_ops
;
6988 extended_remote_ops
.to_shortname
= "extended-remote";
6989 extended_remote_ops
.to_longname
=
6990 "Extended remote serial target in gdb-specific protocol";
6991 extended_remote_ops
.to_doc
=
6992 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6993 Specify the serial device it is connected to (e.g. /dev/ttya).",
6994 extended_remote_ops
.to_open
= extended_remote_open
;
6995 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6996 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
7000 remote_can_async_p (void)
7002 /* We're async whenever the serial device is. */
7003 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
7007 remote_is_async_p (void)
7009 /* We're async whenever the serial device is. */
7010 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
7013 /* Pass the SERIAL event on and up to the client. One day this code
7014 will be able to delay notifying the client of an event until the
7015 point where an entire packet has been received. */
7017 static void (*async_client_callback
) (enum inferior_event_type event_type
,
7019 static void *async_client_context
;
7020 static serial_event_ftype remote_async_serial_handler
;
7023 remote_async_serial_handler (struct serial
*scb
, void *context
)
7025 /* Don't propogate error information up to the client. Instead let
7026 the client find out about the error by querying the target. */
7027 async_client_callback (INF_REG_EVENT
, async_client_context
);
7031 remote_async (void (*callback
) (enum inferior_event_type event_type
,
7032 void *context
), void *context
)
7034 if (current_target
.to_async_mask_value
== 0)
7035 internal_error (__FILE__
, __LINE__
,
7036 _("Calling remote_async when async is masked"));
7038 if (callback
!= NULL
)
7040 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
7041 async_client_callback
= callback
;
7042 async_client_context
= context
;
7045 serial_async (remote_desc
, NULL
, NULL
);
7048 /* Target async and target extended-async.
7050 This are temporary targets, until it is all tested. Eventually
7051 async support will be incorporated int the usual 'remote'
7055 init_remote_async_ops (void)
7057 remote_async_ops
.to_shortname
= "async";
7058 remote_async_ops
.to_longname
=
7059 "Remote serial target in async version of the gdb-specific protocol";
7060 remote_async_ops
.to_doc
=
7061 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
7062 Specify the serial device it is connected to (e.g. /dev/ttya).";
7063 remote_async_ops
.to_open
= remote_async_open
;
7064 remote_async_ops
.to_close
= remote_close
;
7065 remote_async_ops
.to_detach
= remote_detach
;
7066 remote_async_ops
.to_disconnect
= remote_disconnect
;
7067 remote_async_ops
.to_resume
= remote_async_resume
;
7068 remote_async_ops
.to_wait
= remote_async_wait
;
7069 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
7070 remote_async_ops
.to_store_registers
= remote_store_registers
;
7071 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
7072 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
7073 remote_async_ops
.to_files_info
= remote_files_info
;
7074 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
7075 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
7076 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
7077 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
7078 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
7079 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
7080 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
7081 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
7082 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
7083 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
7084 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
7085 remote_async_ops
.to_kill
= remote_async_kill
;
7086 remote_async_ops
.to_load
= generic_load
;
7087 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
7088 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
7089 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
7090 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
7091 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
7092 remote_async_ops
.to_stop
= remote_stop
;
7093 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
7094 remote_async_ops
.to_rcmd
= remote_rcmd
;
7095 remote_async_ops
.to_stratum
= process_stratum
;
7096 remote_async_ops
.to_has_all_memory
= 1;
7097 remote_async_ops
.to_has_memory
= 1;
7098 remote_async_ops
.to_has_stack
= 1;
7099 remote_async_ops
.to_has_registers
= 1;
7100 remote_async_ops
.to_has_execution
= 1;
7101 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
7102 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
7103 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
7104 remote_async_ops
.to_async
= remote_async
;
7105 remote_async_ops
.to_async_mask_value
= 1;
7106 remote_async_ops
.to_magic
= OPS_MAGIC
;
7107 remote_async_ops
.to_memory_map
= remote_memory_map
;
7108 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
7109 remote_async_ops
.to_flash_done
= remote_flash_done
;
7110 remote_async_ops
.to_read_description
= remote_read_description
;
7113 /* Set up the async extended remote vector by making a copy of the standard
7114 remote vector and adding to it. */
7117 init_extended_async_remote_ops (void)
7119 extended_async_remote_ops
= remote_async_ops
;
7121 extended_async_remote_ops
.to_shortname
= "extended-async";
7122 extended_async_remote_ops
.to_longname
=
7123 "Extended remote serial target in async gdb-specific protocol";
7124 extended_async_remote_ops
.to_doc
=
7125 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
7126 Specify the serial device it is connected to (e.g. /dev/ttya).",
7127 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
7128 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
7129 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
7133 set_remote_cmd (char *args
, int from_tty
)
7135 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
7139 show_remote_cmd (char *args
, int from_tty
)
7141 /* We can't just use cmd_show_list here, because we want to skip
7142 the redundant "show remote Z-packet" and the legacy aliases. */
7143 struct cleanup
*showlist_chain
;
7144 struct cmd_list_element
*list
= remote_show_cmdlist
;
7146 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
7147 for (; list
!= NULL
; list
= list
->next
)
7148 if (strcmp (list
->name
, "Z-packet") == 0)
7150 else if (list
->type
== not_set_cmd
)
7151 /* Alias commands are exactly like the original, except they
7152 don't have the normal type. */
7156 struct cleanup
*option_chain
7157 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
7158 ui_out_field_string (uiout
, "name", list
->name
);
7159 ui_out_text (uiout
, ": ");
7160 if (list
->type
== show_cmd
)
7161 do_setshow_command ((char *) NULL
, from_tty
, list
);
7163 cmd_func (list
, NULL
, from_tty
);
7164 /* Close the tuple. */
7165 do_cleanups (option_chain
);
7168 /* Close the tuple. */
7169 do_cleanups (showlist_chain
);
7173 /* Function to be called whenever a new objfile (shlib) is detected. */
7175 remote_new_objfile (struct objfile
*objfile
)
7177 if (remote_desc
!= 0) /* Have a remote connection. */
7178 remote_check_symbols (objfile
);
7182 _initialize_remote (void)
7184 struct remote_state
*rs
;
7186 /* architecture specific data */
7187 remote_gdbarch_data_handle
=
7188 gdbarch_data_register_post_init (init_remote_state
);
7189 remote_g_packet_data_handle
=
7190 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
7192 /* Initialize the per-target state. At the moment there is only one
7193 of these, not one per target. Only one target is active at a
7194 time. The default buffer size is unimportant; it will be expanded
7195 whenever a larger buffer is needed. */
7196 rs
= get_remote_state_raw ();
7198 rs
->buf
= xmalloc (rs
->buf_size
);
7201 add_target (&remote_ops
);
7203 init_extended_remote_ops ();
7204 add_target (&extended_remote_ops
);
7206 init_remote_async_ops ();
7207 add_target (&remote_async_ops
);
7209 init_extended_async_remote_ops ();
7210 add_target (&extended_async_remote_ops
);
7212 /* Hook into new objfile notification. */
7213 observer_attach_new_objfile (remote_new_objfile
);
7216 init_remote_threadtests ();
7219 /* set/show remote ... */
7221 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
7222 Remote protocol specific variables\n\
7223 Configure various remote-protocol specific variables such as\n\
7224 the packets being used"),
7225 &remote_set_cmdlist
, "set remote ",
7226 0 /* allow-unknown */, &setlist
);
7227 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
7228 Remote protocol specific variables\n\
7229 Configure various remote-protocol specific variables such as\n\
7230 the packets being used"),
7231 &remote_show_cmdlist
, "show remote ",
7232 0 /* allow-unknown */, &showlist
);
7234 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
7235 Compare section data on target to the exec file.\n\
7236 Argument is a single section name (default: all loaded sections)."),
7239 add_cmd ("packet", class_maintenance
, packet_command
, _("\
7240 Send an arbitrary packet to a remote target.\n\
7241 maintenance packet TEXT\n\
7242 If GDB is talking to an inferior via the GDB serial protocol, then\n\
7243 this command sends the string TEXT to the inferior, and displays the\n\
7244 response packet. GDB supplies the initial `$' character, and the\n\
7245 terminating `#' character and checksum."),
7248 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
7249 Set whether to send break if interrupted."), _("\
7250 Show whether to send break if interrupted."), _("\
7251 If set, a break, instead of a cntrl-c, is sent to the remote target."),
7252 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
7253 &setlist
, &showlist
);
7255 /* Install commands for configuring memory read/write packets. */
7257 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
7258 Set the maximum number of bytes per memory write packet (deprecated)."),
7260 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
7261 Show the maximum number of bytes per memory write packet (deprecated)."),
7263 add_cmd ("memory-write-packet-size", no_class
,
7264 set_memory_write_packet_size
, _("\
7265 Set the maximum number of bytes per memory-write packet.\n\
7266 Specify the number of bytes in a packet or 0 (zero) for the\n\
7267 default packet size. The actual limit is further reduced\n\
7268 dependent on the target. Specify ``fixed'' to disable the\n\
7269 further restriction and ``limit'' to enable that restriction."),
7270 &remote_set_cmdlist
);
7271 add_cmd ("memory-read-packet-size", no_class
,
7272 set_memory_read_packet_size
, _("\
7273 Set the maximum number of bytes per memory-read packet.\n\
7274 Specify the number of bytes in a packet or 0 (zero) for the\n\
7275 default packet size. The actual limit is further reduced\n\
7276 dependent on the target. Specify ``fixed'' to disable the\n\
7277 further restriction and ``limit'' to enable that restriction."),
7278 &remote_set_cmdlist
);
7279 add_cmd ("memory-write-packet-size", no_class
,
7280 show_memory_write_packet_size
,
7281 _("Show the maximum number of bytes per memory-write packet."),
7282 &remote_show_cmdlist
);
7283 add_cmd ("memory-read-packet-size", no_class
,
7284 show_memory_read_packet_size
,
7285 _("Show the maximum number of bytes per memory-read packet."),
7286 &remote_show_cmdlist
);
7288 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
7289 &remote_hw_watchpoint_limit
, _("\
7290 Set the maximum number of target hardware watchpoints."), _("\
7291 Show the maximum number of target hardware watchpoints."), _("\
7292 Specify a negative limit for unlimited."),
7293 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
7294 &remote_set_cmdlist
, &remote_show_cmdlist
);
7295 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
7296 &remote_hw_breakpoint_limit
, _("\
7297 Set the maximum number of target hardware breakpoints."), _("\
7298 Show the maximum number of target hardware breakpoints."), _("\
7299 Specify a negative limit for unlimited."),
7300 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
7301 &remote_set_cmdlist
, &remote_show_cmdlist
);
7303 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
7304 &remote_address_size
, _("\
7305 Set the maximum size of the address (in bits) in a memory packet."), _("\
7306 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
7308 NULL
, /* FIXME: i18n: */
7309 &setlist
, &showlist
);
7311 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
7312 "X", "binary-download", 1);
7314 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
7315 "vCont", "verbose-resume", 0);
7317 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
7318 "QPassSignals", "pass-signals", 0);
7320 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
7321 "qSymbol", "symbol-lookup", 0);
7323 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
7324 "P", "set-register", 1);
7326 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
7327 "p", "fetch-register", 1);
7329 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
7330 "Z0", "software-breakpoint", 0);
7332 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
7333 "Z1", "hardware-breakpoint", 0);
7335 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
7336 "Z2", "write-watchpoint", 0);
7338 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
7339 "Z3", "read-watchpoint", 0);
7341 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
7342 "Z4", "access-watchpoint", 0);
7344 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
7345 "qXfer:auxv:read", "read-aux-vector", 0);
7347 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
7348 "qXfer:features:read", "target-features", 0);
7350 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
7351 "qXfer:libraries:read", "library-info", 0);
7353 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
7354 "qXfer:memory-map:read", "memory-map", 0);
7356 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
7357 "qXfer:spu:read", "read-spu-object", 0);
7359 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
7360 "qXfer:spu:write", "write-spu-object", 0);
7362 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
7363 "qGetTLSAddr", "get-thread-local-storage-address",
7366 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
7367 "qSupported", "supported-packets", 0);
7369 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
7370 "vFile:open", "hostio-open", 0);
7372 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
7373 "vFile:pread", "hostio-pread", 0);
7375 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
7376 "vFile:pwrite", "hostio-pwrite", 0);
7378 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
7379 "vFile:close", "hostio-close", 0);
7381 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
7382 "vFile:unlink", "hostio-unlink", 0);
7384 /* Keep the old ``set remote Z-packet ...'' working. Each individual
7385 Z sub-packet has its own set and show commands, but users may
7386 have sets to this variable in their .gdbinit files (or in their
7388 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
7389 &remote_Z_packet_detect
, _("\
7390 Set use of remote protocol `Z' packets"), _("\
7391 Show use of remote protocol `Z' packets "), _("\
7392 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
7394 set_remote_protocol_Z_packet_cmd
,
7395 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
7396 &remote_set_cmdlist
, &remote_show_cmdlist
);
7398 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
7399 Manipulate files on the remote system\n\
7400 Transfer files to and from the remote target system."),
7401 &remote_cmdlist
, "remote ",
7402 0 /* allow-unknown */, &cmdlist
);
7404 add_cmd ("put", class_files
, remote_put_command
,
7405 _("Copy a local file to the remote system."),
7408 add_cmd ("get", class_files
, remote_get_command
,
7409 _("Copy a remote file to the local system."),
7412 add_cmd ("delete", class_files
, remote_delete_command
,
7413 _("Delete a remote file."),
7416 /* Eventually initialize fileio. See fileio.c */
7417 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);