1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* See the GDB User Guide for details of the GDB remote protocol. */
27 #include "gdb_string.h"
33 #include "exceptions.h"
35 /*#include "terminal.h" */
38 #include "gdb-stabs.h"
39 #include "gdbthread.h"
43 #include "gdb_assert.h"
46 #include "cli/cli-decode.h"
47 #include "cli/cli-setshow.h"
48 #include "target-descriptions.h"
53 #include "event-loop.h"
54 #include "event-top.h"
60 #include "gdbcore.h" /* for exec_bfd */
62 #include "remote-fileio.h"
64 #include "memory-map.h"
66 /* The size to align memory write packets, when practical. The protocol
67 does not guarantee any alignment, and gdb will generate short
68 writes and unaligned writes, but even as a best-effort attempt this
69 can improve bulk transfers. For instance, if a write is misaligned
70 relative to the target's data bus, the stub may need to make an extra
71 round trip fetching data from the target. This doesn't make a
72 huge difference, but it's easy to do, so we try to be helpful.
74 The alignment chosen is arbitrary; usually data bus width is
75 important here, not the possibly larger cache line size. */
76 enum { REMOTE_ALIGN_WRITES
= 16 };
78 /* Prototypes for local functions. */
79 static void cleanup_sigint_signal_handler (void *dummy
);
80 static void initialize_sigint_signal_handler (void);
81 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
83 static void handle_remote_sigint (int);
84 static void handle_remote_sigint_twice (int);
85 static void async_remote_interrupt (gdb_client_data
);
86 void async_remote_interrupt_twice (gdb_client_data
);
88 static void build_remote_gdbarch_data (void);
90 static void remote_files_info (struct target_ops
*ignore
);
92 static void remote_prepare_to_store (struct regcache
*regcache
);
94 static void remote_fetch_registers (struct regcache
*regcache
, int regno
);
96 static void remote_resume (ptid_t ptid
, int step
,
97 enum target_signal siggnal
);
98 static void remote_async_resume (ptid_t ptid
, int step
,
99 enum target_signal siggnal
);
100 static void remote_open (char *name
, int from_tty
);
101 static void remote_async_open (char *name
, int from_tty
);
103 static void extended_remote_open (char *name
, int from_tty
);
104 static void extended_remote_async_open (char *name
, int from_tty
);
106 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
,
109 static void remote_close (int quitting
);
111 static void remote_store_registers (struct regcache
*regcache
, int regno
);
113 static void remote_mourn (void);
114 static void remote_async_mourn (void);
116 static void extended_remote_restart (void);
118 static void extended_remote_mourn (void);
120 static void remote_mourn_1 (struct target_ops
*);
122 static void remote_send (char **buf
, long *sizeof_buf_p
);
124 static int readchar (int timeout
);
126 static ptid_t
remote_wait (ptid_t ptid
,
127 struct target_waitstatus
*status
);
128 static ptid_t
remote_async_wait (ptid_t ptid
,
129 struct target_waitstatus
*status
);
131 static void remote_kill (void);
132 static void remote_async_kill (void);
134 static int tohex (int nib
);
136 static void remote_detach (char *args
, int from_tty
);
138 static void remote_interrupt (int signo
);
140 static void remote_interrupt_twice (int signo
);
142 static void interrupt_query (void);
144 static void set_thread (int, int);
146 static int remote_thread_alive (ptid_t
);
148 static void get_offsets (void);
150 static void skip_frame (void);
152 static long read_frame (char **buf_p
, long *sizeof_buf
);
154 static int hexnumlen (ULONGEST num
);
156 static void init_remote_ops (void);
158 static void init_extended_remote_ops (void);
160 static void remote_stop (void);
162 static int ishex (int ch
, int *val
);
164 static int stubhex (int ch
);
166 static int hexnumstr (char *, ULONGEST
);
168 static int hexnumnstr (char *, ULONGEST
, int);
170 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
172 static void print_packet (char *);
174 static unsigned long crc32 (unsigned char *, int, unsigned int);
176 static void compare_sections_command (char *, int);
178 static void packet_command (char *, int);
180 static int stub_unpack_int (char *buff
, int fieldlength
);
182 static ptid_t
remote_current_thread (ptid_t oldptid
);
184 static void remote_find_new_threads (void);
186 static void record_currthread (int currthread
);
188 static int fromhex (int a
);
190 static int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
192 static int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
194 static int putpkt_binary (char *buf
, int cnt
);
196 static void check_binary_download (CORE_ADDR addr
);
198 struct packet_config
;
200 static void show_packet_config_cmd (struct packet_config
*config
);
202 static void update_packet_config (struct packet_config
*config
);
204 static void set_remote_protocol_packet_cmd (char *args
, int from_tty
,
205 struct cmd_list_element
*c
);
207 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
209 struct cmd_list_element
*c
,
212 void _initialize_remote (void);
214 /* For "set remote" and "show remote". */
216 static struct cmd_list_element
*remote_set_cmdlist
;
217 static struct cmd_list_element
*remote_show_cmdlist
;
219 /* Description of the remote protocol state for the currently
220 connected target. This is per-target state, and independent of the
221 selected architecture. */
225 /* A buffer to use for incoming packets, and its current size. The
226 buffer is grown dynamically for larger incoming packets.
227 Outgoing packets may also be constructed in this buffer.
228 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
229 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
234 /* If we negotiated packet size explicitly (and thus can bypass
235 heuristics for the largest packet size that will not overflow
236 a buffer in the stub), this will be set to that packet size.
237 Otherwise zero, meaning to use the guessed size. */
238 long explicit_packet_size
;
241 /* This data could be associated with a target, but we do not always
242 have access to the current target when we need it, so for now it is
243 static. This will be fine for as long as only one target is in use
245 static struct remote_state remote_state
;
247 static struct remote_state
*
248 get_remote_state_raw (void)
250 return &remote_state
;
253 /* Description of the remote protocol for a given architecture. */
257 long offset
; /* Offset into G packet. */
258 long regnum
; /* GDB's internal register number. */
259 LONGEST pnum
; /* Remote protocol register number. */
260 int in_g_packet
; /* Always part of G packet. */
261 /* long size in bytes; == register_size (current_gdbarch, regnum);
263 /* char *name; == gdbarch_register_name (current_gdbarch, regnum);
267 struct remote_arch_state
269 /* Description of the remote protocol registers. */
270 long sizeof_g_packet
;
272 /* Description of the remote protocol registers indexed by REGNUM
273 (making an array gdbarch_num_regs in size). */
274 struct packet_reg
*regs
;
276 /* This is the size (in chars) of the first response to the ``g''
277 packet. It is used as a heuristic when determining the maximum
278 size of memory-read and memory-write packets. A target will
279 typically only reserve a buffer large enough to hold the ``g''
280 packet. The size does not include packet overhead (headers and
282 long actual_register_packet_size
;
284 /* This is the maximum size (in chars) of a non read/write packet.
285 It is also used as a cap on the size of read/write packets. */
286 long remote_packet_size
;
290 /* Handle for retreving the remote protocol data from gdbarch. */
291 static struct gdbarch_data
*remote_gdbarch_data_handle
;
293 static struct remote_arch_state
*
294 get_remote_arch_state (void)
296 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
299 /* Fetch the global remote target state. */
301 static struct remote_state
*
302 get_remote_state (void)
304 /* Make sure that the remote architecture state has been
305 initialized, because doing so might reallocate rs->buf. Any
306 function which calls getpkt also needs to be mindful of changes
307 to rs->buf, but this call limits the number of places which run
309 get_remote_arch_state ();
311 return get_remote_state_raw ();
315 compare_pnums (const void *lhs_
, const void *rhs_
)
317 const struct packet_reg
* const *lhs
= lhs_
;
318 const struct packet_reg
* const *rhs
= rhs_
;
320 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
322 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
329 init_remote_state (struct gdbarch
*gdbarch
)
331 int regnum
, num_remote_regs
, offset
;
332 struct remote_state
*rs
= get_remote_state_raw ();
333 struct remote_arch_state
*rsa
;
334 struct packet_reg
**remote_regs
;
336 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
338 /* Use the architecture to build a regnum<->pnum table, which will be
339 1:1 unless a feature set specifies otherwise. */
340 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
341 gdbarch_num_regs (current_gdbarch
),
343 for (regnum
= 0; regnum
< gdbarch_num_regs (current_gdbarch
); regnum
++)
345 struct packet_reg
*r
= &rsa
->regs
[regnum
];
347 if (register_size (current_gdbarch
, regnum
) == 0)
348 /* Do not try to fetch zero-sized (placeholder) registers. */
351 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
356 /* Define the g/G packet format as the contents of each register
357 with a remote protocol number, in order of ascending protocol
360 remote_regs
= alloca (gdbarch_num_regs (current_gdbarch
)
361 * sizeof (struct packet_reg
*));
362 for (num_remote_regs
= 0, regnum
= 0;
363 regnum
< gdbarch_num_regs (current_gdbarch
);
365 if (rsa
->regs
[regnum
].pnum
!= -1)
366 remote_regs
[num_remote_regs
++] = &rsa
->regs
[regnum
];
368 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
371 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
373 remote_regs
[regnum
]->in_g_packet
= 1;
374 remote_regs
[regnum
]->offset
= offset
;
375 offset
+= register_size (current_gdbarch
, remote_regs
[regnum
]->regnum
);
378 /* Record the maximum possible size of the g packet - it may turn out
380 rsa
->sizeof_g_packet
= offset
;
382 /* Default maximum number of characters in a packet body. Many
383 remote stubs have a hardwired buffer size of 400 bytes
384 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
385 as the maximum packet-size to ensure that the packet and an extra
386 NUL character can always fit in the buffer. This stops GDB
387 trashing stubs that try to squeeze an extra NUL into what is
388 already a full buffer (As of 1999-12-04 that was most stubs). */
389 rsa
->remote_packet_size
= 400 - 1;
391 /* This one is filled in when a ``g'' packet is received. */
392 rsa
->actual_register_packet_size
= 0;
394 /* Should rsa->sizeof_g_packet needs more space than the
395 default, adjust the size accordingly. Remember that each byte is
396 encoded as two characters. 32 is the overhead for the packet
397 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
398 (``$NN:G...#NN'') is a better guess, the below has been padded a
400 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
401 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
403 /* Make sure that the packet buffer is plenty big enough for
404 this architecture. */
405 if (rs
->buf_size
< rsa
->remote_packet_size
)
407 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
408 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
414 /* Return the current allowed size of a remote packet. This is
415 inferred from the current architecture, and should be used to
416 limit the length of outgoing packets. */
418 get_remote_packet_size (void)
420 struct remote_state
*rs
= get_remote_state ();
421 struct remote_arch_state
*rsa
= get_remote_arch_state ();
423 if (rs
->explicit_packet_size
)
424 return rs
->explicit_packet_size
;
426 return rsa
->remote_packet_size
;
429 static struct packet_reg
*
430 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
432 if (regnum
< 0 && regnum
>= gdbarch_num_regs (current_gdbarch
))
436 struct packet_reg
*r
= &rsa
->regs
[regnum
];
437 gdb_assert (r
->regnum
== regnum
);
442 static struct packet_reg
*
443 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
446 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
448 struct packet_reg
*r
= &rsa
->regs
[i
];
455 /* FIXME: graces/2002-08-08: These variables should eventually be
456 bound to an instance of the target object (as in gdbarch-tdep()),
457 when such a thing exists. */
459 /* This is set to the data address of the access causing the target
460 to stop for a watchpoint. */
461 static CORE_ADDR remote_watch_data_address
;
463 /* This is non-zero if target stopped for a watchpoint. */
464 static int remote_stopped_by_watchpoint_p
;
466 static struct target_ops remote_ops
;
468 static struct target_ops extended_remote_ops
;
470 /* Temporary target ops. Just like the remote_ops and
471 extended_remote_ops, but with asynchronous support. */
472 static struct target_ops remote_async_ops
;
474 static struct target_ops extended_async_remote_ops
;
476 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
477 ``forever'' still use the normal timeout mechanism. This is
478 currently used by the ASYNC code to guarentee that target reads
479 during the initial connect always time-out. Once getpkt has been
480 modified to return a timeout indication and, in turn
481 remote_wait()/wait_for_inferior() have gained a timeout parameter
483 static int wait_forever_enabled_p
= 1;
486 /* This variable chooses whether to send a ^C or a break when the user
487 requests program interruption. Although ^C is usually what remote
488 systems expect, and that is the default here, sometimes a break is
489 preferable instead. */
491 static int remote_break
;
493 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
494 remote_open knows that we don't have a file open when the program
496 static struct serial
*remote_desc
= NULL
;
498 /* This variable sets the number of bits in an address that are to be
499 sent in a memory ("M" or "m") packet. Normally, after stripping
500 leading zeros, the entire address would be sent. This variable
501 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
502 initial implementation of remote.c restricted the address sent in
503 memory packets to ``host::sizeof long'' bytes - (typically 32
504 bits). Consequently, for 64 bit targets, the upper 32 bits of an
505 address was never sent. Since fixing this bug may cause a break in
506 some remote targets this variable is principly provided to
507 facilitate backward compatibility. */
509 static int remote_address_size
;
511 /* Tempoary to track who currently owns the terminal. See
512 target_async_terminal_* for more details. */
514 static int remote_async_terminal_ours_p
;
517 /* User configurable variables for the number of characters in a
518 memory read/write packet. MIN (rsa->remote_packet_size,
519 rsa->sizeof_g_packet) is the default. Some targets need smaller
520 values (fifo overruns, et.al.) and some users need larger values
521 (speed up transfers). The variables ``preferred_*'' (the user
522 request), ``current_*'' (what was actually set) and ``forced_*''
523 (Positive - a soft limit, negative - a hard limit). */
525 struct memory_packet_config
532 /* Compute the current size of a read/write packet. Since this makes
533 use of ``actual_register_packet_size'' the computation is dynamic. */
536 get_memory_packet_size (struct memory_packet_config
*config
)
538 struct remote_state
*rs
= get_remote_state ();
539 struct remote_arch_state
*rsa
= get_remote_arch_state ();
541 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
542 law?) that some hosts don't cope very well with large alloca()
543 calls. Eventually the alloca() code will be replaced by calls to
544 xmalloc() and make_cleanups() allowing this restriction to either
545 be lifted or removed. */
546 #ifndef MAX_REMOTE_PACKET_SIZE
547 #define MAX_REMOTE_PACKET_SIZE 16384
549 /* NOTE: 20 ensures we can write at least one byte. */
550 #ifndef MIN_REMOTE_PACKET_SIZE
551 #define MIN_REMOTE_PACKET_SIZE 20
556 if (config
->size
<= 0)
557 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
559 what_they_get
= config
->size
;
563 what_they_get
= get_remote_packet_size ();
564 /* Limit the packet to the size specified by the user. */
566 && what_they_get
> config
->size
)
567 what_they_get
= config
->size
;
569 /* Limit it to the size of the targets ``g'' response unless we have
570 permission from the stub to use a larger packet size. */
571 if (rs
->explicit_packet_size
== 0
572 && rsa
->actual_register_packet_size
> 0
573 && what_they_get
> rsa
->actual_register_packet_size
)
574 what_they_get
= rsa
->actual_register_packet_size
;
576 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
577 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
578 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
579 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
581 /* Make sure there is room in the global buffer for this packet
582 (including its trailing NUL byte). */
583 if (rs
->buf_size
< what_they_get
+ 1)
585 rs
->buf_size
= 2 * what_they_get
;
586 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
589 return what_they_get
;
592 /* Update the size of a read/write packet. If they user wants
593 something really big then do a sanity check. */
596 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
598 int fixed_p
= config
->fixed_p
;
599 long size
= config
->size
;
601 error (_("Argument required (integer, `fixed' or `limited')."));
602 else if (strcmp (args
, "hard") == 0
603 || strcmp (args
, "fixed") == 0)
605 else if (strcmp (args
, "soft") == 0
606 || strcmp (args
, "limit") == 0)
611 size
= strtoul (args
, &end
, 0);
613 error (_("Invalid %s (bad syntax)."), config
->name
);
615 /* Instead of explicitly capping the size of a packet to
616 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
617 instead allowed to set the size to something arbitrarily
619 if (size
> MAX_REMOTE_PACKET_SIZE
)
620 error (_("Invalid %s (too large)."), config
->name
);
624 if (fixed_p
&& !config
->fixed_p
)
626 if (! query (_("The target may not be able to correctly handle a %s\n"
627 "of %ld bytes. Change the packet size? "),
629 error (_("Packet size not changed."));
631 /* Update the config. */
632 config
->fixed_p
= fixed_p
;
637 show_memory_packet_size (struct memory_packet_config
*config
)
639 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
641 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
642 get_memory_packet_size (config
));
644 printf_filtered (_("Packets are limited to %ld bytes.\n"),
645 get_memory_packet_size (config
));
648 static struct memory_packet_config memory_write_packet_config
=
650 "memory-write-packet-size",
654 set_memory_write_packet_size (char *args
, int from_tty
)
656 set_memory_packet_size (args
, &memory_write_packet_config
);
660 show_memory_write_packet_size (char *args
, int from_tty
)
662 show_memory_packet_size (&memory_write_packet_config
);
666 get_memory_write_packet_size (void)
668 return get_memory_packet_size (&memory_write_packet_config
);
671 static struct memory_packet_config memory_read_packet_config
=
673 "memory-read-packet-size",
677 set_memory_read_packet_size (char *args
, int from_tty
)
679 set_memory_packet_size (args
, &memory_read_packet_config
);
683 show_memory_read_packet_size (char *args
, int from_tty
)
685 show_memory_packet_size (&memory_read_packet_config
);
689 get_memory_read_packet_size (void)
691 long size
= get_memory_packet_size (&memory_read_packet_config
);
692 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
693 extra buffer size argument before the memory read size can be
694 increased beyond this. */
695 if (size
> get_remote_packet_size ())
696 size
= get_remote_packet_size ();
701 /* Generic configuration support for packets the stub optionally
702 supports. Allows the user to specify the use of the packet as well
703 as allowing GDB to auto-detect support in the remote stub. */
707 PACKET_SUPPORT_UNKNOWN
= 0,
716 enum auto_boolean detect
;
717 enum packet_support support
;
720 /* Analyze a packet's return value and update the packet config
731 update_packet_config (struct packet_config
*config
)
733 switch (config
->detect
)
735 case AUTO_BOOLEAN_TRUE
:
736 config
->support
= PACKET_ENABLE
;
738 case AUTO_BOOLEAN_FALSE
:
739 config
->support
= PACKET_DISABLE
;
741 case AUTO_BOOLEAN_AUTO
:
742 config
->support
= PACKET_SUPPORT_UNKNOWN
;
748 show_packet_config_cmd (struct packet_config
*config
)
750 char *support
= "internal-error";
751 switch (config
->support
)
757 support
= "disabled";
759 case PACKET_SUPPORT_UNKNOWN
:
763 switch (config
->detect
)
765 case AUTO_BOOLEAN_AUTO
:
766 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
767 config
->name
, support
);
769 case AUTO_BOOLEAN_TRUE
:
770 case AUTO_BOOLEAN_FALSE
:
771 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
772 config
->name
, support
);
778 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
779 const char *title
, int legacy
)
786 config
->title
= title
;
787 config
->detect
= AUTO_BOOLEAN_AUTO
;
788 config
->support
= PACKET_SUPPORT_UNKNOWN
;
789 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
791 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
793 /* set/show TITLE-packet {auto,on,off} */
794 cmd_name
= xstrprintf ("%s-packet", title
);
795 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
796 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
797 set_remote_protocol_packet_cmd
,
798 show_remote_protocol_packet_cmd
,
799 &remote_set_cmdlist
, &remote_show_cmdlist
);
800 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
804 legacy_name
= xstrprintf ("%s-packet", name
);
805 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
806 &remote_set_cmdlist
);
807 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
808 &remote_show_cmdlist
);
812 static enum packet_result
813 packet_check_result (const char *buf
)
817 /* The stub recognized the packet request. Check that the
818 operation succeeded. */
820 && isxdigit (buf
[1]) && isxdigit (buf
[2])
822 /* "Enn" - definitly an error. */
825 /* Always treat "E." as an error. This will be used for
826 more verbose error messages, such as E.memtypes. */
827 if (buf
[0] == 'E' && buf
[1] == '.')
830 /* The packet may or may not be OK. Just assume it is. */
834 /* The stub does not support the packet. */
835 return PACKET_UNKNOWN
;
838 static enum packet_result
839 packet_ok (const char *buf
, struct packet_config
*config
)
841 enum packet_result result
;
843 result
= packet_check_result (buf
);
848 /* The stub recognized the packet request. */
849 switch (config
->support
)
851 case PACKET_SUPPORT_UNKNOWN
:
853 fprintf_unfiltered (gdb_stdlog
,
854 "Packet %s (%s) is supported\n",
855 config
->name
, config
->title
);
856 config
->support
= PACKET_ENABLE
;
859 internal_error (__FILE__
, __LINE__
,
860 _("packet_ok: attempt to use a disabled packet"));
867 /* The stub does not support the packet. */
868 switch (config
->support
)
871 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
872 /* If the stub previously indicated that the packet was
873 supported then there is a protocol error.. */
874 error (_("Protocol error: %s (%s) conflicting enabled responses."),
875 config
->name
, config
->title
);
877 /* The user set it wrong. */
878 error (_("Enabled packet %s (%s) not recognized by stub"),
879 config
->name
, config
->title
);
881 case PACKET_SUPPORT_UNKNOWN
:
883 fprintf_unfiltered (gdb_stdlog
,
884 "Packet %s (%s) is NOT supported\n",
885 config
->name
, config
->title
);
886 config
->support
= PACKET_DISABLE
;
909 PACKET_qXfer_features
,
910 PACKET_qXfer_memory_map
,
911 PACKET_qXfer_spu_read
,
912 PACKET_qXfer_spu_write
,
919 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
922 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
923 struct cmd_list_element
*c
)
925 struct packet_config
*packet
;
927 for (packet
= remote_protocol_packets
;
928 packet
< &remote_protocol_packets
[PACKET_MAX
];
931 if (&packet
->detect
== c
->var
)
933 update_packet_config (packet
);
937 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
942 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
943 struct cmd_list_element
*c
,
946 struct packet_config
*packet
;
948 for (packet
= remote_protocol_packets
;
949 packet
< &remote_protocol_packets
[PACKET_MAX
];
952 if (&packet
->detect
== c
->var
)
954 show_packet_config_cmd (packet
);
958 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
962 /* Should we try one of the 'Z' requests? */
966 Z_PACKET_SOFTWARE_BP
,
967 Z_PACKET_HARDWARE_BP
,
974 /* For compatibility with older distributions. Provide a ``set remote
975 Z-packet ...'' command that updates all the Z packet types. */
977 static enum auto_boolean remote_Z_packet_detect
;
980 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
981 struct cmd_list_element
*c
)
984 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
986 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
987 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
992 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
993 struct cmd_list_element
*c
,
997 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
999 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1003 /* Should we try the 'ThreadInfo' query packet?
1005 This variable (NOT available to the user: auto-detect only!)
1006 determines whether GDB will use the new, simpler "ThreadInfo"
1007 query or the older, more complex syntax for thread queries.
1008 This is an auto-detect variable (set to true at each connect,
1009 and set to false when the target fails to recognize it). */
1011 static int use_threadinfo_query
;
1012 static int use_threadextra_query
;
1014 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1015 static struct async_signal_handler
*sigint_remote_twice_token
;
1016 static struct async_signal_handler
*sigint_remote_token
;
1018 /* These are pointers to hook functions that may be set in order to
1019 modify resume/wait behavior for a particular architecture. */
1021 void (*deprecated_target_resume_hook
) (void);
1022 void (*deprecated_target_wait_loop_hook
) (void);
1026 /* These are the threads which we last sent to the remote system.
1027 -1 for all or -2 for not sent yet. */
1028 static int general_thread
;
1029 static int continue_thread
;
1031 /* Call this function as a result of
1032 1) A halt indication (T packet) containing a thread id
1033 2) A direct query of currthread
1034 3) Successful execution of set thread
1038 record_currthread (int currthread
)
1040 general_thread
= currthread
;
1042 /* If this is a new thread, add it to GDB's thread list.
1043 If we leave it up to WFI to do this, bad things will happen. */
1044 if (!in_thread_list (pid_to_ptid (currthread
)))
1046 add_thread (pid_to_ptid (currthread
));
1047 ui_out_text (uiout
, "[New ");
1048 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
1049 ui_out_text (uiout
, "]\n");
1053 static char *last_pass_packet
;
1055 /* If 'QPassSignals' is supported, tell the remote stub what signals
1056 it can simply pass through to the inferior without reporting. */
1059 remote_pass_signals (void)
1061 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1063 char *pass_packet
, *p
;
1064 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1067 gdb_assert (numsigs
< 256);
1068 for (i
= 0; i
< numsigs
; i
++)
1070 if (signal_stop_state (i
) == 0
1071 && signal_print_state (i
) == 0
1072 && signal_pass_state (i
) == 1)
1075 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1076 strcpy (pass_packet
, "QPassSignals:");
1077 p
= pass_packet
+ strlen (pass_packet
);
1078 for (i
= 0; i
< numsigs
; i
++)
1080 if (signal_stop_state (i
) == 0
1081 && signal_print_state (i
) == 0
1082 && signal_pass_state (i
) == 1)
1085 *p
++ = tohex (i
>> 4);
1086 *p
++ = tohex (i
& 15);
1095 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1097 struct remote_state
*rs
= get_remote_state ();
1098 char *buf
= rs
->buf
;
1100 putpkt (pass_packet
);
1101 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1102 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1103 if (last_pass_packet
)
1104 xfree (last_pass_packet
);
1105 last_pass_packet
= pass_packet
;
1108 xfree (pass_packet
);
1112 #define MAGIC_NULL_PID 42000
1115 set_thread (int th
, int gen
)
1117 struct remote_state
*rs
= get_remote_state ();
1118 char *buf
= rs
->buf
;
1119 int state
= gen
? general_thread
: continue_thread
;
1125 buf
[1] = gen
? 'g' : 'c';
1126 if (th
== MAGIC_NULL_PID
)
1132 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
1134 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
1136 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1138 general_thread
= th
;
1140 continue_thread
= th
;
1143 /* Return nonzero if the thread TH is still alive on the remote system. */
1146 remote_thread_alive (ptid_t ptid
)
1148 struct remote_state
*rs
= get_remote_state ();
1149 int tid
= PIDGET (ptid
);
1152 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1154 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1156 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1157 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1160 /* About these extended threadlist and threadinfo packets. They are
1161 variable length packets but, the fields within them are often fixed
1162 length. They are redundent enough to send over UDP as is the
1163 remote protocol in general. There is a matching unit test module
1166 #define OPAQUETHREADBYTES 8
1168 /* a 64 bit opaque identifier */
1169 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1171 /* WARNING: This threadref data structure comes from the remote O.S.,
1172 libstub protocol encoding, and remote.c. it is not particularly
1175 /* Right now, the internal structure is int. We want it to be bigger.
1179 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1181 /* gdb_ext_thread_info is an internal GDB data structure which is
1182 equivalent to the reply of the remote threadinfo packet. */
1184 struct gdb_ext_thread_info
1186 threadref threadid
; /* External form of thread reference. */
1187 int active
; /* Has state interesting to GDB?
1189 char display
[256]; /* Brief state display, name,
1190 blocked/suspended. */
1191 char shortname
[32]; /* To be used to name threads. */
1192 char more_display
[256]; /* Long info, statistics, queue depth,
1196 /* The volume of remote transfers can be limited by submitting
1197 a mask containing bits specifying the desired information.
1198 Use a union of these values as the 'selection' parameter to
1199 get_thread_info. FIXME: Make these TAG names more thread specific.
1202 #define TAG_THREADID 1
1203 #define TAG_EXISTS 2
1204 #define TAG_DISPLAY 4
1205 #define TAG_THREADNAME 8
1206 #define TAG_MOREDISPLAY 16
1208 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1210 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1212 static char *unpack_nibble (char *buf
, int *val
);
1214 static char *pack_nibble (char *buf
, int nibble
);
1216 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1218 static char *unpack_byte (char *buf
, int *value
);
1220 static char *pack_int (char *buf
, int value
);
1222 static char *unpack_int (char *buf
, int *value
);
1224 static char *unpack_string (char *src
, char *dest
, int length
);
1226 static char *pack_threadid (char *pkt
, threadref
*id
);
1228 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1230 void int_to_threadref (threadref
*id
, int value
);
1232 static int threadref_to_int (threadref
*ref
);
1234 static void copy_threadref (threadref
*dest
, threadref
*src
);
1236 static int threadmatch (threadref
*dest
, threadref
*src
);
1238 static char *pack_threadinfo_request (char *pkt
, int mode
,
1241 static int remote_unpack_thread_info_response (char *pkt
,
1242 threadref
*expectedref
,
1243 struct gdb_ext_thread_info
1247 static int remote_get_threadinfo (threadref
*threadid
,
1248 int fieldset
, /*TAG mask */
1249 struct gdb_ext_thread_info
*info
);
1251 static char *pack_threadlist_request (char *pkt
, int startflag
,
1253 threadref
*nextthread
);
1255 static int parse_threadlist_response (char *pkt
,
1257 threadref
*original_echo
,
1258 threadref
*resultlist
,
1261 static int remote_get_threadlist (int startflag
,
1262 threadref
*nextthread
,
1266 threadref
*threadlist
);
1268 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1270 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1271 void *context
, int looplimit
);
1273 static int remote_newthread_step (threadref
*ref
, void *context
);
1275 /* Encode 64 bits in 16 chars of hex. */
1277 static const char hexchars
[] = "0123456789abcdef";
1280 ishex (int ch
, int *val
)
1282 if ((ch
>= 'a') && (ch
<= 'f'))
1284 *val
= ch
- 'a' + 10;
1287 if ((ch
>= 'A') && (ch
<= 'F'))
1289 *val
= ch
- 'A' + 10;
1292 if ((ch
>= '0') && (ch
<= '9'))
1303 if (ch
>= 'a' && ch
<= 'f')
1304 return ch
- 'a' + 10;
1305 if (ch
>= '0' && ch
<= '9')
1307 if (ch
>= 'A' && ch
<= 'F')
1308 return ch
- 'A' + 10;
1313 stub_unpack_int (char *buff
, int fieldlength
)
1320 nibble
= stubhex (*buff
++);
1324 retval
= retval
<< 4;
1330 unpack_varlen_hex (char *buff
, /* packet to parse */
1334 ULONGEST retval
= 0;
1336 while (ishex (*buff
, &nibble
))
1339 retval
= retval
<< 4;
1340 retval
|= nibble
& 0x0f;
1347 unpack_nibble (char *buf
, int *val
)
1349 ishex (*buf
++, val
);
1354 pack_nibble (char *buf
, int nibble
)
1356 *buf
++ = hexchars
[(nibble
& 0x0f)];
1361 pack_hex_byte (char *pkt
, int byte
)
1363 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1364 *pkt
++ = hexchars
[(byte
& 0xf)];
1369 unpack_byte (char *buf
, int *value
)
1371 *value
= stub_unpack_int (buf
, 2);
1376 pack_int (char *buf
, int value
)
1378 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1379 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1380 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1381 buf
= pack_hex_byte (buf
, (value
& 0xff));
1386 unpack_int (char *buf
, int *value
)
1388 *value
= stub_unpack_int (buf
, 8);
1392 #if 0 /* Currently unused, uncomment when needed. */
1393 static char *pack_string (char *pkt
, char *string
);
1396 pack_string (char *pkt
, char *string
)
1401 len
= strlen (string
);
1403 len
= 200; /* Bigger than most GDB packets, junk??? */
1404 pkt
= pack_hex_byte (pkt
, len
);
1408 if ((ch
== '\0') || (ch
== '#'))
1409 ch
= '*'; /* Protect encapsulation. */
1414 #endif /* 0 (unused) */
1417 unpack_string (char *src
, char *dest
, int length
)
1426 pack_threadid (char *pkt
, threadref
*id
)
1429 unsigned char *altid
;
1431 altid
= (unsigned char *) id
;
1432 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1434 pkt
= pack_hex_byte (pkt
, *altid
++);
1440 unpack_threadid (char *inbuf
, threadref
*id
)
1443 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1446 altref
= (char *) id
;
1448 while (inbuf
< limit
)
1450 x
= stubhex (*inbuf
++);
1451 y
= stubhex (*inbuf
++);
1452 *altref
++ = (x
<< 4) | y
;
1457 /* Externally, threadrefs are 64 bits but internally, they are still
1458 ints. This is due to a mismatch of specifications. We would like
1459 to use 64bit thread references internally. This is an adapter
1463 int_to_threadref (threadref
*id
, int value
)
1465 unsigned char *scan
;
1467 scan
= (unsigned char *) id
;
1473 *scan
++ = (value
>> 24) & 0xff;
1474 *scan
++ = (value
>> 16) & 0xff;
1475 *scan
++ = (value
>> 8) & 0xff;
1476 *scan
++ = (value
& 0xff);
1480 threadref_to_int (threadref
*ref
)
1483 unsigned char *scan
;
1489 value
= (value
<< 8) | ((*scan
++) & 0xff);
1494 copy_threadref (threadref
*dest
, threadref
*src
)
1497 unsigned char *csrc
, *cdest
;
1499 csrc
= (unsigned char *) src
;
1500 cdest
= (unsigned char *) dest
;
1507 threadmatch (threadref
*dest
, threadref
*src
)
1509 /* Things are broken right now, so just assume we got a match. */
1511 unsigned char *srcp
, *destp
;
1513 srcp
= (char *) src
;
1514 destp
= (char *) dest
;
1518 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1525 threadid:1, # always request threadid
1532 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1535 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1537 *pkt
++ = 'q'; /* Info Query */
1538 *pkt
++ = 'P'; /* process or thread info */
1539 pkt
= pack_int (pkt
, mode
); /* mode */
1540 pkt
= pack_threadid (pkt
, id
); /* threadid */
1541 *pkt
= '\0'; /* terminate */
1545 /* These values tag the fields in a thread info response packet. */
1546 /* Tagging the fields allows us to request specific fields and to
1547 add more fields as time goes by. */
1549 #define TAG_THREADID 1 /* Echo the thread identifier. */
1550 #define TAG_EXISTS 2 /* Is this process defined enough to
1551 fetch registers and its stack? */
1552 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1553 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1554 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1558 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1559 struct gdb_ext_thread_info
*info
)
1561 struct remote_state
*rs
= get_remote_state ();
1565 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1568 /* info->threadid = 0; FIXME: implement zero_threadref. */
1570 info
->display
[0] = '\0';
1571 info
->shortname
[0] = '\0';
1572 info
->more_display
[0] = '\0';
1574 /* Assume the characters indicating the packet type have been
1576 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1577 pkt
= unpack_threadid (pkt
, &ref
);
1580 warning (_("Incomplete response to threadinfo request."));
1581 if (!threadmatch (&ref
, expectedref
))
1582 { /* This is an answer to a different request. */
1583 warning (_("ERROR RMT Thread info mismatch."));
1586 copy_threadref (&info
->threadid
, &ref
);
1588 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1590 /* Packets are terminated with nulls. */
1591 while ((pkt
< limit
) && mask
&& *pkt
)
1593 pkt
= unpack_int (pkt
, &tag
); /* tag */
1594 pkt
= unpack_byte (pkt
, &length
); /* length */
1595 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1597 warning (_("ERROR RMT: threadinfo tag mismatch."));
1601 if (tag
== TAG_THREADID
)
1605 warning (_("ERROR RMT: length of threadid is not 16."));
1609 pkt
= unpack_threadid (pkt
, &ref
);
1610 mask
= mask
& ~TAG_THREADID
;
1613 if (tag
== TAG_EXISTS
)
1615 info
->active
= stub_unpack_int (pkt
, length
);
1617 mask
= mask
& ~(TAG_EXISTS
);
1620 warning (_("ERROR RMT: 'exists' length too long."));
1626 if (tag
== TAG_THREADNAME
)
1628 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1629 mask
= mask
& ~TAG_THREADNAME
;
1632 if (tag
== TAG_DISPLAY
)
1634 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1635 mask
= mask
& ~TAG_DISPLAY
;
1638 if (tag
== TAG_MOREDISPLAY
)
1640 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1641 mask
= mask
& ~TAG_MOREDISPLAY
;
1644 warning (_("ERROR RMT: unknown thread info tag."));
1645 break; /* Not a tag we know about. */
1651 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1652 struct gdb_ext_thread_info
*info
)
1654 struct remote_state
*rs
= get_remote_state ();
1657 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1659 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1660 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1665 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1668 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1669 threadref
*nextthread
)
1671 *pkt
++ = 'q'; /* info query packet */
1672 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1673 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1674 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1675 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1680 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1683 parse_threadlist_response (char *pkt
, int result_limit
,
1684 threadref
*original_echo
, threadref
*resultlist
,
1687 struct remote_state
*rs
= get_remote_state ();
1689 int count
, resultcount
, done
;
1692 /* Assume the 'q' and 'M chars have been stripped. */
1693 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1694 /* done parse past here */
1695 pkt
= unpack_byte (pkt
, &count
); /* count field */
1696 pkt
= unpack_nibble (pkt
, &done
);
1697 /* The first threadid is the argument threadid. */
1698 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1699 while ((count
-- > 0) && (pkt
< limit
))
1701 pkt
= unpack_threadid (pkt
, resultlist
++);
1702 if (resultcount
++ >= result_limit
)
1711 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1712 int *done
, int *result_count
, threadref
*threadlist
)
1714 struct remote_state
*rs
= get_remote_state ();
1715 static threadref echo_nextthread
;
1718 /* Trancate result limit to be smaller than the packet size. */
1719 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1720 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1722 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1724 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1727 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1730 if (!threadmatch (&echo_nextthread
, nextthread
))
1732 /* FIXME: This is a good reason to drop the packet. */
1733 /* Possably, there is a duplicate response. */
1735 retransmit immediatly - race conditions
1736 retransmit after timeout - yes
1738 wait for packet, then exit
1740 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1741 return 0; /* I choose simply exiting. */
1743 if (*result_count
<= 0)
1747 warning (_("RMT ERROR : failed to get remote thread list."));
1750 return result
; /* break; */
1752 if (*result_count
> result_limit
)
1755 warning (_("RMT ERROR: threadlist response longer than requested."));
1761 /* This is the interface between remote and threads, remotes upper
1764 /* remote_find_new_threads retrieves the thread list and for each
1765 thread in the list, looks up the thread in GDB's internal list,
1766 ading the thread if it does not already exist. This involves
1767 getting partial thread lists from the remote target so, polling the
1768 quit_flag is required. */
1771 /* About this many threadisds fit in a packet. */
1773 #define MAXTHREADLISTRESULTS 32
1776 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1779 int done
, i
, result_count
;
1783 static threadref nextthread
;
1784 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1789 if (loopcount
++ > looplimit
)
1792 warning (_("Remote fetch threadlist -infinite loop-."));
1795 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1796 &done
, &result_count
, resultthreadlist
))
1801 /* Clear for later iterations. */
1803 /* Setup to resume next batch of thread references, set nextthread. */
1804 if (result_count
>= 1)
1805 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1807 while (result_count
--)
1808 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1815 remote_newthread_step (threadref
*ref
, void *context
)
1819 ptid
= pid_to_ptid (threadref_to_int (ref
));
1821 if (!in_thread_list (ptid
))
1823 return 1; /* continue iterator */
1826 #define CRAZY_MAX_THREADS 1000
1829 remote_current_thread (ptid_t oldpid
)
1831 struct remote_state
*rs
= get_remote_state ();
1834 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1835 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1836 /* Use strtoul here, so we'll correctly parse values whose highest
1837 bit is set. The protocol carries them as a simple series of
1838 hex digits; in the absence of a sign, strtol will see such
1839 values as positive numbers out of range for signed 'long', and
1840 return LONG_MAX to indicate an overflow. */
1841 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1846 /* Find new threads for info threads command.
1847 * Original version, using John Metzler's thread protocol.
1851 remote_find_new_threads (void)
1853 remote_threadlist_iterator (remote_newthread_step
, 0,
1855 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1856 inferior_ptid
= remote_current_thread (inferior_ptid
);
1860 * Find all threads for info threads command.
1861 * Uses new thread protocol contributed by Cisco.
1862 * Falls back and attempts to use the older method (above)
1863 * if the target doesn't respond to the new method.
1867 remote_threads_info (void)
1869 struct remote_state
*rs
= get_remote_state ();
1873 if (remote_desc
== 0) /* paranoia */
1874 error (_("Command can only be used when connected to the remote target."));
1876 if (use_threadinfo_query
)
1878 putpkt ("qfThreadInfo");
1879 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1881 if (bufp
[0] != '\0') /* q packet recognized */
1883 while (*bufp
++ == 'm') /* reply contains one or more TID */
1887 /* Use strtoul here, so we'll correctly parse values
1888 whose highest bit is set. The protocol carries
1889 them as a simple series of hex digits; in the
1890 absence of a sign, strtol will see such values as
1891 positive numbers out of range for signed 'long',
1892 and return LONG_MAX to indicate an overflow. */
1893 tid
= strtoul (bufp
, &bufp
, 16);
1894 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1895 add_thread (pid_to_ptid (tid
));
1897 while (*bufp
++ == ','); /* comma-separated list */
1898 putpkt ("qsThreadInfo");
1899 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1906 /* Else fall back to old method based on jmetzler protocol. */
1907 use_threadinfo_query
= 0;
1908 remote_find_new_threads ();
1913 * Collect a descriptive string about the given thread.
1914 * The target may say anything it wants to about the thread
1915 * (typically info about its blocked / runnable state, name, etc.).
1916 * This string will appear in the info threads display.
1918 * Optional: targets are not required to implement this function.
1922 remote_threads_extra_info (struct thread_info
*tp
)
1924 struct remote_state
*rs
= get_remote_state ();
1928 struct gdb_ext_thread_info threadinfo
;
1929 static char display_buf
[100]; /* arbitrary... */
1930 int n
= 0; /* position in display_buf */
1932 if (remote_desc
== 0) /* paranoia */
1933 internal_error (__FILE__
, __LINE__
,
1934 _("remote_threads_extra_info"));
1936 if (use_threadextra_query
)
1938 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1941 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1942 if (rs
->buf
[0] != 0)
1944 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1945 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1946 display_buf
[result
] = '\0';
1951 /* If the above query fails, fall back to the old method. */
1952 use_threadextra_query
= 0;
1953 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1954 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1955 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1956 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1957 if (threadinfo
.active
)
1959 if (*threadinfo
.shortname
)
1960 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1961 " Name: %s,", threadinfo
.shortname
);
1962 if (*threadinfo
.display
)
1963 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1964 " State: %s,", threadinfo
.display
);
1965 if (*threadinfo
.more_display
)
1966 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1967 " Priority: %s", threadinfo
.more_display
);
1971 /* For purely cosmetic reasons, clear up trailing commas. */
1972 if (',' == display_buf
[n
-1])
1973 display_buf
[n
-1] = ' ';
1981 /* Restart the remote side; this is an extended protocol operation. */
1984 extended_remote_restart (void)
1986 struct remote_state
*rs
= get_remote_state ();
1988 /* Send the restart command; for reasons I don't understand the
1989 remote side really expects a number after the "R". */
1990 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1993 remote_fileio_reset ();
1995 /* Now query for status so this looks just like we restarted
1996 gdbserver from scratch. */
1998 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2001 /* Clean up connection to a remote debugger. */
2004 remote_close (int quitting
)
2007 serial_close (remote_desc
);
2011 /* Query the remote side for the text, data and bss offsets. */
2016 struct remote_state
*rs
= get_remote_state ();
2020 CORE_ADDR text_addr
, data_addr
, bss_addr
;
2021 struct section_offsets
*offs
;
2023 putpkt ("qOffsets");
2024 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2027 if (buf
[0] == '\000')
2028 return; /* Return silently. Stub doesn't support
2032 warning (_("Remote failure reply: %s"), buf
);
2036 /* Pick up each field in turn. This used to be done with scanf, but
2037 scanf will make trouble if CORE_ADDR size doesn't match
2038 conversion directives correctly. The following code will work
2039 with any size of CORE_ADDR. */
2040 text_addr
= data_addr
= bss_addr
= 0;
2044 if (strncmp (ptr
, "Text=", 5) == 0)
2047 /* Don't use strtol, could lose on big values. */
2048 while (*ptr
&& *ptr
!= ';')
2049 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2054 if (!lose
&& strncmp (ptr
, ";Data=", 6) == 0)
2057 while (*ptr
&& *ptr
!= ';')
2058 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2063 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2066 while (*ptr
&& *ptr
!= ';')
2067 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2073 error (_("Malformed response to offset query, %s"), buf
);
2075 if (symfile_objfile
== NULL
)
2078 offs
= ((struct section_offsets
*)
2079 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2080 memcpy (offs
, symfile_objfile
->section_offsets
,
2081 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2083 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2085 /* This is a temporary kludge to force data and bss to use the same offsets
2086 because that's what nlmconv does now. The real solution requires changes
2087 to the stub and remote.c that I don't have time to do right now. */
2089 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2090 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2092 objfile_relocate (symfile_objfile
, offs
);
2095 /* Stub for catch_exception. */
2098 remote_start_remote (struct ui_out
*uiout
, void *from_tty_p
)
2100 int from_tty
= * (int *) from_tty_p
;
2102 immediate_quit
++; /* Allow user to interrupt it. */
2104 /* Ack any packet which the remote side has already sent. */
2105 serial_write (remote_desc
, "+", 1);
2107 /* Let the stub know that we want it to return the thread. */
2110 inferior_ptid
= remote_current_thread (inferior_ptid
);
2112 get_offsets (); /* Get text, data & bss offsets. */
2114 putpkt ("?"); /* Initiate a query from remote machine. */
2117 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
2120 /* Open a connection to a remote debugger.
2121 NAME is the filename used for communication. */
2124 remote_open (char *name
, int from_tty
)
2126 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2129 /* Just like remote_open, but with asynchronous support. */
2131 remote_async_open (char *name
, int from_tty
)
2133 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2136 /* Open a connection to a remote debugger using the extended
2137 remote gdb protocol. NAME is the filename used for communication. */
2140 extended_remote_open (char *name
, int from_tty
)
2142 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2146 /* Just like extended_remote_open, but with asynchronous support. */
2148 extended_remote_async_open (char *name
, int from_tty
)
2150 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2151 1 /*extended_p */, 1 /* async_p */);
2154 /* Generic code for opening a connection to a remote target. */
2157 init_all_packet_configs (void)
2160 for (i
= 0; i
< PACKET_MAX
; i
++)
2161 update_packet_config (&remote_protocol_packets
[i
]);
2164 /* Symbol look-up. */
2167 remote_check_symbols (struct objfile
*objfile
)
2169 struct remote_state
*rs
= get_remote_state ();
2170 char *msg
, *reply
, *tmp
;
2171 struct minimal_symbol
*sym
;
2174 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2177 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2178 because we need both at the same time. */
2179 msg
= alloca (get_remote_packet_size ());
2181 /* Invite target to request symbol lookups. */
2183 putpkt ("qSymbol::");
2184 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2185 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2188 while (strncmp (reply
, "qSymbol:", 8) == 0)
2191 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2193 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2195 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2197 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2198 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2201 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2206 static struct serial
*
2207 remote_serial_open (char *name
)
2209 static int udp_warning
= 0;
2211 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2212 of in ser-tcp.c, because it is the remote protocol assuming that the
2213 serial connection is reliable and not the serial connection promising
2215 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2218 The remote protocol may be unreliable over UDP.\n\
2219 Some events may be lost, rendering further debugging impossible."));
2223 return serial_open (name
);
2226 /* This type describes each known response to the qSupported
2228 struct protocol_feature
2230 /* The name of this protocol feature. */
2233 /* The default for this protocol feature. */
2234 enum packet_support default_support
;
2236 /* The function to call when this feature is reported, or after
2237 qSupported processing if the feature is not supported.
2238 The first argument points to this structure. The second
2239 argument indicates whether the packet requested support be
2240 enabled, disabled, or probed (or the default, if this function
2241 is being called at the end of processing and this feature was
2242 not reported). The third argument may be NULL; if not NULL, it
2243 is a NUL-terminated string taken from the packet following
2244 this feature's name and an equals sign. */
2245 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2248 /* The corresponding packet for this feature. Only used if
2249 FUNC is remote_supported_packet. */
2254 remote_supported_packet (const struct protocol_feature
*feature
,
2255 enum packet_support support
,
2256 const char *argument
)
2260 warning (_("Remote qSupported response supplied an unexpected value for"
2261 " \"%s\"."), feature
->name
);
2265 if (remote_protocol_packets
[feature
->packet
].support
2266 == PACKET_SUPPORT_UNKNOWN
)
2267 remote_protocol_packets
[feature
->packet
].support
= support
;
2271 remote_packet_size (const struct protocol_feature
*feature
,
2272 enum packet_support support
, const char *value
)
2274 struct remote_state
*rs
= get_remote_state ();
2279 if (support
!= PACKET_ENABLE
)
2282 if (value
== NULL
|| *value
== '\0')
2284 warning (_("Remote target reported \"%s\" without a size."),
2290 packet_size
= strtol (value
, &value_end
, 16);
2291 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2293 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2294 feature
->name
, value
);
2298 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2300 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2301 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2302 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2305 /* Record the new maximum packet size. */
2306 rs
->explicit_packet_size
= packet_size
;
2309 static struct protocol_feature remote_protocol_features
[] = {
2310 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2311 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2312 PACKET_qXfer_auxv
},
2313 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2314 PACKET_qXfer_features
},
2315 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2316 PACKET_qXfer_memory_map
},
2317 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
2318 PACKET_qXfer_spu_read
},
2319 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
2320 PACKET_qXfer_spu_write
},
2321 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2322 PACKET_QPassSignals
},
2326 remote_query_supported (void)
2328 struct remote_state
*rs
= get_remote_state ();
2331 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2333 /* The packet support flags are handled differently for this packet
2334 than for most others. We treat an error, a disabled packet, and
2335 an empty response identically: any features which must be reported
2336 to be used will be automatically disabled. An empty buffer
2337 accomplishes this, since that is also the representation for a list
2338 containing no features. */
2341 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2343 putpkt ("qSupported");
2344 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2346 /* If an error occured, warn, but do not return - just reset the
2347 buffer to empty and go on to disable features. */
2348 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2351 warning (_("Remote failure reply: %s"), rs
->buf
);
2356 memset (seen
, 0, sizeof (seen
));
2361 enum packet_support is_supported
;
2362 char *p
, *end
, *name_end
, *value
;
2364 /* First separate out this item from the rest of the packet. If
2365 there's another item after this, we overwrite the separator
2366 (terminated strings are much easier to work with). */
2368 end
= strchr (p
, ';');
2371 end
= p
+ strlen (p
);
2381 warning (_("empty item in \"qSupported\" response"));
2386 name_end
= strchr (p
, '=');
2389 /* This is a name=value entry. */
2390 is_supported
= PACKET_ENABLE
;
2391 value
= name_end
+ 1;
2400 is_supported
= PACKET_ENABLE
;
2404 is_supported
= PACKET_DISABLE
;
2408 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2412 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2418 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2419 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2421 const struct protocol_feature
*feature
;
2424 feature
= &remote_protocol_features
[i
];
2425 feature
->func (feature
, is_supported
, value
);
2430 /* If we increased the packet size, make sure to increase the global
2431 buffer size also. We delay this until after parsing the entire
2432 qSupported packet, because this is the same buffer we were
2434 if (rs
->buf_size
< rs
->explicit_packet_size
)
2436 rs
->buf_size
= rs
->explicit_packet_size
;
2437 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2440 /* Handle the defaults for unmentioned features. */
2441 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2444 const struct protocol_feature
*feature
;
2446 feature
= &remote_protocol_features
[i
];
2447 feature
->func (feature
, feature
->default_support
, NULL
);
2453 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2454 int extended_p
, int async_p
)
2456 struct remote_state
*rs
= get_remote_state ();
2458 error (_("To open a remote debug connection, you need to specify what\n"
2459 "serial device is attached to the remote system\n"
2460 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2462 /* See FIXME above. */
2464 wait_forever_enabled_p
= 1;
2466 target_preopen (from_tty
);
2468 unpush_target (target
);
2470 /* Make sure we send the passed signals list the next time we resume. */
2471 xfree (last_pass_packet
);
2472 last_pass_packet
= NULL
;
2474 remote_fileio_reset ();
2475 reopen_exec_file ();
2478 remote_desc
= remote_serial_open (name
);
2480 perror_with_name (name
);
2482 if (baud_rate
!= -1)
2484 if (serial_setbaudrate (remote_desc
, baud_rate
))
2486 /* The requested speed could not be set. Error out to
2487 top level after closing remote_desc. Take care to
2488 set remote_desc to NULL to avoid closing remote_desc
2490 serial_close (remote_desc
);
2492 perror_with_name (name
);
2496 serial_raw (remote_desc
);
2498 /* If there is something sitting in the buffer we might take it as a
2499 response to a command, which would be bad. */
2500 serial_flush_input (remote_desc
);
2504 puts_filtered ("Remote debugging using ");
2505 puts_filtered (name
);
2506 puts_filtered ("\n");
2508 push_target (target
); /* Switch to using remote target now. */
2510 /* Reset the target state; these things will be queried either by
2511 remote_query_supported or as they are needed. */
2512 init_all_packet_configs ();
2513 rs
->explicit_packet_size
= 0;
2515 general_thread
= -2;
2516 continue_thread
= -2;
2518 /* Probe for ability to use "ThreadInfo" query, as required. */
2519 use_threadinfo_query
= 1;
2520 use_threadextra_query
= 1;
2522 /* The first packet we send to the target is the optional "supported
2523 packets" request. If the target can answer this, it will tell us
2524 which later probes to skip. */
2525 remote_query_supported ();
2527 /* Next, if the target can specify a description, read it. We do
2528 this before anything involving memory or registers. */
2529 target_find_description ();
2531 /* Without this, some commands which require an active target (such
2532 as kill) won't work. This variable serves (at least) double duty
2533 as both the pid of the target process (if it has such), and as a
2534 flag indicating that a target is active. These functions should
2535 be split out into seperate variables, especially since GDB will
2536 someday have a notion of debugging several processes. */
2538 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2542 /* With this target we start out by owning the terminal. */
2543 remote_async_terminal_ours_p
= 1;
2545 /* FIXME: cagney/1999-09-23: During the initial connection it is
2546 assumed that the target is already ready and able to respond to
2547 requests. Unfortunately remote_start_remote() eventually calls
2548 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2549 around this. Eventually a mechanism that allows
2550 wait_for_inferior() to expect/get timeouts will be
2552 wait_forever_enabled_p
= 0;
2555 /* First delete any symbols previously loaded from shared libraries. */
2556 no_shared_libraries (NULL
, 0);
2558 /* Start the remote connection. If error() or QUIT, discard this
2559 target (we'd otherwise be in an inconsistent state) and then
2560 propogate the error on up the exception chain. This ensures that
2561 the caller doesn't stumble along blindly assuming that the
2562 function succeeded. The CLI doesn't have this problem but other
2563 UI's, such as MI do.
2565 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2566 this function should return an error indication letting the
2567 caller restore the previous state. Unfortunately the command
2568 ``target remote'' is directly wired to this function making that
2569 impossible. On a positive note, the CLI side of this problem has
2570 been fixed - the function set_cmd_context() makes it possible for
2571 all the ``target ....'' commands to share a common callback
2572 function. See cli-dump.c. */
2574 struct gdb_exception ex
2575 = catch_exception (uiout
, remote_start_remote
, &from_tty
,
2581 wait_forever_enabled_p
= 1;
2582 throw_exception (ex
);
2587 wait_forever_enabled_p
= 1;
2591 /* Tell the remote that we are using the extended protocol. */
2593 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2596 if (exec_bfd
) /* No use without an exec file. */
2597 remote_check_symbols (symfile_objfile
);
2600 /* This takes a program previously attached to and detaches it. After
2601 this is done, GDB can be used to debug some other program. We
2602 better not have left any breakpoints in the target program or it'll
2603 die when it hits one. */
2606 remote_detach (char *args
, int from_tty
)
2608 struct remote_state
*rs
= get_remote_state ();
2611 error (_("Argument given to \"detach\" when remotely debugging."));
2613 /* Tell the remote target to detach. */
2614 strcpy (rs
->buf
, "D");
2616 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2618 if (rs
->buf
[0] == 'E')
2619 error (_("Can't detach process."));
2621 /* Unregister the file descriptor from the event loop. */
2622 if (target_is_async_p ())
2623 serial_async (remote_desc
, NULL
, 0);
2625 target_mourn_inferior ();
2627 puts_filtered ("Ending remote debugging.\n");
2630 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2633 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2636 error (_("Argument given to \"detach\" when remotely debugging."));
2638 /* Unregister the file descriptor from the event loop. */
2639 if (target_is_async_p ())
2640 serial_async (remote_desc
, NULL
, 0);
2642 target_mourn_inferior ();
2644 puts_filtered ("Ending remote debugging.\n");
2647 /* Convert hex digit A to a number. */
2652 if (a
>= '0' && a
<= '9')
2654 else if (a
>= 'a' && a
<= 'f')
2655 return a
- 'a' + 10;
2656 else if (a
>= 'A' && a
<= 'F')
2657 return a
- 'A' + 10;
2659 error (_("Reply contains invalid hex digit %d"), a
);
2663 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2667 for (i
= 0; i
< count
; i
++)
2669 if (hex
[0] == 0 || hex
[1] == 0)
2671 /* Hex string is short, or of uneven length.
2672 Return the count that has been converted so far. */
2675 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2681 /* Convert number NIB to a hex digit. */
2689 return 'a' + nib
- 10;
2693 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2696 /* May use a length, or a nul-terminated string as input. */
2698 count
= strlen ((char *) bin
);
2700 for (i
= 0; i
< count
; i
++)
2702 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2703 *hex
++ = tohex (*bin
++ & 0xf);
2709 /* Check for the availability of vCont. This function should also check
2713 remote_vcont_probe (struct remote_state
*rs
)
2717 strcpy (rs
->buf
, "vCont?");
2719 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2722 /* Make sure that the features we assume are supported. */
2723 if (strncmp (buf
, "vCont", 5) == 0)
2726 int support_s
, support_S
, support_c
, support_C
;
2732 while (p
&& *p
== ';')
2735 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2737 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2739 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2741 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2744 p
= strchr (p
, ';');
2747 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2748 BUF will make packet_ok disable the packet. */
2749 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2753 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2756 /* Resume the remote inferior by using a "vCont" packet. The thread
2757 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2758 resumed thread should be single-stepped and/or signalled. If PTID's
2759 PID is -1, then all threads are resumed; the thread to be stepped and/or
2760 signalled is given in the global INFERIOR_PTID. This function returns
2761 non-zero iff it resumes the inferior.
2763 This function issues a strict subset of all possible vCont commands at the
2767 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2769 struct remote_state
*rs
= get_remote_state ();
2770 int pid
= PIDGET (ptid
);
2771 char *buf
= NULL
, *outbuf
;
2772 struct cleanup
*old_cleanup
;
2774 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2775 remote_vcont_probe (rs
);
2777 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2780 /* If we could generate a wider range of packets, we'd have to worry
2781 about overflowing BUF. Should there be a generic
2782 "multi-part-packet" packet? */
2784 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2786 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2787 don't have any PID numbers the inferior will understand. Make sure
2788 to only send forms that do not specify a PID. */
2789 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2790 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2792 outbuf
= xstrprintf ("vCont;s");
2793 else if (siggnal
!= TARGET_SIGNAL_0
)
2794 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2796 outbuf
= xstrprintf ("vCont;c");
2800 /* Resume all threads, with preference for INFERIOR_PTID. */
2801 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2802 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2803 PIDGET (inferior_ptid
));
2805 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2806 else if (siggnal
!= TARGET_SIGNAL_0
)
2807 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2808 PIDGET (inferior_ptid
));
2810 outbuf
= xstrprintf ("vCont;c");
2814 /* Scheduler locking; resume only PTID. */
2815 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2816 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2818 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2819 else if (siggnal
!= TARGET_SIGNAL_0
)
2820 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2822 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2825 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2826 old_cleanup
= make_cleanup (xfree
, outbuf
);
2830 do_cleanups (old_cleanup
);
2835 /* Tell the remote machine to resume. */
2837 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2839 static int last_sent_step
;
2842 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2844 struct remote_state
*rs
= get_remote_state ();
2846 int pid
= PIDGET (ptid
);
2848 last_sent_signal
= siggnal
;
2849 last_sent_step
= step
;
2851 /* A hook for when we need to do something at the last moment before
2853 if (deprecated_target_resume_hook
)
2854 (*deprecated_target_resume_hook
) ();
2856 /* Update the inferior on signals to silently pass, if they've changed. */
2857 remote_pass_signals ();
2859 /* The vCont packet doesn't need to specify threads via Hc. */
2860 if (remote_vcont_resume (ptid
, step
, siggnal
))
2863 /* All other supported resume packets do use Hc, so call set_thread. */
2865 set_thread (0, 0); /* Run any thread. */
2867 set_thread (pid
, 0); /* Run this thread. */
2870 if (siggnal
!= TARGET_SIGNAL_0
)
2872 buf
[0] = step
? 'S' : 'C';
2873 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2874 buf
[2] = tohex (((int) siggnal
) & 0xf);
2878 strcpy (buf
, step
? "s" : "c");
2883 /* Same as remote_resume, but with async support. */
2885 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2887 remote_resume (ptid
, step
, siggnal
);
2889 /* We are about to start executing the inferior, let's register it
2890 with the event loop. NOTE: this is the one place where all the
2891 execution commands end up. We could alternatively do this in each
2892 of the execution commands in infcmd.c. */
2893 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2894 into infcmd.c in order to allow inferior function calls to work
2895 NOT asynchronously. */
2896 if (target_can_async_p ())
2897 target_async (inferior_event_handler
, 0);
2898 /* Tell the world that the target is now executing. */
2899 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2900 this? Instead, should the client of target just assume (for
2901 async targets) that the target is going to start executing? Is
2902 this information already found in the continuation block? */
2903 if (target_is_async_p ())
2904 target_executing
= 1;
2908 /* Set up the signal handler for SIGINT, while the target is
2909 executing, ovewriting the 'regular' SIGINT signal handler. */
2911 initialize_sigint_signal_handler (void)
2913 sigint_remote_token
=
2914 create_async_signal_handler (async_remote_interrupt
, NULL
);
2915 signal (SIGINT
, handle_remote_sigint
);
2918 /* Signal handler for SIGINT, while the target is executing. */
2920 handle_remote_sigint (int sig
)
2922 signal (sig
, handle_remote_sigint_twice
);
2923 sigint_remote_twice_token
=
2924 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2925 mark_async_signal_handler_wrapper (sigint_remote_token
);
2928 /* Signal handler for SIGINT, installed after SIGINT has already been
2929 sent once. It will take effect the second time that the user sends
2932 handle_remote_sigint_twice (int sig
)
2934 signal (sig
, handle_sigint
);
2935 sigint_remote_twice_token
=
2936 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
2937 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
2940 /* Perform the real interruption of the target execution, in response
2943 async_remote_interrupt (gdb_client_data arg
)
2946 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2951 /* Perform interrupt, if the first attempt did not succeed. Just give
2952 up on the target alltogether. */
2954 async_remote_interrupt_twice (gdb_client_data arg
)
2957 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
2958 /* Do something only if the target was not killed by the previous
2960 if (target_executing
)
2963 signal (SIGINT
, handle_remote_sigint
);
2967 /* Reinstall the usual SIGINT handlers, after the target has
2970 cleanup_sigint_signal_handler (void *dummy
)
2972 signal (SIGINT
, handle_sigint
);
2973 if (sigint_remote_twice_token
)
2974 delete_async_signal_handler (&sigint_remote_twice_token
);
2975 if (sigint_remote_token
)
2976 delete_async_signal_handler (&sigint_remote_token
);
2979 /* Send ^C to target to halt it. Target will respond, and send us a
2981 static void (*ofunc
) (int);
2983 /* The command line interface's stop routine. This function is installed
2984 as a signal handler for SIGINT. The first time a user requests a
2985 stop, we call remote_stop to send a break or ^C. If there is no
2986 response from the target (it didn't stop when the user requested it),
2987 we ask the user if he'd like to detach from the target. */
2989 remote_interrupt (int signo
)
2991 /* If this doesn't work, try more severe steps. */
2992 signal (signo
, remote_interrupt_twice
);
2995 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3000 /* The user typed ^C twice. */
3003 remote_interrupt_twice (int signo
)
3005 signal (signo
, ofunc
);
3007 signal (signo
, remote_interrupt
);
3010 /* This is the generic stop called via the target vector. When a target
3011 interrupt is requested, either by the command line or the GUI, we
3012 will eventually end up here. */
3016 /* Send a break or a ^C, depending on user preference. */
3018 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
3021 serial_send_break (remote_desc
);
3023 serial_write (remote_desc
, "\003", 1);
3026 /* Ask the user what to do when an interrupt is received. */
3029 interrupt_query (void)
3031 target_terminal_ours ();
3033 if (query ("Interrupted while waiting for the program.\n\
3034 Give up (and stop debugging it)? "))
3036 target_mourn_inferior ();
3037 deprecated_throw_reason (RETURN_QUIT
);
3040 target_terminal_inferior ();
3043 /* Enable/disable target terminal ownership. Most targets can use
3044 terminal groups to control terminal ownership. Remote targets are
3045 different in that explicit transfer of ownership to/from GDB/target
3049 remote_async_terminal_inferior (void)
3051 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3052 sync_execution here. This function should only be called when
3053 GDB is resuming the inferior in the forground. A background
3054 resume (``run&'') should leave GDB in control of the terminal and
3055 consequently should not call this code. */
3056 if (!sync_execution
)
3058 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3059 calls target_terminal_*() idenpotent. The event-loop GDB talking
3060 to an asynchronous target with a synchronous command calls this
3061 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3062 stops trying to transfer the terminal to the target when it
3063 shouldn't this guard can go away. */
3064 if (!remote_async_terminal_ours_p
)
3066 delete_file_handler (input_fd
);
3067 remote_async_terminal_ours_p
= 0;
3068 initialize_sigint_signal_handler ();
3069 /* NOTE: At this point we could also register our selves as the
3070 recipient of all input. Any characters typed could then be
3071 passed on down to the target. */
3075 remote_async_terminal_ours (void)
3077 /* See FIXME in remote_async_terminal_inferior. */
3078 if (!sync_execution
)
3080 /* See FIXME in remote_async_terminal_inferior. */
3081 if (remote_async_terminal_ours_p
)
3083 cleanup_sigint_signal_handler (NULL
);
3084 add_file_handler (input_fd
, stdin_event_handler
, 0);
3085 remote_async_terminal_ours_p
= 1;
3088 /* If nonzero, ignore the next kill. */
3093 remote_console_output (char *msg
)
3097 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3100 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3103 fputs_unfiltered (tb
, gdb_stdtarg
);
3105 gdb_flush (gdb_stdtarg
);
3108 /* Wait until the remote machine stops, then return,
3109 storing status in STATUS just as `wait' would.
3110 Returns "pid", which in the case of a multi-threaded
3111 remote OS, is the thread-id. */
3114 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3116 struct remote_state
*rs
= get_remote_state ();
3117 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3118 ULONGEST thread_num
= -1;
3121 status
->kind
= TARGET_WAITKIND_EXITED
;
3122 status
->value
.integer
= 0;
3128 ofunc
= signal (SIGINT
, remote_interrupt
);
3129 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3130 signal (SIGINT
, ofunc
);
3134 /* This is a hook for when we need to do something (perhaps the
3135 collection of trace data) every time the target stops. */
3136 if (deprecated_target_wait_loop_hook
)
3137 (*deprecated_target_wait_loop_hook
) ();
3139 remote_stopped_by_watchpoint_p
= 0;
3143 case 'E': /* Error of some sort. */
3144 warning (_("Remote failure reply: %s"), buf
);
3146 case 'F': /* File-I/O request. */
3147 remote_fileio_request (buf
);
3149 case 'T': /* Status with PC, SP, FP, ... */
3151 gdb_byte regs
[MAX_REGISTER_SIZE
];
3153 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3154 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3156 n... = register number
3157 r... = register contents
3159 p
= &buf
[3]; /* after Txx */
3168 /* If the packet contains a register number save it in
3169 pnum and set p1 to point to the character following
3170 it. Otherwise p1 points to p. */
3172 /* If this packet is an awatch packet, don't parse the
3173 'a' as a register number. */
3175 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3177 /* Read the ``P'' register number. */
3178 pnum
= strtol (p
, &p_temp
, 16);
3184 if (p1
== p
) /* No register number present here. */
3186 p1
= strchr (p
, ':');
3188 error (_("Malformed packet(a) (missing colon): %s\n\
3191 if (strncmp (p
, "thread", p1
- p
) == 0)
3193 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3194 record_currthread (thread_num
);
3197 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3198 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3199 || (strncmp (p
, "awatch", p1
- p
) == 0))
3201 remote_stopped_by_watchpoint_p
= 1;
3202 p
= unpack_varlen_hex (++p1
, &addr
);
3203 remote_watch_data_address
= (CORE_ADDR
)addr
;
3207 /* Silently skip unknown optional info. */
3208 p_temp
= strchr (p1
+ 1, ';');
3215 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3219 error (_("Malformed packet(b) (missing colon): %s\n\
3224 error (_("Remote sent bad register number %s: %s\n\
3226 phex_nz (pnum
, 0), p
, buf
);
3228 fieldsize
= hex2bin (p
, regs
,
3229 register_size (current_gdbarch
,
3232 if (fieldsize
< register_size (current_gdbarch
,
3234 warning (_("Remote reply is too short: %s"), buf
);
3235 regcache_raw_supply (current_regcache
,
3240 error (_("Remote register badly formatted: %s\nhere: %s"),
3245 case 'S': /* Old style status, just signal only. */
3246 status
->kind
= TARGET_WAITKIND_STOPPED
;
3247 status
->value
.sig
= (enum target_signal
)
3248 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3252 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3253 record_currthread (thread_num
);
3256 case 'W': /* Target exited. */
3258 /* The remote process exited. */
3259 status
->kind
= TARGET_WAITKIND_EXITED
;
3260 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3264 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3265 status
->value
.sig
= (enum target_signal
)
3266 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3270 case 'O': /* Console output. */
3271 remote_console_output (buf
+ 1);
3274 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3276 /* Zero length reply means that we tried 'S' or 'C' and
3277 the remote system doesn't support it. */
3278 target_terminal_ours_for_output ();
3280 ("Can't send signals to this remote system. %s not sent.\n",
3281 target_signal_to_name (last_sent_signal
));
3282 last_sent_signal
= TARGET_SIGNAL_0
;
3283 target_terminal_inferior ();
3285 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3286 putpkt ((char *) buf
);
3289 /* else fallthrough */
3291 warning (_("Invalid remote reply: %s"), buf
);
3296 if (thread_num
!= -1)
3298 return pid_to_ptid (thread_num
);
3300 return inferior_ptid
;
3303 /* Async version of remote_wait. */
3305 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3307 struct remote_state
*rs
= get_remote_state ();
3308 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3309 ULONGEST thread_num
= -1;
3312 status
->kind
= TARGET_WAITKIND_EXITED
;
3313 status
->value
.integer
= 0;
3315 remote_stopped_by_watchpoint_p
= 0;
3321 if (!target_is_async_p ())
3322 ofunc
= signal (SIGINT
, remote_interrupt
);
3323 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3324 _never_ wait for ever -> test on target_is_async_p().
3325 However, before we do that we need to ensure that the caller
3326 knows how to take the target into/out of async mode. */
3327 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3328 if (!target_is_async_p ())
3329 signal (SIGINT
, ofunc
);
3333 /* This is a hook for when we need to do something (perhaps the
3334 collection of trace data) every time the target stops. */
3335 if (deprecated_target_wait_loop_hook
)
3336 (*deprecated_target_wait_loop_hook
) ();
3340 case 'E': /* Error of some sort. */
3341 warning (_("Remote failure reply: %s"), buf
);
3343 case 'F': /* File-I/O request. */
3344 remote_fileio_request (buf
);
3346 case 'T': /* Status with PC, SP, FP, ... */
3348 gdb_byte regs
[MAX_REGISTER_SIZE
];
3350 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3351 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3353 n... = register number
3354 r... = register contents
3356 p
= &buf
[3]; /* after Txx */
3365 /* If the packet contains a register number, save it
3366 in pnum and set p1 to point to the character
3367 following it. Otherwise p1 points to p. */
3369 /* If this packet is an awatch packet, don't parse the 'a'
3370 as a register number. */
3372 if (!strncmp (p
, "awatch", strlen ("awatch")) != 0)
3374 /* Read the register number. */
3375 pnum
= strtol (p
, &p_temp
, 16);
3381 if (p1
== p
) /* No register number present here. */
3383 p1
= strchr (p
, ':');
3385 error (_("Malformed packet(a) (missing colon): %s\n\
3388 if (strncmp (p
, "thread", p1
- p
) == 0)
3390 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3391 record_currthread (thread_num
);
3394 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3395 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3396 || (strncmp (p
, "awatch", p1
- p
) == 0))
3398 remote_stopped_by_watchpoint_p
= 1;
3399 p
= unpack_varlen_hex (++p1
, &addr
);
3400 remote_watch_data_address
= (CORE_ADDR
)addr
;
3404 /* Silently skip unknown optional info. */
3405 p_temp
= strchr (p1
+ 1, ';');
3413 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3416 error (_("Malformed packet(b) (missing colon): %s\n\
3421 error (_("Remote sent bad register number %ld: %s\n\
3425 fieldsize
= hex2bin (p
, regs
,
3426 register_size (current_gdbarch
,
3429 if (fieldsize
< register_size (current_gdbarch
,
3431 warning (_("Remote reply is too short: %s"), buf
);
3432 regcache_raw_supply (current_regcache
, reg
->regnum
, regs
);
3436 error (_("Remote register badly formatted: %s\nhere: %s"),
3441 case 'S': /* Old style status, just signal only. */
3442 status
->kind
= TARGET_WAITKIND_STOPPED
;
3443 status
->value
.sig
= (enum target_signal
)
3444 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3448 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3449 record_currthread (thread_num
);
3452 case 'W': /* Target exited. */
3454 /* The remote process exited. */
3455 status
->kind
= TARGET_WAITKIND_EXITED
;
3456 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3460 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3461 status
->value
.sig
= (enum target_signal
)
3462 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3466 case 'O': /* Console output. */
3467 remote_console_output (buf
+ 1);
3468 /* Return immediately to the event loop. The event loop will
3469 still be waiting on the inferior afterwards. */
3470 status
->kind
= TARGET_WAITKIND_IGNORE
;
3473 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3475 /* Zero length reply means that we tried 'S' or 'C' and
3476 the remote system doesn't support it. */
3477 target_terminal_ours_for_output ();
3479 ("Can't send signals to this remote system. %s not sent.\n",
3480 target_signal_to_name (last_sent_signal
));
3481 last_sent_signal
= TARGET_SIGNAL_0
;
3482 target_terminal_inferior ();
3484 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3485 putpkt ((char *) buf
);
3488 /* else fallthrough */
3490 warning (_("Invalid remote reply: %s"), buf
);
3495 if (thread_num
!= -1)
3497 return pid_to_ptid (thread_num
);
3499 return inferior_ptid
;
3502 /* Fetch a single register using a 'p' packet. */
3505 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3507 struct remote_state
*rs
= get_remote_state ();
3509 char regp
[MAX_REGISTER_SIZE
];
3512 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3515 if (reg
->pnum
== -1)
3520 p
+= hexnumstr (p
, reg
->pnum
);
3522 remote_send (&rs
->buf
, &rs
->buf_size
);
3526 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3530 case PACKET_UNKNOWN
:
3533 error (_("Could not fetch register \"%s\""),
3534 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3537 /* If this register is unfetchable, tell the regcache. */
3540 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3544 /* Otherwise, parse and supply the value. */
3550 error (_("fetch_register_using_p: early buf termination"));
3552 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3555 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3559 /* Fetch the registers included in the target's 'g' packet. */
3562 send_g_packet (void)
3564 struct remote_state
*rs
= get_remote_state ();
3569 sprintf (rs
->buf
, "g");
3570 remote_send (&rs
->buf
, &rs
->buf_size
);
3572 /* We can get out of synch in various cases. If the first character
3573 in the buffer is not a hex character, assume that has happened
3574 and try to fetch another packet to read. */
3575 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3576 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3577 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3578 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3581 fprintf_unfiltered (gdb_stdlog
,
3582 "Bad register packet; fetching a new packet\n");
3583 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3586 buf_len
= strlen (rs
->buf
);
3588 /* Sanity check the received packet. */
3589 if (buf_len
% 2 != 0)
3590 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3596 process_g_packet (struct regcache
*regcache
)
3598 struct remote_state
*rs
= get_remote_state ();
3599 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3604 buf_len
= strlen (rs
->buf
);
3606 /* Further sanity checks, with knowledge of the architecture. */
3607 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3608 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3610 /* Save the size of the packet sent to us by the target. It is used
3611 as a heuristic when determining the max size of packets that the
3612 target can safely receive. */
3613 if (rsa
->actual_register_packet_size
== 0)
3614 rsa
->actual_register_packet_size
= buf_len
;
3616 /* If this is smaller than we guessed the 'g' packet would be,
3617 update our records. A 'g' reply that doesn't include a register's
3618 value implies either that the register is not available, or that
3619 the 'p' packet must be used. */
3620 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3622 rsa
->sizeof_g_packet
= buf_len
/ 2;
3624 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3626 if (rsa
->regs
[i
].pnum
== -1)
3629 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3630 rsa
->regs
[i
].in_g_packet
= 0;
3632 rsa
->regs
[i
].in_g_packet
= 1;
3636 regs
= alloca (rsa
->sizeof_g_packet
);
3638 /* Unimplemented registers read as all bits zero. */
3639 memset (regs
, 0, rsa
->sizeof_g_packet
);
3641 /* Reply describes registers byte by byte, each byte encoded as two
3642 hex characters. Suck them all up, then supply them to the
3643 register cacheing/storage mechanism. */
3646 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3648 if (p
[0] == 0 || p
[1] == 0)
3649 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3650 internal_error (__FILE__
, __LINE__
,
3651 "unexpected end of 'g' packet reply");
3653 if (p
[0] == 'x' && p
[1] == 'x')
3654 regs
[i
] = 0; /* 'x' */
3656 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3662 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3664 struct packet_reg
*r
= &rsa
->regs
[i
];
3667 if (r
->offset
* 2 >= strlen (rs
->buf
))
3668 /* This shouldn't happen - we adjusted in_g_packet above. */
3669 internal_error (__FILE__
, __LINE__
,
3670 "unexpected end of 'g' packet reply");
3671 else if (rs
->buf
[r
->offset
* 2] == 'x')
3673 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3674 /* The register isn't available, mark it as such (at
3675 the same time setting the value to zero). */
3676 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3679 regcache_raw_supply (regcache
, r
->regnum
,
3687 fetch_registers_using_g (struct regcache
*regcache
)
3690 process_g_packet (regcache
);
3694 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3696 struct remote_state
*rs
= get_remote_state ();
3697 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3700 set_thread (PIDGET (inferior_ptid
), 1);
3704 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3705 gdb_assert (reg
!= NULL
);
3707 /* If this register might be in the 'g' packet, try that first -
3708 we are likely to read more than one register. If this is the
3709 first 'g' packet, we might be overly optimistic about its
3710 contents, so fall back to 'p'. */
3711 if (reg
->in_g_packet
)
3713 fetch_registers_using_g (regcache
);
3714 if (reg
->in_g_packet
)
3718 if (fetch_register_using_p (regcache
, reg
))
3721 /* This register is not available. */
3722 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3727 fetch_registers_using_g (regcache
);
3729 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3730 if (!rsa
->regs
[i
].in_g_packet
)
3731 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3733 /* This register is not available. */
3734 regcache_raw_supply (regcache
, i
, NULL
);
3738 /* Prepare to store registers. Since we may send them all (using a
3739 'G' request), we have to read out the ones we don't want to change
3743 remote_prepare_to_store (struct regcache
*regcache
)
3745 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3747 gdb_byte buf
[MAX_REGISTER_SIZE
];
3749 /* Make sure the entire registers array is valid. */
3750 switch (remote_protocol_packets
[PACKET_P
].support
)
3752 case PACKET_DISABLE
:
3753 case PACKET_SUPPORT_UNKNOWN
:
3754 /* Make sure all the necessary registers are cached. */
3755 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3756 if (rsa
->regs
[i
].in_g_packet
)
3757 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3764 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3765 packet was not recognized. */
3768 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3770 struct remote_state
*rs
= get_remote_state ();
3771 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3772 /* Try storing a single register. */
3773 char *buf
= rs
->buf
;
3774 gdb_byte regp
[MAX_REGISTER_SIZE
];
3777 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3780 if (reg
->pnum
== -1)
3783 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3784 p
= buf
+ strlen (buf
);
3785 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3786 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3787 remote_send (&rs
->buf
, &rs
->buf_size
);
3789 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3794 error (_("Could not write register \"%s\""),
3795 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3796 case PACKET_UNKNOWN
:
3799 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3803 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3804 contents of the register cache buffer. FIXME: ignores errors. */
3807 store_registers_using_G (const struct regcache
*regcache
)
3809 struct remote_state
*rs
= get_remote_state ();
3810 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3814 /* Extract all the registers in the regcache copying them into a
3818 regs
= alloca (rsa
->sizeof_g_packet
);
3819 memset (regs
, 0, rsa
->sizeof_g_packet
);
3820 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3822 struct packet_reg
*r
= &rsa
->regs
[i
];
3824 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3828 /* Command describes registers byte by byte,
3829 each byte encoded as two hex characters. */
3832 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3834 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3835 remote_send (&rs
->buf
, &rs
->buf_size
);
3838 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3839 of the register cache buffer. FIXME: ignores errors. */
3842 remote_store_registers (struct regcache
*regcache
, int regnum
)
3844 struct remote_state
*rs
= get_remote_state ();
3845 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3848 set_thread (PIDGET (inferior_ptid
), 1);
3852 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3853 gdb_assert (reg
!= NULL
);
3855 /* Always prefer to store registers using the 'P' packet if
3856 possible; we often change only a small number of registers.
3857 Sometimes we change a larger number; we'd need help from a
3858 higher layer to know to use 'G'. */
3859 if (store_register_using_P (regcache
, reg
))
3862 /* For now, don't complain if we have no way to write the
3863 register. GDB loses track of unavailable registers too
3864 easily. Some day, this may be an error. We don't have
3865 any way to read the register, either... */
3866 if (!reg
->in_g_packet
)
3869 store_registers_using_G (regcache
);
3873 store_registers_using_G (regcache
);
3875 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3876 if (!rsa
->regs
[i
].in_g_packet
)
3877 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
3878 /* See above for why we do not issue an error here. */
3883 /* Return the number of hex digits in num. */
3886 hexnumlen (ULONGEST num
)
3890 for (i
= 0; num
!= 0; i
++)
3896 /* Set BUF to the minimum number of hex digits representing NUM. */
3899 hexnumstr (char *buf
, ULONGEST num
)
3901 int len
= hexnumlen (num
);
3902 return hexnumnstr (buf
, num
, len
);
3906 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3909 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3915 for (i
= width
- 1; i
>= 0; i
--)
3917 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3924 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3927 remote_address_masked (CORE_ADDR addr
)
3929 if (remote_address_size
> 0
3930 && remote_address_size
< (sizeof (ULONGEST
) * 8))
3932 /* Only create a mask when that mask can safely be constructed
3933 in a ULONGEST variable. */
3935 mask
= (mask
<< remote_address_size
) - 1;
3941 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
3942 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
3943 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
3944 (which may be more than *OUT_LEN due to escape characters). The
3945 total number of bytes in the output buffer will be at most
3949 remote_escape_output (const gdb_byte
*buffer
, int len
,
3950 gdb_byte
*out_buf
, int *out_len
,
3953 int input_index
, output_index
;
3956 for (input_index
= 0; input_index
< len
; input_index
++)
3958 gdb_byte b
= buffer
[input_index
];
3960 if (b
== '$' || b
== '#' || b
== '}')
3962 /* These must be escaped. */
3963 if (output_index
+ 2 > out_maxlen
)
3965 out_buf
[output_index
++] = '}';
3966 out_buf
[output_index
++] = b
^ 0x20;
3970 if (output_index
+ 1 > out_maxlen
)
3972 out_buf
[output_index
++] = b
;
3976 *out_len
= input_index
;
3977 return output_index
;
3980 /* Convert BUFFER, escaped data LEN bytes long, into binary data
3981 in OUT_BUF. Return the number of bytes written to OUT_BUF.
3982 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
3984 This function reverses remote_escape_output. It allows more
3985 escaped characters than that function does, in particular because
3986 '*' must be escaped to avoid the run-length encoding processing
3987 in reading packets. */
3990 remote_unescape_input (const gdb_byte
*buffer
, int len
,
3991 gdb_byte
*out_buf
, int out_maxlen
)
3993 int input_index
, output_index
;
3998 for (input_index
= 0; input_index
< len
; input_index
++)
4000 gdb_byte b
= buffer
[input_index
];
4002 if (output_index
+ 1 > out_maxlen
)
4004 warning (_("Received too much data from remote target;"
4005 " ignoring overflow."));
4006 return output_index
;
4011 out_buf
[output_index
++] = b
^ 0x20;
4017 out_buf
[output_index
++] = b
;
4021 error (_("Unmatched escape character in target response."));
4023 return output_index
;
4026 /* Determine whether the remote target supports binary downloading.
4027 This is accomplished by sending a no-op memory write of zero length
4028 to the target at the specified address. It does not suffice to send
4029 the whole packet, since many stubs strip the eighth bit and
4030 subsequently compute a wrong checksum, which causes real havoc with
4033 NOTE: This can still lose if the serial line is not eight-bit
4034 clean. In cases like this, the user should clear "remote
4038 check_binary_download (CORE_ADDR addr
)
4040 struct remote_state
*rs
= get_remote_state ();
4042 switch (remote_protocol_packets
[PACKET_X
].support
)
4044 case PACKET_DISABLE
:
4048 case PACKET_SUPPORT_UNKNOWN
:
4054 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4056 p
+= hexnumstr (p
, (ULONGEST
) 0);
4060 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4061 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4063 if (rs
->buf
[0] == '\0')
4066 fprintf_unfiltered (gdb_stdlog
,
4067 "binary downloading NOT suppported by target\n");
4068 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4073 fprintf_unfiltered (gdb_stdlog
,
4074 "binary downloading suppported by target\n");
4075 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4082 /* Write memory data directly to the remote machine.
4083 This does not inform the data cache; the data cache uses this.
4084 HEADER is the starting part of the packet.
4085 MEMADDR is the address in the remote memory space.
4086 MYADDR is the address of the buffer in our space.
4087 LEN is the number of bytes.
4088 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4089 should send data as binary ('X'), or hex-encoded ('M').
4091 The function creates packet of the form
4092 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4094 where encoding of <DATA> is termined by PACKET_FORMAT.
4096 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4099 Returns the number of bytes transferred, or 0 (setting errno) for
4100 error. Only transfer a single packet. */
4103 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4104 const gdb_byte
*myaddr
, int len
,
4105 char packet_format
, int use_length
)
4107 struct remote_state
*rs
= get_remote_state ();
4117 if (packet_format
!= 'X' && packet_format
!= 'M')
4118 internal_error (__FILE__
, __LINE__
,
4119 "remote_write_bytes_aux: bad packet format");
4124 payload_size
= get_memory_write_packet_size ();
4126 /* The packet buffer will be large enough for the payload;
4127 get_memory_packet_size ensures this. */
4130 /* Compute the size of the actual payload by subtracting out the
4131 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4133 payload_size
-= strlen ("$,:#NN");
4135 /* The comma won't be used. */
4137 header_length
= strlen (header
);
4138 payload_size
-= header_length
;
4139 payload_size
-= hexnumlen (memaddr
);
4141 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4143 strcat (rs
->buf
, header
);
4144 p
= rs
->buf
+ strlen (header
);
4146 /* Compute a best guess of the number of bytes actually transfered. */
4147 if (packet_format
== 'X')
4149 /* Best guess at number of bytes that will fit. */
4150 todo
= min (len
, payload_size
);
4152 payload_size
-= hexnumlen (todo
);
4153 todo
= min (todo
, payload_size
);
4157 /* Num bytes that will fit. */
4158 todo
= min (len
, payload_size
/ 2);
4160 payload_size
-= hexnumlen (todo
);
4161 todo
= min (todo
, payload_size
/ 2);
4165 internal_error (__FILE__
, __LINE__
,
4166 _("minumum packet size too small to write data"));
4168 /* If we already need another packet, then try to align the end
4169 of this packet to a useful boundary. */
4170 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4171 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4173 /* Append "<memaddr>". */
4174 memaddr
= remote_address_masked (memaddr
);
4175 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4182 /* Append <len>. Retain the location/size of <len>. It may need to
4183 be adjusted once the packet body has been created. */
4185 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4193 /* Append the packet body. */
4194 if (packet_format
== 'X')
4196 /* Binary mode. Send target system values byte by byte, in
4197 increasing byte addresses. Only escape certain critical
4199 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4202 /* If not all TODO bytes fit, then we'll need another packet. Make
4203 a second try to keep the end of the packet aligned. Don't do
4204 this if the packet is tiny. */
4205 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4209 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4211 if (new_nr_bytes
!= nr_bytes
)
4212 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4217 p
+= payload_length
;
4218 if (use_length
&& nr_bytes
< todo
)
4220 /* Escape chars have filled up the buffer prematurely,
4221 and we have actually sent fewer bytes than planned.
4222 Fix-up the length field of the packet. Use the same
4223 number of characters as before. */
4224 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4225 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4230 /* Normal mode: Send target system values byte by byte, in
4231 increasing byte addresses. Each byte is encoded as a two hex
4233 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4237 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4238 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4240 if (rs
->buf
[0] == 'E')
4242 /* There is no correspondance between what the remote protocol
4243 uses for errors and errno codes. We would like a cleaner way
4244 of representing errors (big enough to include errno codes,
4245 bfd_error codes, and others). But for now just return EIO. */
4250 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4251 fewer bytes than we'd planned. */
4255 /* Write memory data directly to the remote machine.
4256 This does not inform the data cache; the data cache uses this.
4257 MEMADDR is the address in the remote memory space.
4258 MYADDR is the address of the buffer in our space.
4259 LEN is the number of bytes.
4261 Returns number of bytes transferred, or 0 (setting errno) for
4262 error. Only transfer a single packet. */
4265 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4267 char *packet_format
= 0;
4269 /* Check whether the target supports binary download. */
4270 check_binary_download (memaddr
);
4272 switch (remote_protocol_packets
[PACKET_X
].support
)
4275 packet_format
= "X";
4277 case PACKET_DISABLE
:
4278 packet_format
= "M";
4280 case PACKET_SUPPORT_UNKNOWN
:
4281 internal_error (__FILE__
, __LINE__
,
4282 _("remote_write_bytes: bad internal state"));
4284 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4287 return remote_write_bytes_aux (packet_format
,
4288 memaddr
, myaddr
, len
, packet_format
[0], 1);
4291 /* Read memory data directly from the remote machine.
4292 This does not use the data cache; the data cache uses this.
4293 MEMADDR is the address in the remote memory space.
4294 MYADDR is the address of the buffer in our space.
4295 LEN is the number of bytes.
4297 Returns number of bytes transferred, or 0 for error. */
4299 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4300 remote targets) shouldn't attempt to read the entire buffer.
4301 Instead it should read a single packet worth of data and then
4302 return the byte size of that packet to the caller. The caller (its
4303 caller and its callers caller ;-) already contains code for
4304 handling partial reads. */
4307 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4309 struct remote_state
*rs
= get_remote_state ();
4310 int max_buf_size
; /* Max size of packet output buffer. */
4316 max_buf_size
= get_memory_read_packet_size ();
4317 /* The packet buffer will be large enough for the payload;
4318 get_memory_packet_size ensures this. */
4327 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4329 /* construct "m"<memaddr>","<len>" */
4330 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4331 memaddr
= remote_address_masked (memaddr
);
4334 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4336 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4340 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4342 if (rs
->buf
[0] == 'E'
4343 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4344 && rs
->buf
[3] == '\0')
4346 /* There is no correspondance between what the remote
4347 protocol uses for errors and errno codes. We would like
4348 a cleaner way of representing errors (big enough to
4349 include errno codes, bfd_error codes, and others). But
4350 for now just return EIO. */
4355 /* Reply describes memory byte by byte,
4356 each byte encoded as two hex characters. */
4359 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4361 /* Reply is short. This means that we were able to read
4362 only part of what we wanted to. */
4363 return i
+ (origlen
- len
);
4372 /* Read or write LEN bytes from inferior memory at MEMADDR,
4373 transferring to or from debugger address BUFFER. Write to inferior
4374 if SHOULD_WRITE is nonzero. Returns length of data written or
4375 read; 0 for error. TARGET is unused. */
4378 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4379 int should_write
, struct mem_attrib
*attrib
,
4380 struct target_ops
*target
)
4385 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4387 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4392 /* Sends a packet with content determined by the printf format string
4393 FORMAT and the remaining arguments, then gets the reply. Returns
4394 whether the packet was a success, a failure, or unknown. */
4397 remote_send_printf (const char *format
, ...)
4399 struct remote_state
*rs
= get_remote_state ();
4400 int max_size
= get_remote_packet_size ();
4403 va_start (ap
, format
);
4406 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4407 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4409 if (putpkt (rs
->buf
) < 0)
4410 error (_("Communication problem with target."));
4413 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4415 return packet_check_result (rs
->buf
);
4419 restore_remote_timeout (void *p
)
4421 int value
= *(int *)p
;
4422 remote_timeout
= value
;
4425 /* Flash writing can take quite some time. We'll set
4426 effectively infinite timeout for flash operations.
4427 In future, we'll need to decide on a better approach. */
4428 static const int remote_flash_timeout
= 1000;
4431 remote_flash_erase (struct target_ops
*ops
,
4432 ULONGEST address
, LONGEST length
)
4434 int saved_remote_timeout
= remote_timeout
;
4435 enum packet_result ret
;
4437 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4438 &saved_remote_timeout
);
4439 remote_timeout
= remote_flash_timeout
;
4441 ret
= remote_send_printf ("vFlashErase:%s,%s",
4446 case PACKET_UNKNOWN
:
4447 error (_("Remote target does not support flash erase"));
4449 error (_("Error erasing flash with vFlashErase packet"));
4454 do_cleanups (back_to
);
4458 remote_flash_write (struct target_ops
*ops
,
4459 ULONGEST address
, LONGEST length
,
4460 const gdb_byte
*data
)
4462 int saved_remote_timeout
= remote_timeout
;
4464 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4465 &saved_remote_timeout
);
4467 remote_timeout
= remote_flash_timeout
;
4468 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4469 do_cleanups (back_to
);
4475 remote_flash_done (struct target_ops
*ops
)
4477 int saved_remote_timeout
= remote_timeout
;
4479 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4480 &saved_remote_timeout
);
4482 remote_timeout
= remote_flash_timeout
;
4483 ret
= remote_send_printf ("vFlashDone");
4484 do_cleanups (back_to
);
4488 case PACKET_UNKNOWN
:
4489 error (_("Remote target does not support vFlashDone"));
4491 error (_("Error finishing flash operation"));
4498 remote_files_info (struct target_ops
*ignore
)
4500 puts_filtered ("Debugging a target over a serial line.\n");
4503 /* Stuff for dealing with the packets which are part of this protocol.
4504 See comment at top of file for details. */
4506 /* Read a single character from the remote end. */
4509 readchar (int timeout
)
4513 ch
= serial_readchar (remote_desc
, timeout
);
4518 switch ((enum serial_rc
) ch
)
4521 target_mourn_inferior ();
4522 error (_("Remote connection closed"));
4525 perror_with_name (_("Remote communication error"));
4527 case SERIAL_TIMEOUT
:
4533 /* Send the command in *BUF to the remote machine, and read the reply
4534 into *BUF. Report an error if we get an error reply. Resize
4535 *BUF using xrealloc if necessary to hold the result, and update
4539 remote_send (char **buf
,
4543 getpkt (buf
, sizeof_buf
, 0);
4545 if ((*buf
)[0] == 'E')
4546 error (_("Remote failure reply: %s"), *buf
);
4549 /* Display a null-terminated packet on stdout, for debugging, using C
4553 print_packet (char *buf
)
4555 puts_filtered ("\"");
4556 fputstr_filtered (buf
, '"', gdb_stdout
);
4557 puts_filtered ("\"");
4563 return putpkt_binary (buf
, strlen (buf
));
4566 /* Send a packet to the remote machine, with error checking. The data
4567 of the packet is in BUF. The string in BUF can be at most
4568 get_remote_packet_size () - 5 to account for the $, # and checksum,
4569 and for a possible /0 if we are debugging (remote_debug) and want
4570 to print the sent packet as a string. */
4573 putpkt_binary (char *buf
, int cnt
)
4576 unsigned char csum
= 0;
4577 char *buf2
= alloca (cnt
+ 6);
4583 /* Copy the packet into buffer BUF2, encapsulating it
4584 and giving it a checksum. */
4589 for (i
= 0; i
< cnt
; i
++)
4595 *p
++ = tohex ((csum
>> 4) & 0xf);
4596 *p
++ = tohex (csum
& 0xf);
4598 /* Send it over and over until we get a positive ack. */
4602 int started_error_output
= 0;
4607 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4608 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4609 fprintf_unfiltered (gdb_stdlog
, "...");
4610 gdb_flush (gdb_stdlog
);
4612 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4613 perror_with_name (_("putpkt: write failed"));
4615 /* Read until either a timeout occurs (-2) or '+' is read. */
4618 ch
= readchar (remote_timeout
);
4626 case SERIAL_TIMEOUT
:
4628 if (started_error_output
)
4630 putchar_unfiltered ('\n');
4631 started_error_output
= 0;
4640 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4644 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4645 case SERIAL_TIMEOUT
:
4649 break; /* Retransmit buffer. */
4653 fprintf_unfiltered (gdb_stdlog
,
4654 "Packet instead of Ack, ignoring it\n");
4655 /* It's probably an old response sent because an ACK
4656 was lost. Gobble up the packet and ack it so it
4657 doesn't get retransmitted when we resend this
4660 serial_write (remote_desc
, "+", 1);
4661 continue; /* Now, go look for +. */
4666 if (!started_error_output
)
4668 started_error_output
= 1;
4669 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4671 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4675 break; /* Here to retransmit. */
4679 /* This is wrong. If doing a long backtrace, the user should be
4680 able to get out next time we call QUIT, without anything as
4681 violent as interrupt_query. If we want to provide a way out of
4682 here without getting to the next QUIT, it should be based on
4683 hitting ^C twice as in remote_wait. */
4693 /* Come here after finding the start of a frame when we expected an
4694 ack. Do our best to discard the rest of this packet. */
4703 c
= readchar (remote_timeout
);
4706 case SERIAL_TIMEOUT
:
4707 /* Nothing we can do. */
4710 /* Discard the two bytes of checksum and stop. */
4711 c
= readchar (remote_timeout
);
4713 c
= readchar (remote_timeout
);
4716 case '*': /* Run length encoding. */
4717 /* Discard the repeat count. */
4718 c
= readchar (remote_timeout
);
4723 /* A regular character. */
4729 /* Come here after finding the start of the frame. Collect the rest
4730 into *BUF, verifying the checksum, length, and handling run-length
4731 compression. NUL terminate the buffer. If there is not enough room,
4732 expand *BUF using xrealloc.
4734 Returns -1 on error, number of characters in buffer (ignoring the
4735 trailing NULL) on success. (could be extended to return one of the
4736 SERIAL status indications). */
4739 read_frame (char **buf_p
,
4752 c
= readchar (remote_timeout
);
4755 case SERIAL_TIMEOUT
:
4757 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4761 fputs_filtered ("Saw new packet start in middle of old one\n",
4763 return -1; /* Start a new packet, count retries. */
4766 unsigned char pktcsum
;
4772 check_0
= readchar (remote_timeout
);
4774 check_1
= readchar (remote_timeout
);
4776 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4779 fputs_filtered ("Timeout in checksum, retrying\n",
4783 else if (check_0
< 0 || check_1
< 0)
4786 fputs_filtered ("Communication error in checksum\n",
4791 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4792 if (csum
== pktcsum
)
4797 fprintf_filtered (gdb_stdlog
,
4798 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4800 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4801 fputs_filtered ("\n", gdb_stdlog
);
4803 /* Number of characters in buffer ignoring trailing
4807 case '*': /* Run length encoding. */
4812 c
= readchar (remote_timeout
);
4814 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4816 /* The character before ``*'' is repeated. */
4818 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4820 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4822 /* Make some more room in the buffer. */
4823 *sizeof_buf
+= repeat
;
4824 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4828 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4834 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4838 if (bc
>= *sizeof_buf
- 1)
4840 /* Make some more room in the buffer. */
4842 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4853 /* Read a packet from the remote machine, with error checking, and
4854 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4855 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4856 rather than timing out; this is used (in synchronous mode) to wait
4857 for a target that is is executing user code to stop. */
4858 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4859 don't have to change all the calls to getpkt to deal with the
4860 return value, because at the moment I don't know what the right
4861 thing to do it for those. */
4869 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4873 /* Read a packet from the remote machine, with error checking, and
4874 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4875 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4876 rather than timing out; this is used (in synchronous mode) to wait
4877 for a target that is is executing user code to stop. If FOREVER ==
4878 0, this function is allowed to time out gracefully and return an
4879 indication of this to the caller. Otherwise return the number
4882 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4889 strcpy (*buf
, "timeout");
4893 timeout
= watchdog
> 0 ? watchdog
: -1;
4897 timeout
= remote_timeout
;
4901 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4903 /* This can loop forever if the remote side sends us characters
4904 continuously, but if it pauses, we'll get a zero from
4905 readchar because of timeout. Then we'll count that as a
4908 /* Note that we will only wait forever prior to the start of a
4909 packet. After that, we expect characters to arrive at a
4910 brisk pace. They should show up within remote_timeout
4915 c
= readchar (timeout
);
4917 if (c
== SERIAL_TIMEOUT
)
4919 if (forever
) /* Watchdog went off? Kill the target. */
4922 target_mourn_inferior ();
4923 error (_("Watchdog has expired. Target detached."));
4926 fputs_filtered ("Timed out.\n", gdb_stdlog
);
4932 /* We've found the start of a packet, now collect the data. */
4934 val
= read_frame (buf
, sizeof_buf
);
4940 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
4941 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
4942 fprintf_unfiltered (gdb_stdlog
, "\n");
4944 serial_write (remote_desc
, "+", 1);
4948 /* Try the whole thing again. */
4950 serial_write (remote_desc
, "-", 1);
4953 /* We have tried hard enough, and just can't receive the packet.
4956 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
4957 serial_write (remote_desc
, "+", 1);
4964 /* For some mysterious reason, wait_for_inferior calls kill instead of
4965 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4969 target_mourn_inferior ();
4973 /* Use catch_errors so the user can quit from gdb even when we aren't on
4974 speaking terms with the remote system. */
4975 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4977 /* Don't wait for it to die. I'm not really sure it matters whether
4978 we do or not. For the existing stubs, kill is a noop. */
4979 target_mourn_inferior ();
4982 /* Async version of remote_kill. */
4984 remote_async_kill (void)
4986 /* Unregister the file descriptor from the event loop. */
4987 if (target_is_async_p ())
4988 serial_async (remote_desc
, NULL
, 0);
4990 /* For some mysterious reason, wait_for_inferior calls kill instead of
4991 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4995 target_mourn_inferior ();
4999 /* Use catch_errors so the user can quit from gdb even when we
5000 aren't on speaking terms with the remote system. */
5001 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5003 /* Don't wait for it to die. I'm not really sure it matters whether
5004 we do or not. For the existing stubs, kill is a noop. */
5005 target_mourn_inferior ();
5011 remote_mourn_1 (&remote_ops
);
5015 remote_async_mourn (void)
5017 remote_mourn_1 (&remote_async_ops
);
5021 extended_remote_mourn (void)
5023 /* We do _not_ want to mourn the target like this; this will
5024 remove the extended remote target from the target stack,
5025 and the next time the user says "run" it'll fail.
5027 FIXME: What is the right thing to do here? */
5029 remote_mourn_1 (&extended_remote_ops
);
5033 /* Worker function for remote_mourn. */
5035 remote_mourn_1 (struct target_ops
*target
)
5037 unpush_target (target
);
5038 generic_mourn_inferior ();
5041 /* In the extended protocol we want to be able to do things like
5042 "run" and have them basically work as expected. So we need
5043 a special create_inferior function.
5045 FIXME: One day add support for changing the exec file
5046 we're debugging, arguments and an environment. */
5049 extended_remote_create_inferior (char *exec_file
, char *args
,
5050 char **env
, int from_tty
)
5052 /* Rip out the breakpoints; we'll reinsert them after restarting
5053 the remote server. */
5054 remove_breakpoints ();
5056 /* Now restart the remote server. */
5057 extended_remote_restart ();
5059 /* NOTE: We don't need to recheck for a target description here; but
5060 if we gain the ability to switch the remote executable we may
5061 need to, if for instance we are running a process which requested
5062 different emulated hardware from the operating system. A
5063 concrete example of this is ARM GNU/Linux, where some binaries
5064 will have a legacy FPA coprocessor emulated and others may have
5065 access to a hardware VFP unit. */
5067 /* Now put the breakpoints back in. This way we're safe if the
5068 restart function works via a unix fork on the remote side. */
5069 insert_breakpoints ();
5071 /* Clean up from the last time we were running. */
5072 clear_proceed_status ();
5075 /* Async version of extended_remote_create_inferior. */
5077 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5078 char **env
, int from_tty
)
5080 /* Rip out the breakpoints; we'll reinsert them after restarting
5081 the remote server. */
5082 remove_breakpoints ();
5084 /* If running asynchronously, register the target file descriptor
5085 with the event loop. */
5086 if (target_can_async_p ())
5087 target_async (inferior_event_handler
, 0);
5089 /* Now restart the remote server. */
5090 extended_remote_restart ();
5092 /* NOTE: We don't need to recheck for a target description here; but
5093 if we gain the ability to switch the remote executable we may
5094 need to, if for instance we are running a process which requested
5095 different emulated hardware from the operating system. A
5096 concrete example of this is ARM GNU/Linux, where some binaries
5097 will have a legacy FPA coprocessor emulated and others may have
5098 access to a hardware VFP unit. */
5100 /* Now put the breakpoints back in. This way we're safe if the
5101 restart function works via a unix fork on the remote side. */
5102 insert_breakpoints ();
5104 /* Clean up from the last time we were running. */
5105 clear_proceed_status ();
5109 /* Insert a breakpoint. On targets that have software breakpoint
5110 support, we ask the remote target to do the work; on targets
5111 which don't, we insert a traditional memory breakpoint. */
5114 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5116 CORE_ADDR addr
= bp_tgt
->placed_address
;
5117 struct remote_state
*rs
= get_remote_state ();
5119 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5120 If it succeeds, then set the support to PACKET_ENABLE. If it
5121 fails, and the user has explicitly requested the Z support then
5122 report an error, otherwise, mark it disabled and go on. */
5124 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5131 gdbarch_breakpoint_from_pc
5132 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5133 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5134 p
+= hexnumstr (p
, addr
);
5135 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5138 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5140 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5146 case PACKET_UNKNOWN
:
5151 return memory_insert_breakpoint (bp_tgt
);
5155 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5157 CORE_ADDR addr
= bp_tgt
->placed_address
;
5158 struct remote_state
*rs
= get_remote_state ();
5161 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5169 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5170 p
+= hexnumstr (p
, addr
);
5171 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5174 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5176 return (rs
->buf
[0] == 'E');
5179 return memory_remove_breakpoint (bp_tgt
);
5183 watchpoint_to_Z_packet (int type
)
5188 return Z_PACKET_WRITE_WP
;
5191 return Z_PACKET_READ_WP
;
5194 return Z_PACKET_ACCESS_WP
;
5197 internal_error (__FILE__
, __LINE__
,
5198 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5203 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5205 struct remote_state
*rs
= get_remote_state ();
5207 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5209 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5212 sprintf (rs
->buf
, "Z%x,", packet
);
5213 p
= strchr (rs
->buf
, '\0');
5214 addr
= remote_address_masked (addr
);
5215 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5216 sprintf (p
, ",%x", len
);
5219 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5221 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5224 case PACKET_UNKNOWN
:
5229 internal_error (__FILE__
, __LINE__
,
5230 _("remote_insert_watchpoint: reached end of function"));
5235 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5237 struct remote_state
*rs
= get_remote_state ();
5239 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5241 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5244 sprintf (rs
->buf
, "z%x,", packet
);
5245 p
= strchr (rs
->buf
, '\0');
5246 addr
= remote_address_masked (addr
);
5247 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5248 sprintf (p
, ",%x", len
);
5250 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5252 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5255 case PACKET_UNKNOWN
:
5260 internal_error (__FILE__
, __LINE__
,
5261 _("remote_remove_watchpoint: reached end of function"));
5265 int remote_hw_watchpoint_limit
= -1;
5266 int remote_hw_breakpoint_limit
= -1;
5269 remote_check_watch_resources (int type
, int cnt
, int ot
)
5271 if (type
== bp_hardware_breakpoint
)
5273 if (remote_hw_breakpoint_limit
== 0)
5275 else if (remote_hw_breakpoint_limit
< 0)
5277 else if (cnt
<= remote_hw_breakpoint_limit
)
5282 if (remote_hw_watchpoint_limit
== 0)
5284 else if (remote_hw_watchpoint_limit
< 0)
5288 else if (cnt
<= remote_hw_watchpoint_limit
)
5295 remote_stopped_by_watchpoint (void)
5297 return remote_stopped_by_watchpoint_p
;
5300 extern int stepped_after_stopped_by_watchpoint
;
5303 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5306 if (remote_stopped_by_watchpoint ()
5307 || stepped_after_stopped_by_watchpoint
)
5309 *addr_p
= remote_watch_data_address
;
5318 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5321 struct remote_state
*rs
= get_remote_state ();
5324 /* The length field should be set to the size of a breakpoint
5325 instruction, even though we aren't inserting one ourselves. */
5327 gdbarch_breakpoint_from_pc
5328 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5330 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5337 addr
= remote_address_masked (bp_tgt
->placed_address
);
5338 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5339 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5342 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5344 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5347 case PACKET_UNKNOWN
:
5352 internal_error (__FILE__
, __LINE__
,
5353 _("remote_insert_hw_breakpoint: reached end of function"));
5358 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5361 struct remote_state
*rs
= get_remote_state ();
5364 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5371 addr
= remote_address_masked (bp_tgt
->placed_address
);
5372 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5373 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5376 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5378 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5381 case PACKET_UNKNOWN
:
5386 internal_error (__FILE__
, __LINE__
,
5387 _("remote_remove_hw_breakpoint: reached end of function"));
5390 /* Some targets are only capable of doing downloads, and afterwards
5391 they switch to the remote serial protocol. This function provides
5392 a clean way to get from the download target to the remote target.
5393 It's basically just a wrapper so that we don't have to expose any
5394 of the internal workings of remote.c.
5396 Prior to calling this routine, you should shutdown the current
5397 target code, else you will get the "A program is being debugged
5398 already..." message. Usually a call to pop_target() suffices. */
5401 push_remote_target (char *name
, int from_tty
)
5403 printf_filtered (_("Switching to remote protocol\n"));
5404 remote_open (name
, from_tty
);
5407 /* Table used by the crc32 function to calcuate the checksum. */
5409 static unsigned long crc32_table
[256] =
5412 static unsigned long
5413 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5415 if (!crc32_table
[1])
5417 /* Initialize the CRC table and the decoding table. */
5421 for (i
= 0; i
< 256; i
++)
5423 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5424 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5431 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5437 /* compare-sections command
5439 With no arguments, compares each loadable section in the exec bfd
5440 with the same memory range on the target, and reports mismatches.
5441 Useful for verifying the image on the target against the exec file.
5442 Depends on the target understanding the new "qCRC:" request. */
5444 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5445 target method (target verify memory) and generic version of the
5446 actual command. This will allow other high-level code (especially
5447 generic_load()) to make use of this target functionality. */
5450 compare_sections_command (char *args
, int from_tty
)
5452 struct remote_state
*rs
= get_remote_state ();
5454 unsigned long host_crc
, target_crc
;
5455 extern bfd
*exec_bfd
;
5456 struct cleanup
*old_chain
;
5459 const char *sectname
;
5466 error (_("command cannot be used without an exec file"));
5467 if (!current_target
.to_shortname
||
5468 strcmp (current_target
.to_shortname
, "remote") != 0)
5469 error (_("command can only be used with remote target"));
5471 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5473 if (!(s
->flags
& SEC_LOAD
))
5474 continue; /* skip non-loadable section */
5476 size
= bfd_get_section_size (s
);
5478 continue; /* skip zero-length section */
5480 sectname
= bfd_get_section_name (exec_bfd
, s
);
5481 if (args
&& strcmp (args
, sectname
) != 0)
5482 continue; /* not the section selected by user */
5484 matched
= 1; /* do this section */
5486 /* FIXME: assumes lma can fit into long. */
5487 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5488 (long) lma
, (long) size
);
5491 /* Be clever; compute the host_crc before waiting for target
5493 sectdata
= xmalloc (size
);
5494 old_chain
= make_cleanup (xfree
, sectdata
);
5495 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5496 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5498 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5499 if (rs
->buf
[0] == 'E')
5500 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5501 sectname
, paddr (lma
), paddr (lma
+ size
));
5502 if (rs
->buf
[0] != 'C')
5503 error (_("remote target does not support this operation"));
5505 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5506 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5508 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5509 sectname
, paddr (lma
), paddr (lma
+ size
));
5510 if (host_crc
== target_crc
)
5511 printf_filtered ("matched.\n");
5514 printf_filtered ("MIS-MATCHED!\n");
5518 do_cleanups (old_chain
);
5521 warning (_("One or more sections of the remote executable does not match\n\
5522 the loaded file\n"));
5523 if (args
&& !matched
)
5524 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5527 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5528 into remote target. The number of bytes written to the remote
5529 target is returned, or -1 for error. */
5532 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
5533 const char *annex
, const gdb_byte
*writebuf
,
5534 ULONGEST offset
, LONGEST len
,
5535 struct packet_config
*packet
)
5540 struct remote_state
*rs
= get_remote_state ();
5541 int max_size
= get_memory_write_packet_size ();
5543 if (packet
->support
== PACKET_DISABLE
)
5546 /* Insert header. */
5547 i
= snprintf (rs
->buf
, max_size
,
5548 "qXfer:%s:write:%s:%s:",
5549 object_name
, annex
? annex
: "",
5550 phex_nz (offset
, sizeof offset
));
5551 max_size
-= (i
+ 1);
5553 /* Escape as much data as fits into rs->buf. */
5554 buf_len
= remote_escape_output
5555 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
5557 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
5558 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
5559 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5562 unpack_varlen_hex (rs
->buf
, &n
);
5566 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5567 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5568 number of bytes read is returned, or 0 for EOF, or -1 for error.
5569 The number of bytes read may be less than LEN without indicating an
5570 EOF. PACKET is checked and updated to indicate whether the remote
5571 target supports this object. */
5574 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5576 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5577 struct packet_config
*packet
)
5579 static char *finished_object
;
5580 static char *finished_annex
;
5581 static ULONGEST finished_offset
;
5583 struct remote_state
*rs
= get_remote_state ();
5584 unsigned int total
= 0;
5585 LONGEST i
, n
, packet_len
;
5587 if (packet
->support
== PACKET_DISABLE
)
5590 /* Check whether we've cached an end-of-object packet that matches
5592 if (finished_object
)
5594 if (strcmp (object_name
, finished_object
) == 0
5595 && strcmp (annex
? annex
: "", finished_annex
) == 0
5596 && offset
== finished_offset
)
5599 /* Otherwise, we're now reading something different. Discard
5601 xfree (finished_object
);
5602 xfree (finished_annex
);
5603 finished_object
= NULL
;
5604 finished_annex
= NULL
;
5607 /* Request only enough to fit in a single packet. The actual data
5608 may not, since we don't know how much of it will need to be escaped;
5609 the target is free to respond with slightly less data. We subtract
5610 five to account for the response type and the protocol frame. */
5611 n
= min (get_remote_packet_size () - 5, len
);
5612 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5613 object_name
, annex
? annex
: "",
5614 phex_nz (offset
, sizeof offset
),
5615 phex_nz (n
, sizeof n
));
5616 i
= putpkt (rs
->buf
);
5621 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5622 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5625 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5626 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5628 /* 'm' means there is (or at least might be) more data after this
5629 batch. That does not make sense unless there's at least one byte
5630 of data in this reply. */
5631 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5632 error (_("Remote qXfer reply contained no data."));
5634 /* Got some data. */
5635 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5637 /* 'l' is an EOF marker, possibly including a final block of data,
5638 or possibly empty. If we have the final block of a non-empty
5639 object, record this fact to bypass a subsequent partial read. */
5640 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
5642 finished_object
= xstrdup (object_name
);
5643 finished_annex
= xstrdup (annex
? annex
: "");
5644 finished_offset
= offset
+ i
;
5651 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5652 const char *annex
, gdb_byte
*readbuf
,
5653 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5655 struct remote_state
*rs
= get_remote_state ();
5660 /* Handle memory using the standard memory routines. */
5661 if (object
== TARGET_OBJECT_MEMORY
)
5666 if (writebuf
!= NULL
)
5667 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5669 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5673 else if (xfered
== 0 && errno
== 0)
5679 /* Handle SPU memory using qxfer packets. */
5680 if (object
== TARGET_OBJECT_SPU
)
5683 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
5684 &remote_protocol_packets
5685 [PACKET_qXfer_spu_read
]);
5687 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
5688 &remote_protocol_packets
5689 [PACKET_qXfer_spu_write
]);
5692 /* Only handle flash writes. */
5693 if (writebuf
!= NULL
)
5699 case TARGET_OBJECT_FLASH
:
5700 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5704 else if (xfered
== 0 && errno
== 0)
5714 /* Map pre-existing objects onto letters. DO NOT do this for new
5715 objects!!! Instead specify new query packets. */
5718 case TARGET_OBJECT_AVR
:
5722 case TARGET_OBJECT_AUXV
:
5723 gdb_assert (annex
== NULL
);
5724 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5725 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5727 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5728 return remote_read_qxfer
5729 (ops
, "features", annex
, readbuf
, offset
, len
,
5730 &remote_protocol_packets
[PACKET_qXfer_features
]);
5732 case TARGET_OBJECT_MEMORY_MAP
:
5733 gdb_assert (annex
== NULL
);
5734 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5735 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5741 /* Note: a zero OFFSET and LEN can be used to query the minimum
5743 if (offset
== 0 && len
== 0)
5744 return (get_remote_packet_size ());
5745 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5746 large enough let the caller deal with it. */
5747 if (len
< get_remote_packet_size ())
5749 len
= get_remote_packet_size ();
5751 /* Except for querying the minimum buffer size, target must be open. */
5753 error (_("remote query is only available after target open"));
5755 gdb_assert (annex
!= NULL
);
5756 gdb_assert (readbuf
!= NULL
);
5762 /* We used one buffer char for the remote protocol q command and
5763 another for the query type. As the remote protocol encapsulation
5764 uses 4 chars plus one extra in case we are debugging
5765 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5768 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5770 /* Bad caller may have sent forbidden characters. */
5771 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5776 gdb_assert (annex
[i
] == '\0');
5778 i
= putpkt (rs
->buf
);
5782 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5783 strcpy ((char *) readbuf
, rs
->buf
);
5785 return strlen ((char *) readbuf
);
5789 remote_rcmd (char *command
,
5790 struct ui_file
*outbuf
)
5792 struct remote_state
*rs
= get_remote_state ();
5796 error (_("remote rcmd is only available after target open"));
5798 /* Send a NULL command across as an empty command. */
5799 if (command
== NULL
)
5802 /* The query prefix. */
5803 strcpy (rs
->buf
, "qRcmd,");
5804 p
= strchr (rs
->buf
, '\0');
5806 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5807 error (_("\"monitor\" command ``%s'' is too long."), command
);
5809 /* Encode the actual command. */
5810 bin2hex ((gdb_byte
*) command
, p
, 0);
5812 if (putpkt (rs
->buf
) < 0)
5813 error (_("Communication problem with target."));
5815 /* get/display the response */
5820 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5822 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5825 error (_("Target does not support this command."));
5826 if (buf
[0] == 'O' && buf
[1] != 'K')
5828 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5831 if (strcmp (buf
, "OK") == 0)
5833 if (strlen (buf
) == 3 && buf
[0] == 'E'
5834 && isdigit (buf
[1]) && isdigit (buf
[2]))
5836 error (_("Protocol error with Rcmd"));
5838 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5840 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5841 fputc_unfiltered (c
, outbuf
);
5847 static VEC(mem_region_s
) *
5848 remote_memory_map (struct target_ops
*ops
)
5850 VEC(mem_region_s
) *result
= NULL
;
5851 char *text
= target_read_stralloc (¤t_target
,
5852 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5856 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5857 result
= parse_memory_map (text
);
5858 do_cleanups (back_to
);
5865 packet_command (char *args
, int from_tty
)
5867 struct remote_state
*rs
= get_remote_state ();
5870 error (_("command can only be used with remote target"));
5873 error (_("remote-packet command requires packet text as argument"));
5875 puts_filtered ("sending: ");
5876 print_packet (args
);
5877 puts_filtered ("\n");
5880 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5881 puts_filtered ("received: ");
5882 print_packet (rs
->buf
);
5883 puts_filtered ("\n");
5887 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5889 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5891 static void threadset_test_cmd (char *cmd
, int tty
);
5893 static void threadalive_test (char *cmd
, int tty
);
5895 static void threadlist_test_cmd (char *cmd
, int tty
);
5897 int get_and_display_threadinfo (threadref
*ref
);
5899 static void threadinfo_test_cmd (char *cmd
, int tty
);
5901 static int thread_display_step (threadref
*ref
, void *context
);
5903 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5905 static void init_remote_threadtests (void);
5907 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5910 threadset_test_cmd (char *cmd
, int tty
)
5912 int sample_thread
= SAMPLE_THREAD
;
5914 printf_filtered (_("Remote threadset test\n"));
5915 set_thread (sample_thread
, 1);
5920 threadalive_test (char *cmd
, int tty
)
5922 int sample_thread
= SAMPLE_THREAD
;
5924 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5925 printf_filtered ("PASS: Thread alive test\n");
5927 printf_filtered ("FAIL: Thread alive test\n");
5930 void output_threadid (char *title
, threadref
*ref
);
5933 output_threadid (char *title
, threadref
*ref
)
5937 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
5939 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
5943 threadlist_test_cmd (char *cmd
, int tty
)
5946 threadref nextthread
;
5947 int done
, result_count
;
5948 threadref threadlist
[3];
5950 printf_filtered ("Remote Threadlist test\n");
5951 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
5952 &result_count
, &threadlist
[0]))
5953 printf_filtered ("FAIL: threadlist test\n");
5956 threadref
*scan
= threadlist
;
5957 threadref
*limit
= scan
+ result_count
;
5959 while (scan
< limit
)
5960 output_threadid (" thread ", scan
++);
5965 display_thread_info (struct gdb_ext_thread_info
*info
)
5967 output_threadid ("Threadid: ", &info
->threadid
);
5968 printf_filtered ("Name: %s\n ", info
->shortname
);
5969 printf_filtered ("State: %s\n", info
->display
);
5970 printf_filtered ("other: %s\n\n", info
->more_display
);
5974 get_and_display_threadinfo (threadref
*ref
)
5978 struct gdb_ext_thread_info threadinfo
;
5980 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
5981 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
5982 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
5983 display_thread_info (&threadinfo
);
5988 threadinfo_test_cmd (char *cmd
, int tty
)
5990 int athread
= SAMPLE_THREAD
;
5994 int_to_threadref (&thread
, athread
);
5995 printf_filtered ("Remote Threadinfo test\n");
5996 if (!get_and_display_threadinfo (&thread
))
5997 printf_filtered ("FAIL cannot get thread info\n");
6001 thread_display_step (threadref
*ref
, void *context
)
6003 /* output_threadid(" threadstep ",ref); *//* simple test */
6004 return get_and_display_threadinfo (ref
);
6008 threadlist_update_test_cmd (char *cmd
, int tty
)
6010 printf_filtered ("Remote Threadlist update test\n");
6011 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
6015 init_remote_threadtests (void)
6017 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
6018 Fetch and print the remote list of thread identifiers, one pkt only"));
6019 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
6020 _("Fetch and display info about one thread"));
6021 add_com ("tset", class_obscure
, threadset_test_cmd
,
6022 _("Test setting to a different thread"));
6023 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
6024 _("Iterate through updating all remote thread info"));
6025 add_com ("talive", class_obscure
, threadalive_test
,
6026 _(" Remote thread alive test "));
6031 /* Convert a thread ID to a string. Returns the string in a static
6035 remote_pid_to_str (ptid_t ptid
)
6037 static char buf
[32];
6039 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
6043 /* Get the address of the thread local variable in OBJFILE which is
6044 stored at OFFSET within the thread local storage for thread PTID. */
6047 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
6049 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
6051 struct remote_state
*rs
= get_remote_state ();
6053 enum packet_result result
;
6055 strcpy (p
, "qGetTLSAddr:");
6057 p
+= hexnumstr (p
, PIDGET (ptid
));
6059 p
+= hexnumstr (p
, offset
);
6061 p
+= hexnumstr (p
, lm
);
6065 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6066 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6067 if (result
== PACKET_OK
)
6071 unpack_varlen_hex (rs
->buf
, &result
);
6074 else if (result
== PACKET_UNKNOWN
)
6075 throw_error (TLS_GENERIC_ERROR
,
6076 _("Remote target doesn't support qGetTLSAddr packet"));
6078 throw_error (TLS_GENERIC_ERROR
,
6079 _("Remote target failed to process qGetTLSAddr request"));
6082 throw_error (TLS_GENERIC_ERROR
,
6083 _("TLS not supported or disabled on this target"));
6088 /* Support for inferring a target description based on the current
6089 architecture and the size of a 'g' packet. While the 'g' packet
6090 can have any size (since optional registers can be left off the
6091 end), some sizes are easily recognizable given knowledge of the
6092 approximate architecture. */
6094 struct remote_g_packet_guess
6097 const struct target_desc
*tdesc
;
6099 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6100 DEF_VEC_O(remote_g_packet_guess_s
);
6102 struct remote_g_packet_data
6104 VEC(remote_g_packet_guess_s
) *guesses
;
6107 static struct gdbarch_data
*remote_g_packet_data_handle
;
6110 remote_g_packet_data_init (struct obstack
*obstack
)
6112 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6116 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6117 const struct target_desc
*tdesc
)
6119 struct remote_g_packet_data
*data
6120 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6121 struct remote_g_packet_guess new_guess
, *guess
;
6124 gdb_assert (tdesc
!= NULL
);
6127 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6129 if (guess
->bytes
== bytes
)
6130 internal_error (__FILE__
, __LINE__
,
6131 "Duplicate g packet description added for size %d",
6134 new_guess
.bytes
= bytes
;
6135 new_guess
.tdesc
= tdesc
;
6136 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6139 static const struct target_desc
*
6140 remote_read_description (struct target_ops
*target
)
6142 struct remote_g_packet_data
*data
6143 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6145 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6147 struct remote_g_packet_guess
*guess
;
6149 int bytes
= send_g_packet ();
6152 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6154 if (guess
->bytes
== bytes
)
6155 return guess
->tdesc
;
6157 /* We discard the g packet. A minor optimization would be to
6158 hold on to it, and fill the register cache once we have selected
6159 an architecture, but it's too tricky to do safely. */
6166 init_remote_ops (void)
6168 remote_ops
.to_shortname
= "remote";
6169 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6171 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6172 Specify the serial device it is connected to\n\
6173 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6174 remote_ops
.to_open
= remote_open
;
6175 remote_ops
.to_close
= remote_close
;
6176 remote_ops
.to_detach
= remote_detach
;
6177 remote_ops
.to_disconnect
= remote_disconnect
;
6178 remote_ops
.to_resume
= remote_resume
;
6179 remote_ops
.to_wait
= remote_wait
;
6180 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6181 remote_ops
.to_store_registers
= remote_store_registers
;
6182 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6183 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6184 remote_ops
.to_files_info
= remote_files_info
;
6185 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6186 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6187 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6188 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6189 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6190 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6191 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6192 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6193 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6194 remote_ops
.to_kill
= remote_kill
;
6195 remote_ops
.to_load
= generic_load
;
6196 remote_ops
.to_mourn_inferior
= remote_mourn
;
6197 remote_ops
.to_thread_alive
= remote_thread_alive
;
6198 remote_ops
.to_find_new_threads
= remote_threads_info
;
6199 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6200 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6201 remote_ops
.to_stop
= remote_stop
;
6202 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6203 remote_ops
.to_rcmd
= remote_rcmd
;
6204 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6205 remote_ops
.to_stratum
= process_stratum
;
6206 remote_ops
.to_has_all_memory
= 1;
6207 remote_ops
.to_has_memory
= 1;
6208 remote_ops
.to_has_stack
= 1;
6209 remote_ops
.to_has_registers
= 1;
6210 remote_ops
.to_has_execution
= 1;
6211 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6212 remote_ops
.to_magic
= OPS_MAGIC
;
6213 remote_ops
.to_memory_map
= remote_memory_map
;
6214 remote_ops
.to_flash_erase
= remote_flash_erase
;
6215 remote_ops
.to_flash_done
= remote_flash_done
;
6216 remote_ops
.to_read_description
= remote_read_description
;
6219 /* Set up the extended remote vector by making a copy of the standard
6220 remote vector and adding to it. */
6223 init_extended_remote_ops (void)
6225 extended_remote_ops
= remote_ops
;
6227 extended_remote_ops
.to_shortname
= "extended-remote";
6228 extended_remote_ops
.to_longname
=
6229 "Extended remote serial target in gdb-specific protocol";
6230 extended_remote_ops
.to_doc
=
6231 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6232 Specify the serial device it is connected to (e.g. /dev/ttya).",
6233 extended_remote_ops
.to_open
= extended_remote_open
;
6234 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6235 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6239 remote_can_async_p (void)
6241 /* We're async whenever the serial device is. */
6242 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6246 remote_is_async_p (void)
6248 /* We're async whenever the serial device is. */
6249 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6252 /* Pass the SERIAL event on and up to the client. One day this code
6253 will be able to delay notifying the client of an event until the
6254 point where an entire packet has been received. */
6256 static void (*async_client_callback
) (enum inferior_event_type event_type
,
6258 static void *async_client_context
;
6259 static serial_event_ftype remote_async_serial_handler
;
6262 remote_async_serial_handler (struct serial
*scb
, void *context
)
6264 /* Don't propogate error information up to the client. Instead let
6265 the client find out about the error by querying the target. */
6266 async_client_callback (INF_REG_EVENT
, async_client_context
);
6270 remote_async (void (*callback
) (enum inferior_event_type event_type
,
6271 void *context
), void *context
)
6273 if (current_target
.to_async_mask_value
== 0)
6274 internal_error (__FILE__
, __LINE__
,
6275 _("Calling remote_async when async is masked"));
6277 if (callback
!= NULL
)
6279 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
6280 async_client_callback
= callback
;
6281 async_client_context
= context
;
6284 serial_async (remote_desc
, NULL
, NULL
);
6287 /* Target async and target extended-async.
6289 This are temporary targets, until it is all tested. Eventually
6290 async support will be incorporated int the usual 'remote'
6294 init_remote_async_ops (void)
6296 remote_async_ops
.to_shortname
= "async";
6297 remote_async_ops
.to_longname
=
6298 "Remote serial target in async version of the gdb-specific protocol";
6299 remote_async_ops
.to_doc
=
6300 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6301 Specify the serial device it is connected to (e.g. /dev/ttya).";
6302 remote_async_ops
.to_open
= remote_async_open
;
6303 remote_async_ops
.to_close
= remote_close
;
6304 remote_async_ops
.to_detach
= remote_detach
;
6305 remote_async_ops
.to_disconnect
= remote_disconnect
;
6306 remote_async_ops
.to_resume
= remote_async_resume
;
6307 remote_async_ops
.to_wait
= remote_async_wait
;
6308 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
6309 remote_async_ops
.to_store_registers
= remote_store_registers
;
6310 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6311 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6312 remote_async_ops
.to_files_info
= remote_files_info
;
6313 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6314 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6315 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6316 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6317 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6318 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6319 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6320 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6321 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6322 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
6323 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
6324 remote_async_ops
.to_kill
= remote_async_kill
;
6325 remote_async_ops
.to_load
= generic_load
;
6326 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
6327 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
6328 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
6329 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
6330 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6331 remote_async_ops
.to_stop
= remote_stop
;
6332 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
6333 remote_async_ops
.to_rcmd
= remote_rcmd
;
6334 remote_async_ops
.to_stratum
= process_stratum
;
6335 remote_async_ops
.to_has_all_memory
= 1;
6336 remote_async_ops
.to_has_memory
= 1;
6337 remote_async_ops
.to_has_stack
= 1;
6338 remote_async_ops
.to_has_registers
= 1;
6339 remote_async_ops
.to_has_execution
= 1;
6340 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6341 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
6342 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
6343 remote_async_ops
.to_async
= remote_async
;
6344 remote_async_ops
.to_async_mask_value
= 1;
6345 remote_async_ops
.to_magic
= OPS_MAGIC
;
6346 remote_async_ops
.to_memory_map
= remote_memory_map
;
6347 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
6348 remote_async_ops
.to_flash_done
= remote_flash_done
;
6349 remote_ops
.to_read_description
= remote_read_description
;
6352 /* Set up the async extended remote vector by making a copy of the standard
6353 remote vector and adding to it. */
6356 init_extended_async_remote_ops (void)
6358 extended_async_remote_ops
= remote_async_ops
;
6360 extended_async_remote_ops
.to_shortname
= "extended-async";
6361 extended_async_remote_ops
.to_longname
=
6362 "Extended remote serial target in async gdb-specific protocol";
6363 extended_async_remote_ops
.to_doc
=
6364 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6365 Specify the serial device it is connected to (e.g. /dev/ttya).",
6366 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
6367 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
6368 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6372 set_remote_cmd (char *args
, int from_tty
)
6374 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
6378 show_remote_cmd (char *args
, int from_tty
)
6380 /* We can't just use cmd_show_list here, because we want to skip
6381 the redundant "show remote Z-packet" and the legacy aliases. */
6382 struct cleanup
*showlist_chain
;
6383 struct cmd_list_element
*list
= remote_show_cmdlist
;
6385 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
6386 for (; list
!= NULL
; list
= list
->next
)
6387 if (strcmp (list
->name
, "Z-packet") == 0)
6389 else if (list
->type
== not_set_cmd
)
6390 /* Alias commands are exactly like the original, except they
6391 don't have the normal type. */
6395 struct cleanup
*option_chain
6396 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
6397 ui_out_field_string (uiout
, "name", list
->name
);
6398 ui_out_text (uiout
, ": ");
6399 if (list
->type
== show_cmd
)
6400 do_setshow_command ((char *) NULL
, from_tty
, list
);
6402 cmd_func (list
, NULL
, from_tty
);
6403 /* Close the tuple. */
6404 do_cleanups (option_chain
);
6407 /* Close the tuple. */
6408 do_cleanups (showlist_chain
);
6412 build_remote_gdbarch_data (void)
6414 remote_address_size
= gdbarch_addr_bit (current_gdbarch
);
6417 /* Function to be called whenever a new objfile (shlib) is detected. */
6419 remote_new_objfile (struct objfile
*objfile
)
6421 if (remote_desc
!= 0) /* Have a remote connection. */
6422 remote_check_symbols (objfile
);
6426 _initialize_remote (void)
6428 struct remote_state
*rs
;
6430 /* architecture specific data */
6431 remote_gdbarch_data_handle
=
6432 gdbarch_data_register_post_init (init_remote_state
);
6433 remote_g_packet_data_handle
=
6434 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
6436 /* Old tacky stuff. NOTE: This comes after the remote protocol so
6437 that the remote protocol has been initialized. */
6438 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size
);
6439 deprecated_register_gdbarch_swap (NULL
, 0, build_remote_gdbarch_data
);
6441 /* Initialize the per-target state. At the moment there is only one
6442 of these, not one per target. Only one target is active at a
6443 time. The default buffer size is unimportant; it will be expanded
6444 whenever a larger buffer is needed. */
6445 rs
= get_remote_state_raw ();
6447 rs
->buf
= xmalloc (rs
->buf_size
);
6450 add_target (&remote_ops
);
6452 init_extended_remote_ops ();
6453 add_target (&extended_remote_ops
);
6455 init_remote_async_ops ();
6456 add_target (&remote_async_ops
);
6458 init_extended_async_remote_ops ();
6459 add_target (&extended_async_remote_ops
);
6461 /* Hook into new objfile notification. */
6462 observer_attach_new_objfile (remote_new_objfile
);
6465 init_remote_threadtests ();
6468 /* set/show remote ... */
6470 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
6471 Remote protocol specific variables\n\
6472 Configure various remote-protocol specific variables such as\n\
6473 the packets being used"),
6474 &remote_set_cmdlist
, "set remote ",
6475 0 /* allow-unknown */, &setlist
);
6476 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
6477 Remote protocol specific variables\n\
6478 Configure various remote-protocol specific variables such as\n\
6479 the packets being used"),
6480 &remote_show_cmdlist
, "show remote ",
6481 0 /* allow-unknown */, &showlist
);
6483 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
6484 Compare section data on target to the exec file.\n\
6485 Argument is a single section name (default: all loaded sections)."),
6488 add_cmd ("packet", class_maintenance
, packet_command
, _("\
6489 Send an arbitrary packet to a remote target.\n\
6490 maintenance packet TEXT\n\
6491 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6492 this command sends the string TEXT to the inferior, and displays the\n\
6493 response packet. GDB supplies the initial `$' character, and the\n\
6494 terminating `#' character and checksum."),
6497 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
6498 Set whether to send break if interrupted."), _("\
6499 Show whether to send break if interrupted."), _("\
6500 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6501 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6502 &setlist
, &showlist
);
6504 /* Install commands for configuring memory read/write packets. */
6506 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
6507 Set the maximum number of bytes per memory write packet (deprecated)."),
6509 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
6510 Show the maximum number of bytes per memory write packet (deprecated)."),
6512 add_cmd ("memory-write-packet-size", no_class
,
6513 set_memory_write_packet_size
, _("\
6514 Set the maximum number of bytes per memory-write packet.\n\
6515 Specify the number of bytes in a packet or 0 (zero) for the\n\
6516 default packet size. The actual limit is further reduced\n\
6517 dependent on the target. Specify ``fixed'' to disable the\n\
6518 further restriction and ``limit'' to enable that restriction."),
6519 &remote_set_cmdlist
);
6520 add_cmd ("memory-read-packet-size", no_class
,
6521 set_memory_read_packet_size
, _("\
6522 Set the maximum number of bytes per memory-read packet.\n\
6523 Specify the number of bytes in a packet or 0 (zero) for the\n\
6524 default packet size. The actual limit is further reduced\n\
6525 dependent on the target. Specify ``fixed'' to disable the\n\
6526 further restriction and ``limit'' to enable that restriction."),
6527 &remote_set_cmdlist
);
6528 add_cmd ("memory-write-packet-size", no_class
,
6529 show_memory_write_packet_size
,
6530 _("Show the maximum number of bytes per memory-write packet."),
6531 &remote_show_cmdlist
);
6532 add_cmd ("memory-read-packet-size", no_class
,
6533 show_memory_read_packet_size
,
6534 _("Show the maximum number of bytes per memory-read packet."),
6535 &remote_show_cmdlist
);
6537 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6538 &remote_hw_watchpoint_limit
, _("\
6539 Set the maximum number of target hardware watchpoints."), _("\
6540 Show the maximum number of target hardware watchpoints."), _("\
6541 Specify a negative limit for unlimited."),
6542 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6543 &remote_set_cmdlist
, &remote_show_cmdlist
);
6544 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6545 &remote_hw_breakpoint_limit
, _("\
6546 Set the maximum number of target hardware breakpoints."), _("\
6547 Show the maximum number of target hardware breakpoints."), _("\
6548 Specify a negative limit for unlimited."),
6549 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6550 &remote_set_cmdlist
, &remote_show_cmdlist
);
6552 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6553 &remote_address_size
, _("\
6554 Set the maximum size of the address (in bits) in a memory packet."), _("\
6555 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6557 NULL
, /* FIXME: i18n: */
6558 &setlist
, &showlist
);
6560 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6561 "X", "binary-download", 1);
6563 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6564 "vCont", "verbose-resume", 0);
6566 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
6567 "QPassSignals", "pass-signals", 0);
6569 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6570 "qSymbol", "symbol-lookup", 0);
6572 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6573 "P", "set-register", 1);
6575 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6576 "p", "fetch-register", 1);
6578 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6579 "Z0", "software-breakpoint", 0);
6581 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6582 "Z1", "hardware-breakpoint", 0);
6584 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6585 "Z2", "write-watchpoint", 0);
6587 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6588 "Z3", "read-watchpoint", 0);
6590 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6591 "Z4", "access-watchpoint", 0);
6593 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6594 "qXfer:auxv:read", "read-aux-vector", 0);
6596 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
6597 "qXfer:features:read", "target-features", 0);
6599 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
6600 "qXfer:memory-map:read", "memory-map", 0);
6602 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
6603 "qXfer:spu:read", "read-spu-object", 0);
6605 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
6606 "qXfer:spu:write", "write-spu-object", 0);
6608 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6609 "qGetTLSAddr", "get-thread-local-storage-address",
6612 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6613 "qSupported", "supported-packets", 0);
6615 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6616 Z sub-packet has its own set and show commands, but users may
6617 have sets to this variable in their .gdbinit files (or in their
6619 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6620 &remote_Z_packet_detect
, _("\
6621 Set use of remote protocol `Z' packets"), _("\
6622 Show use of remote protocol `Z' packets "), _("\
6623 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6625 set_remote_protocol_Z_packet_cmd
,
6626 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6627 &remote_set_cmdlist
, &remote_show_cmdlist
);
6629 /* Eventually initialize fileio. See fileio.c */
6630 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);