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 ();
2019 int lose
, num_segments
= 0, do_sections
, do_segments
;
2020 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
2021 struct section_offsets
*offs
;
2022 struct symfile_segment_data
*data
;
2024 if (symfile_objfile
== NULL
)
2027 putpkt ("qOffsets");
2028 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2031 if (buf
[0] == '\000')
2032 return; /* Return silently. Stub doesn't support
2036 warning (_("Remote failure reply: %s"), buf
);
2040 /* Pick up each field in turn. This used to be done with scanf, but
2041 scanf will make trouble if CORE_ADDR size doesn't match
2042 conversion directives correctly. The following code will work
2043 with any size of CORE_ADDR. */
2044 text_addr
= data_addr
= bss_addr
= 0;
2048 if (strncmp (ptr
, "Text=", 5) == 0)
2051 /* Don't use strtol, could lose on big values. */
2052 while (*ptr
&& *ptr
!= ';')
2053 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2055 if (strncmp (ptr
, ";Data=", 6) == 0)
2058 while (*ptr
&& *ptr
!= ';')
2059 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2064 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2067 while (*ptr
&& *ptr
!= ';')
2068 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2070 if (bss_addr
!= data_addr
)
2071 warning (_("Target reported unsupported offsets: %s"), buf
);
2076 else if (strncmp (ptr
, "TextSeg=", 8) == 0)
2079 /* Don't use strtol, could lose on big values. */
2080 while (*ptr
&& *ptr
!= ';')
2081 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2084 if (strncmp (ptr
, ";DataSeg=", 9) == 0)
2087 while (*ptr
&& *ptr
!= ';')
2088 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2096 error (_("Malformed response to offset query, %s"), buf
);
2097 else if (*ptr
!= '\0')
2098 warning (_("Target reported unsupported offsets: %s"), buf
);
2100 offs
= ((struct section_offsets
*)
2101 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2102 memcpy (offs
, symfile_objfile
->section_offsets
,
2103 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2105 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
2106 do_segments
= (data
!= NULL
);
2107 do_sections
= num_segments
== 0;
2109 /* Text= and Data= specify offsets for the text and data sections,
2110 but symfile_map_offsets_to_segments expects base addresses
2111 instead of offsets. If we have two segments, we can still
2112 try to relocate the whole segments instead of just ".text"
2114 if (num_segments
== 0)
2117 if (data
== NULL
|| data
->num_segments
!= 2)
2121 segments
[0] = data
->segment_bases
[0] + text_addr
;
2122 segments
[1] = data
->segment_bases
[1] + data_addr
;
2128 segments
[0] = text_addr
;
2129 segments
[1] = data_addr
;
2134 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
2135 offs
, num_segments
, segments
);
2137 if (ret
== 0 && !do_sections
)
2138 error (_("Can not handle qOffsets TextSeg response with this symbol file"));
2144 free_symfile_segment_data (data
);
2148 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2150 /* This is a temporary kludge to force data and bss to use the same offsets
2151 because that's what nlmconv does now. The real solution requires changes
2152 to the stub and remote.c that I don't have time to do right now. */
2154 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2155 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2158 objfile_relocate (symfile_objfile
, offs
);
2161 /* Stub for catch_exception. */
2164 remote_start_remote (struct ui_out
*uiout
, void *from_tty_p
)
2166 int from_tty
= * (int *) from_tty_p
;
2168 immediate_quit
++; /* Allow user to interrupt it. */
2170 /* Ack any packet which the remote side has already sent. */
2171 serial_write (remote_desc
, "+", 1);
2173 /* Let the stub know that we want it to return the thread. */
2176 inferior_ptid
= remote_current_thread (inferior_ptid
);
2178 get_offsets (); /* Get text, data & bss offsets. */
2180 putpkt ("?"); /* Initiate a query from remote machine. */
2183 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
2186 /* Open a connection to a remote debugger.
2187 NAME is the filename used for communication. */
2190 remote_open (char *name
, int from_tty
)
2192 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2195 /* Just like remote_open, but with asynchronous support. */
2197 remote_async_open (char *name
, int from_tty
)
2199 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2202 /* Open a connection to a remote debugger using the extended
2203 remote gdb protocol. NAME is the filename used for communication. */
2206 extended_remote_open (char *name
, int from_tty
)
2208 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2212 /* Just like extended_remote_open, but with asynchronous support. */
2214 extended_remote_async_open (char *name
, int from_tty
)
2216 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2217 1 /*extended_p */, 1 /* async_p */);
2220 /* Generic code for opening a connection to a remote target. */
2223 init_all_packet_configs (void)
2226 for (i
= 0; i
< PACKET_MAX
; i
++)
2227 update_packet_config (&remote_protocol_packets
[i
]);
2230 /* Symbol look-up. */
2233 remote_check_symbols (struct objfile
*objfile
)
2235 struct remote_state
*rs
= get_remote_state ();
2236 char *msg
, *reply
, *tmp
;
2237 struct minimal_symbol
*sym
;
2240 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2243 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2244 because we need both at the same time. */
2245 msg
= alloca (get_remote_packet_size ());
2247 /* Invite target to request symbol lookups. */
2249 putpkt ("qSymbol::");
2250 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2251 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2254 while (strncmp (reply
, "qSymbol:", 8) == 0)
2257 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2259 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2261 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2263 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2264 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2267 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2272 static struct serial
*
2273 remote_serial_open (char *name
)
2275 static int udp_warning
= 0;
2277 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2278 of in ser-tcp.c, because it is the remote protocol assuming that the
2279 serial connection is reliable and not the serial connection promising
2281 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2284 The remote protocol may be unreliable over UDP.\n\
2285 Some events may be lost, rendering further debugging impossible."));
2289 return serial_open (name
);
2292 /* This type describes each known response to the qSupported
2294 struct protocol_feature
2296 /* The name of this protocol feature. */
2299 /* The default for this protocol feature. */
2300 enum packet_support default_support
;
2302 /* The function to call when this feature is reported, or after
2303 qSupported processing if the feature is not supported.
2304 The first argument points to this structure. The second
2305 argument indicates whether the packet requested support be
2306 enabled, disabled, or probed (or the default, if this function
2307 is being called at the end of processing and this feature was
2308 not reported). The third argument may be NULL; if not NULL, it
2309 is a NUL-terminated string taken from the packet following
2310 this feature's name and an equals sign. */
2311 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2314 /* The corresponding packet for this feature. Only used if
2315 FUNC is remote_supported_packet. */
2320 remote_supported_packet (const struct protocol_feature
*feature
,
2321 enum packet_support support
,
2322 const char *argument
)
2326 warning (_("Remote qSupported response supplied an unexpected value for"
2327 " \"%s\"."), feature
->name
);
2331 if (remote_protocol_packets
[feature
->packet
].support
2332 == PACKET_SUPPORT_UNKNOWN
)
2333 remote_protocol_packets
[feature
->packet
].support
= support
;
2337 remote_packet_size (const struct protocol_feature
*feature
,
2338 enum packet_support support
, const char *value
)
2340 struct remote_state
*rs
= get_remote_state ();
2345 if (support
!= PACKET_ENABLE
)
2348 if (value
== NULL
|| *value
== '\0')
2350 warning (_("Remote target reported \"%s\" without a size."),
2356 packet_size
= strtol (value
, &value_end
, 16);
2357 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2359 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2360 feature
->name
, value
);
2364 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2366 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2367 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2368 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2371 /* Record the new maximum packet size. */
2372 rs
->explicit_packet_size
= packet_size
;
2375 static struct protocol_feature remote_protocol_features
[] = {
2376 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2377 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2378 PACKET_qXfer_auxv
},
2379 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2380 PACKET_qXfer_features
},
2381 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2382 PACKET_qXfer_memory_map
},
2383 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
2384 PACKET_qXfer_spu_read
},
2385 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
2386 PACKET_qXfer_spu_write
},
2387 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2388 PACKET_QPassSignals
},
2392 remote_query_supported (void)
2394 struct remote_state
*rs
= get_remote_state ();
2397 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2399 /* The packet support flags are handled differently for this packet
2400 than for most others. We treat an error, a disabled packet, and
2401 an empty response identically: any features which must be reported
2402 to be used will be automatically disabled. An empty buffer
2403 accomplishes this, since that is also the representation for a list
2404 containing no features. */
2407 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2409 putpkt ("qSupported");
2410 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2412 /* If an error occured, warn, but do not return - just reset the
2413 buffer to empty and go on to disable features. */
2414 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2417 warning (_("Remote failure reply: %s"), rs
->buf
);
2422 memset (seen
, 0, sizeof (seen
));
2427 enum packet_support is_supported
;
2428 char *p
, *end
, *name_end
, *value
;
2430 /* First separate out this item from the rest of the packet. If
2431 there's another item after this, we overwrite the separator
2432 (terminated strings are much easier to work with). */
2434 end
= strchr (p
, ';');
2437 end
= p
+ strlen (p
);
2447 warning (_("empty item in \"qSupported\" response"));
2452 name_end
= strchr (p
, '=');
2455 /* This is a name=value entry. */
2456 is_supported
= PACKET_ENABLE
;
2457 value
= name_end
+ 1;
2466 is_supported
= PACKET_ENABLE
;
2470 is_supported
= PACKET_DISABLE
;
2474 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2478 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2484 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2485 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2487 const struct protocol_feature
*feature
;
2490 feature
= &remote_protocol_features
[i
];
2491 feature
->func (feature
, is_supported
, value
);
2496 /* If we increased the packet size, make sure to increase the global
2497 buffer size also. We delay this until after parsing the entire
2498 qSupported packet, because this is the same buffer we were
2500 if (rs
->buf_size
< rs
->explicit_packet_size
)
2502 rs
->buf_size
= rs
->explicit_packet_size
;
2503 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2506 /* Handle the defaults for unmentioned features. */
2507 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2510 const struct protocol_feature
*feature
;
2512 feature
= &remote_protocol_features
[i
];
2513 feature
->func (feature
, feature
->default_support
, NULL
);
2519 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2520 int extended_p
, int async_p
)
2522 struct remote_state
*rs
= get_remote_state ();
2524 error (_("To open a remote debug connection, you need to specify what\n"
2525 "serial device is attached to the remote system\n"
2526 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2528 /* See FIXME above. */
2530 wait_forever_enabled_p
= 1;
2532 target_preopen (from_tty
);
2534 unpush_target (target
);
2536 /* Make sure we send the passed signals list the next time we resume. */
2537 xfree (last_pass_packet
);
2538 last_pass_packet
= NULL
;
2540 remote_fileio_reset ();
2541 reopen_exec_file ();
2544 remote_desc
= remote_serial_open (name
);
2546 perror_with_name (name
);
2548 if (baud_rate
!= -1)
2550 if (serial_setbaudrate (remote_desc
, baud_rate
))
2552 /* The requested speed could not be set. Error out to
2553 top level after closing remote_desc. Take care to
2554 set remote_desc to NULL to avoid closing remote_desc
2556 serial_close (remote_desc
);
2558 perror_with_name (name
);
2562 serial_raw (remote_desc
);
2564 /* If there is something sitting in the buffer we might take it as a
2565 response to a command, which would be bad. */
2566 serial_flush_input (remote_desc
);
2570 puts_filtered ("Remote debugging using ");
2571 puts_filtered (name
);
2572 puts_filtered ("\n");
2574 push_target (target
); /* Switch to using remote target now. */
2576 /* Reset the target state; these things will be queried either by
2577 remote_query_supported or as they are needed. */
2578 init_all_packet_configs ();
2579 rs
->explicit_packet_size
= 0;
2581 general_thread
= -2;
2582 continue_thread
= -2;
2584 /* Probe for ability to use "ThreadInfo" query, as required. */
2585 use_threadinfo_query
= 1;
2586 use_threadextra_query
= 1;
2588 /* The first packet we send to the target is the optional "supported
2589 packets" request. If the target can answer this, it will tell us
2590 which later probes to skip. */
2591 remote_query_supported ();
2593 /* Next, if the target can specify a description, read it. We do
2594 this before anything involving memory or registers. */
2595 target_find_description ();
2597 /* Without this, some commands which require an active target (such
2598 as kill) won't work. This variable serves (at least) double duty
2599 as both the pid of the target process (if it has such), and as a
2600 flag indicating that a target is active. These functions should
2601 be split out into seperate variables, especially since GDB will
2602 someday have a notion of debugging several processes. */
2604 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2608 /* With this target we start out by owning the terminal. */
2609 remote_async_terminal_ours_p
= 1;
2611 /* FIXME: cagney/1999-09-23: During the initial connection it is
2612 assumed that the target is already ready and able to respond to
2613 requests. Unfortunately remote_start_remote() eventually calls
2614 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2615 around this. Eventually a mechanism that allows
2616 wait_for_inferior() to expect/get timeouts will be
2618 wait_forever_enabled_p
= 0;
2621 /* First delete any symbols previously loaded from shared libraries. */
2622 no_shared_libraries (NULL
, 0);
2624 /* Start the remote connection. If error() or QUIT, discard this
2625 target (we'd otherwise be in an inconsistent state) and then
2626 propogate the error on up the exception chain. This ensures that
2627 the caller doesn't stumble along blindly assuming that the
2628 function succeeded. The CLI doesn't have this problem but other
2629 UI's, such as MI do.
2631 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2632 this function should return an error indication letting the
2633 caller restore the previous state. Unfortunately the command
2634 ``target remote'' is directly wired to this function making that
2635 impossible. On a positive note, the CLI side of this problem has
2636 been fixed - the function set_cmd_context() makes it possible for
2637 all the ``target ....'' commands to share a common callback
2638 function. See cli-dump.c. */
2640 struct gdb_exception ex
2641 = catch_exception (uiout
, remote_start_remote
, &from_tty
,
2647 wait_forever_enabled_p
= 1;
2648 throw_exception (ex
);
2653 wait_forever_enabled_p
= 1;
2657 /* Tell the remote that we are using the extended protocol. */
2659 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2662 if (exec_bfd
) /* No use without an exec file. */
2663 remote_check_symbols (symfile_objfile
);
2666 /* This takes a program previously attached to and detaches it. After
2667 this is done, GDB can be used to debug some other program. We
2668 better not have left any breakpoints in the target program or it'll
2669 die when it hits one. */
2672 remote_detach (char *args
, int from_tty
)
2674 struct remote_state
*rs
= get_remote_state ();
2677 error (_("Argument given to \"detach\" when remotely debugging."));
2679 /* Tell the remote target to detach. */
2680 strcpy (rs
->buf
, "D");
2682 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2684 if (rs
->buf
[0] == 'E')
2685 error (_("Can't detach process."));
2687 /* Unregister the file descriptor from the event loop. */
2688 if (target_is_async_p ())
2689 serial_async (remote_desc
, NULL
, 0);
2691 target_mourn_inferior ();
2693 puts_filtered ("Ending remote debugging.\n");
2696 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2699 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2702 error (_("Argument given to \"detach\" when remotely debugging."));
2704 /* Unregister the file descriptor from the event loop. */
2705 if (target_is_async_p ())
2706 serial_async (remote_desc
, NULL
, 0);
2708 target_mourn_inferior ();
2710 puts_filtered ("Ending remote debugging.\n");
2713 /* Convert hex digit A to a number. */
2718 if (a
>= '0' && a
<= '9')
2720 else if (a
>= 'a' && a
<= 'f')
2721 return a
- 'a' + 10;
2722 else if (a
>= 'A' && a
<= 'F')
2723 return a
- 'A' + 10;
2725 error (_("Reply contains invalid hex digit %d"), a
);
2729 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2733 for (i
= 0; i
< count
; i
++)
2735 if (hex
[0] == 0 || hex
[1] == 0)
2737 /* Hex string is short, or of uneven length.
2738 Return the count that has been converted so far. */
2741 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2747 /* Convert number NIB to a hex digit. */
2755 return 'a' + nib
- 10;
2759 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2762 /* May use a length, or a nul-terminated string as input. */
2764 count
= strlen ((char *) bin
);
2766 for (i
= 0; i
< count
; i
++)
2768 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2769 *hex
++ = tohex (*bin
++ & 0xf);
2775 /* Check for the availability of vCont. This function should also check
2779 remote_vcont_probe (struct remote_state
*rs
)
2783 strcpy (rs
->buf
, "vCont?");
2785 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2788 /* Make sure that the features we assume are supported. */
2789 if (strncmp (buf
, "vCont", 5) == 0)
2792 int support_s
, support_S
, support_c
, support_C
;
2798 while (p
&& *p
== ';')
2801 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2803 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2805 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2807 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2810 p
= strchr (p
, ';');
2813 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2814 BUF will make packet_ok disable the packet. */
2815 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2819 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2822 /* Resume the remote inferior by using a "vCont" packet. The thread
2823 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2824 resumed thread should be single-stepped and/or signalled. If PTID's
2825 PID is -1, then all threads are resumed; the thread to be stepped and/or
2826 signalled is given in the global INFERIOR_PTID. This function returns
2827 non-zero iff it resumes the inferior.
2829 This function issues a strict subset of all possible vCont commands at the
2833 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2835 struct remote_state
*rs
= get_remote_state ();
2836 int pid
= PIDGET (ptid
);
2837 char *buf
= NULL
, *outbuf
;
2838 struct cleanup
*old_cleanup
;
2840 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2841 remote_vcont_probe (rs
);
2843 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2846 /* If we could generate a wider range of packets, we'd have to worry
2847 about overflowing BUF. Should there be a generic
2848 "multi-part-packet" packet? */
2850 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2852 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2853 don't have any PID numbers the inferior will understand. Make sure
2854 to only send forms that do not specify a PID. */
2855 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2856 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2858 outbuf
= xstrprintf ("vCont;s");
2859 else if (siggnal
!= TARGET_SIGNAL_0
)
2860 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2862 outbuf
= xstrprintf ("vCont;c");
2866 /* Resume all threads, with preference for INFERIOR_PTID. */
2867 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2868 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2869 PIDGET (inferior_ptid
));
2871 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2872 else if (siggnal
!= TARGET_SIGNAL_0
)
2873 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2874 PIDGET (inferior_ptid
));
2876 outbuf
= xstrprintf ("vCont;c");
2880 /* Scheduler locking; resume only PTID. */
2881 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2882 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2884 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2885 else if (siggnal
!= TARGET_SIGNAL_0
)
2886 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2888 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2891 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2892 old_cleanup
= make_cleanup (xfree
, outbuf
);
2896 do_cleanups (old_cleanup
);
2901 /* Tell the remote machine to resume. */
2903 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2905 static int last_sent_step
;
2908 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2910 struct remote_state
*rs
= get_remote_state ();
2912 int pid
= PIDGET (ptid
);
2914 last_sent_signal
= siggnal
;
2915 last_sent_step
= step
;
2917 /* A hook for when we need to do something at the last moment before
2919 if (deprecated_target_resume_hook
)
2920 (*deprecated_target_resume_hook
) ();
2922 /* Update the inferior on signals to silently pass, if they've changed. */
2923 remote_pass_signals ();
2925 /* The vCont packet doesn't need to specify threads via Hc. */
2926 if (remote_vcont_resume (ptid
, step
, siggnal
))
2929 /* All other supported resume packets do use Hc, so call set_thread. */
2931 set_thread (0, 0); /* Run any thread. */
2933 set_thread (pid
, 0); /* Run this thread. */
2936 if (siggnal
!= TARGET_SIGNAL_0
)
2938 buf
[0] = step
? 'S' : 'C';
2939 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2940 buf
[2] = tohex (((int) siggnal
) & 0xf);
2944 strcpy (buf
, step
? "s" : "c");
2949 /* Same as remote_resume, but with async support. */
2951 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2953 remote_resume (ptid
, step
, siggnal
);
2955 /* We are about to start executing the inferior, let's register it
2956 with the event loop. NOTE: this is the one place where all the
2957 execution commands end up. We could alternatively do this in each
2958 of the execution commands in infcmd.c. */
2959 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2960 into infcmd.c in order to allow inferior function calls to work
2961 NOT asynchronously. */
2962 if (target_can_async_p ())
2963 target_async (inferior_event_handler
, 0);
2964 /* Tell the world that the target is now executing. */
2965 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2966 this? Instead, should the client of target just assume (for
2967 async targets) that the target is going to start executing? Is
2968 this information already found in the continuation block? */
2969 if (target_is_async_p ())
2970 target_executing
= 1;
2974 /* Set up the signal handler for SIGINT, while the target is
2975 executing, ovewriting the 'regular' SIGINT signal handler. */
2977 initialize_sigint_signal_handler (void)
2979 sigint_remote_token
=
2980 create_async_signal_handler (async_remote_interrupt
, NULL
);
2981 signal (SIGINT
, handle_remote_sigint
);
2984 /* Signal handler for SIGINT, while the target is executing. */
2986 handle_remote_sigint (int sig
)
2988 signal (sig
, handle_remote_sigint_twice
);
2989 sigint_remote_twice_token
=
2990 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2991 mark_async_signal_handler_wrapper (sigint_remote_token
);
2994 /* Signal handler for SIGINT, installed after SIGINT has already been
2995 sent once. It will take effect the second time that the user sends
2998 handle_remote_sigint_twice (int sig
)
3000 signal (sig
, handle_sigint
);
3001 sigint_remote_twice_token
=
3002 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
3003 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
3006 /* Perform the real interruption of the target execution, in response
3009 async_remote_interrupt (gdb_client_data arg
)
3012 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3017 /* Perform interrupt, if the first attempt did not succeed. Just give
3018 up on the target alltogether. */
3020 async_remote_interrupt_twice (gdb_client_data arg
)
3023 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
3024 /* Do something only if the target was not killed by the previous
3026 if (target_executing
)
3029 signal (SIGINT
, handle_remote_sigint
);
3033 /* Reinstall the usual SIGINT handlers, after the target has
3036 cleanup_sigint_signal_handler (void *dummy
)
3038 signal (SIGINT
, handle_sigint
);
3039 if (sigint_remote_twice_token
)
3040 delete_async_signal_handler (&sigint_remote_twice_token
);
3041 if (sigint_remote_token
)
3042 delete_async_signal_handler (&sigint_remote_token
);
3045 /* Send ^C to target to halt it. Target will respond, and send us a
3047 static void (*ofunc
) (int);
3049 /* The command line interface's stop routine. This function is installed
3050 as a signal handler for SIGINT. The first time a user requests a
3051 stop, we call remote_stop to send a break or ^C. If there is no
3052 response from the target (it didn't stop when the user requested it),
3053 we ask the user if he'd like to detach from the target. */
3055 remote_interrupt (int signo
)
3057 /* If this doesn't work, try more severe steps. */
3058 signal (signo
, remote_interrupt_twice
);
3061 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
3066 /* The user typed ^C twice. */
3069 remote_interrupt_twice (int signo
)
3071 signal (signo
, ofunc
);
3073 signal (signo
, remote_interrupt
);
3076 /* This is the generic stop called via the target vector. When a target
3077 interrupt is requested, either by the command line or the GUI, we
3078 will eventually end up here. */
3082 /* Send a break or a ^C, depending on user preference. */
3084 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
3087 serial_send_break (remote_desc
);
3089 serial_write (remote_desc
, "\003", 1);
3092 /* Ask the user what to do when an interrupt is received. */
3095 interrupt_query (void)
3097 target_terminal_ours ();
3099 if (query ("Interrupted while waiting for the program.\n\
3100 Give up (and stop debugging it)? "))
3102 target_mourn_inferior ();
3103 deprecated_throw_reason (RETURN_QUIT
);
3106 target_terminal_inferior ();
3109 /* Enable/disable target terminal ownership. Most targets can use
3110 terminal groups to control terminal ownership. Remote targets are
3111 different in that explicit transfer of ownership to/from GDB/target
3115 remote_async_terminal_inferior (void)
3117 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3118 sync_execution here. This function should only be called when
3119 GDB is resuming the inferior in the forground. A background
3120 resume (``run&'') should leave GDB in control of the terminal and
3121 consequently should not call this code. */
3122 if (!sync_execution
)
3124 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3125 calls target_terminal_*() idenpotent. The event-loop GDB talking
3126 to an asynchronous target with a synchronous command calls this
3127 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3128 stops trying to transfer the terminal to the target when it
3129 shouldn't this guard can go away. */
3130 if (!remote_async_terminal_ours_p
)
3132 delete_file_handler (input_fd
);
3133 remote_async_terminal_ours_p
= 0;
3134 initialize_sigint_signal_handler ();
3135 /* NOTE: At this point we could also register our selves as the
3136 recipient of all input. Any characters typed could then be
3137 passed on down to the target. */
3141 remote_async_terminal_ours (void)
3143 /* See FIXME in remote_async_terminal_inferior. */
3144 if (!sync_execution
)
3146 /* See FIXME in remote_async_terminal_inferior. */
3147 if (remote_async_terminal_ours_p
)
3149 cleanup_sigint_signal_handler (NULL
);
3150 add_file_handler (input_fd
, stdin_event_handler
, 0);
3151 remote_async_terminal_ours_p
= 1;
3154 /* If nonzero, ignore the next kill. */
3159 remote_console_output (char *msg
)
3163 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3166 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3169 fputs_unfiltered (tb
, gdb_stdtarg
);
3171 gdb_flush (gdb_stdtarg
);
3174 /* Wait until the remote machine stops, then return,
3175 storing status in STATUS just as `wait' would.
3176 Returns "pid", which in the case of a multi-threaded
3177 remote OS, is the thread-id. */
3180 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3182 struct remote_state
*rs
= get_remote_state ();
3183 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3184 ULONGEST thread_num
= -1;
3187 status
->kind
= TARGET_WAITKIND_EXITED
;
3188 status
->value
.integer
= 0;
3194 ofunc
= signal (SIGINT
, remote_interrupt
);
3195 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3196 signal (SIGINT
, ofunc
);
3200 /* This is a hook for when we need to do something (perhaps the
3201 collection of trace data) every time the target stops. */
3202 if (deprecated_target_wait_loop_hook
)
3203 (*deprecated_target_wait_loop_hook
) ();
3205 remote_stopped_by_watchpoint_p
= 0;
3209 case 'E': /* Error of some sort. */
3210 warning (_("Remote failure reply: %s"), buf
);
3212 case 'F': /* File-I/O request. */
3213 remote_fileio_request (buf
);
3215 case 'T': /* Status with PC, SP, FP, ... */
3217 gdb_byte regs
[MAX_REGISTER_SIZE
];
3219 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3220 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3222 n... = register number
3223 r... = register contents
3225 p
= &buf
[3]; /* after Txx */
3234 /* If the packet contains a register number save it in
3235 pnum and set p1 to point to the character following
3236 it. Otherwise p1 points to p. */
3238 /* If this packet is an awatch packet, don't parse the
3239 'a' as a register number. */
3241 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3243 /* Read the ``P'' register number. */
3244 pnum
= strtol (p
, &p_temp
, 16);
3250 if (p1
== p
) /* No register number present here. */
3252 p1
= strchr (p
, ':');
3254 error (_("Malformed packet(a) (missing colon): %s\n\
3257 if (strncmp (p
, "thread", p1
- p
) == 0)
3259 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3260 record_currthread (thread_num
);
3263 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3264 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3265 || (strncmp (p
, "awatch", p1
- p
) == 0))
3267 remote_stopped_by_watchpoint_p
= 1;
3268 p
= unpack_varlen_hex (++p1
, &addr
);
3269 remote_watch_data_address
= (CORE_ADDR
)addr
;
3273 /* Silently skip unknown optional info. */
3274 p_temp
= strchr (p1
+ 1, ';');
3281 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3285 error (_("Malformed packet(b) (missing colon): %s\n\
3290 error (_("Remote sent bad register number %s: %s\n\
3292 phex_nz (pnum
, 0), p
, buf
);
3294 fieldsize
= hex2bin (p
, regs
,
3295 register_size (current_gdbarch
,
3298 if (fieldsize
< register_size (current_gdbarch
,
3300 warning (_("Remote reply is too short: %s"), buf
);
3301 regcache_raw_supply (get_current_regcache (),
3306 error (_("Remote register badly formatted: %s\nhere: %s"),
3311 case 'S': /* Old style status, just signal only. */
3312 status
->kind
= TARGET_WAITKIND_STOPPED
;
3313 status
->value
.sig
= (enum target_signal
)
3314 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3318 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3319 record_currthread (thread_num
);
3322 case 'W': /* Target exited. */
3324 /* The remote process exited. */
3325 status
->kind
= TARGET_WAITKIND_EXITED
;
3326 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3330 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3331 status
->value
.sig
= (enum target_signal
)
3332 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3336 case 'O': /* Console output. */
3337 remote_console_output (buf
+ 1);
3340 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3342 /* Zero length reply means that we tried 'S' or 'C' and
3343 the remote system doesn't support it. */
3344 target_terminal_ours_for_output ();
3346 ("Can't send signals to this remote system. %s not sent.\n",
3347 target_signal_to_name (last_sent_signal
));
3348 last_sent_signal
= TARGET_SIGNAL_0
;
3349 target_terminal_inferior ();
3351 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3352 putpkt ((char *) buf
);
3355 /* else fallthrough */
3357 warning (_("Invalid remote reply: %s"), buf
);
3362 if (thread_num
!= -1)
3364 return pid_to_ptid (thread_num
);
3366 return inferior_ptid
;
3369 /* Async version of remote_wait. */
3371 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3373 struct remote_state
*rs
= get_remote_state ();
3374 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3375 ULONGEST thread_num
= -1;
3378 status
->kind
= TARGET_WAITKIND_EXITED
;
3379 status
->value
.integer
= 0;
3381 remote_stopped_by_watchpoint_p
= 0;
3387 if (!target_is_async_p ())
3388 ofunc
= signal (SIGINT
, remote_interrupt
);
3389 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3390 _never_ wait for ever -> test on target_is_async_p().
3391 However, before we do that we need to ensure that the caller
3392 knows how to take the target into/out of async mode. */
3393 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3394 if (!target_is_async_p ())
3395 signal (SIGINT
, ofunc
);
3399 /* This is a hook for when we need to do something (perhaps the
3400 collection of trace data) every time the target stops. */
3401 if (deprecated_target_wait_loop_hook
)
3402 (*deprecated_target_wait_loop_hook
) ();
3406 case 'E': /* Error of some sort. */
3407 warning (_("Remote failure reply: %s"), buf
);
3409 case 'F': /* File-I/O request. */
3410 remote_fileio_request (buf
);
3412 case 'T': /* Status with PC, SP, FP, ... */
3414 gdb_byte regs
[MAX_REGISTER_SIZE
];
3416 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3417 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3419 n... = register number
3420 r... = register contents
3422 p
= &buf
[3]; /* after Txx */
3431 /* If the packet contains a register number, save it
3432 in pnum and set p1 to point to the character
3433 following it. Otherwise p1 points to p. */
3435 /* If this packet is an awatch packet, don't parse the 'a'
3436 as a register number. */
3438 if (!strncmp (p
, "awatch", strlen ("awatch")) != 0)
3440 /* Read the register number. */
3441 pnum
= strtol (p
, &p_temp
, 16);
3447 if (p1
== p
) /* No register number present here. */
3449 p1
= strchr (p
, ':');
3451 error (_("Malformed packet(a) (missing colon): %s\n\
3454 if (strncmp (p
, "thread", p1
- p
) == 0)
3456 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3457 record_currthread (thread_num
);
3460 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3461 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3462 || (strncmp (p
, "awatch", p1
- p
) == 0))
3464 remote_stopped_by_watchpoint_p
= 1;
3465 p
= unpack_varlen_hex (++p1
, &addr
);
3466 remote_watch_data_address
= (CORE_ADDR
)addr
;
3470 /* Silently skip unknown optional info. */
3471 p_temp
= strchr (p1
+ 1, ';');
3479 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3482 error (_("Malformed packet(b) (missing colon): %s\n\
3487 error (_("Remote sent bad register number %ld: %s\n\
3491 fieldsize
= hex2bin (p
, regs
,
3492 register_size (current_gdbarch
,
3495 if (fieldsize
< register_size (current_gdbarch
,
3497 warning (_("Remote reply is too short: %s"), buf
);
3498 regcache_raw_supply (get_current_regcache (),
3503 error (_("Remote register badly formatted: %s\nhere: %s"),
3508 case 'S': /* Old style status, just signal only. */
3509 status
->kind
= TARGET_WAITKIND_STOPPED
;
3510 status
->value
.sig
= (enum target_signal
)
3511 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3515 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3516 record_currthread (thread_num
);
3519 case 'W': /* Target exited. */
3521 /* The remote process exited. */
3522 status
->kind
= TARGET_WAITKIND_EXITED
;
3523 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3527 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3528 status
->value
.sig
= (enum target_signal
)
3529 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3533 case 'O': /* Console output. */
3534 remote_console_output (buf
+ 1);
3535 /* Return immediately to the event loop. The event loop will
3536 still be waiting on the inferior afterwards. */
3537 status
->kind
= TARGET_WAITKIND_IGNORE
;
3540 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3542 /* Zero length reply means that we tried 'S' or 'C' and
3543 the remote system doesn't support it. */
3544 target_terminal_ours_for_output ();
3546 ("Can't send signals to this remote system. %s not sent.\n",
3547 target_signal_to_name (last_sent_signal
));
3548 last_sent_signal
= TARGET_SIGNAL_0
;
3549 target_terminal_inferior ();
3551 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3552 putpkt ((char *) buf
);
3555 /* else fallthrough */
3557 warning (_("Invalid remote reply: %s"), buf
);
3562 if (thread_num
!= -1)
3564 return pid_to_ptid (thread_num
);
3566 return inferior_ptid
;
3569 /* Fetch a single register using a 'p' packet. */
3572 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3574 struct remote_state
*rs
= get_remote_state ();
3576 char regp
[MAX_REGISTER_SIZE
];
3579 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3582 if (reg
->pnum
== -1)
3587 p
+= hexnumstr (p
, reg
->pnum
);
3589 remote_send (&rs
->buf
, &rs
->buf_size
);
3593 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3597 case PACKET_UNKNOWN
:
3600 error (_("Could not fetch register \"%s\""),
3601 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3604 /* If this register is unfetchable, tell the regcache. */
3607 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3611 /* Otherwise, parse and supply the value. */
3617 error (_("fetch_register_using_p: early buf termination"));
3619 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3622 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3626 /* Fetch the registers included in the target's 'g' packet. */
3629 send_g_packet (void)
3631 struct remote_state
*rs
= get_remote_state ();
3636 sprintf (rs
->buf
, "g");
3637 remote_send (&rs
->buf
, &rs
->buf_size
);
3639 /* We can get out of synch in various cases. If the first character
3640 in the buffer is not a hex character, assume that has happened
3641 and try to fetch another packet to read. */
3642 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3643 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3644 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3645 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3648 fprintf_unfiltered (gdb_stdlog
,
3649 "Bad register packet; fetching a new packet\n");
3650 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3653 buf_len
= strlen (rs
->buf
);
3655 /* Sanity check the received packet. */
3656 if (buf_len
% 2 != 0)
3657 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3663 process_g_packet (struct regcache
*regcache
)
3665 struct remote_state
*rs
= get_remote_state ();
3666 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3671 buf_len
= strlen (rs
->buf
);
3673 /* Further sanity checks, with knowledge of the architecture. */
3674 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3675 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3677 /* Save the size of the packet sent to us by the target. It is used
3678 as a heuristic when determining the max size of packets that the
3679 target can safely receive. */
3680 if (rsa
->actual_register_packet_size
== 0)
3681 rsa
->actual_register_packet_size
= buf_len
;
3683 /* If this is smaller than we guessed the 'g' packet would be,
3684 update our records. A 'g' reply that doesn't include a register's
3685 value implies either that the register is not available, or that
3686 the 'p' packet must be used. */
3687 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3689 rsa
->sizeof_g_packet
= buf_len
/ 2;
3691 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3693 if (rsa
->regs
[i
].pnum
== -1)
3696 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3697 rsa
->regs
[i
].in_g_packet
= 0;
3699 rsa
->regs
[i
].in_g_packet
= 1;
3703 regs
= alloca (rsa
->sizeof_g_packet
);
3705 /* Unimplemented registers read as all bits zero. */
3706 memset (regs
, 0, rsa
->sizeof_g_packet
);
3708 /* Reply describes registers byte by byte, each byte encoded as two
3709 hex characters. Suck them all up, then supply them to the
3710 register cacheing/storage mechanism. */
3713 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3715 if (p
[0] == 0 || p
[1] == 0)
3716 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3717 internal_error (__FILE__
, __LINE__
,
3718 "unexpected end of 'g' packet reply");
3720 if (p
[0] == 'x' && p
[1] == 'x')
3721 regs
[i
] = 0; /* 'x' */
3723 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3729 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3731 struct packet_reg
*r
= &rsa
->regs
[i
];
3734 if (r
->offset
* 2 >= strlen (rs
->buf
))
3735 /* This shouldn't happen - we adjusted in_g_packet above. */
3736 internal_error (__FILE__
, __LINE__
,
3737 "unexpected end of 'g' packet reply");
3738 else if (rs
->buf
[r
->offset
* 2] == 'x')
3740 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3741 /* The register isn't available, mark it as such (at
3742 the same time setting the value to zero). */
3743 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3746 regcache_raw_supply (regcache
, r
->regnum
,
3754 fetch_registers_using_g (struct regcache
*regcache
)
3757 process_g_packet (regcache
);
3761 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3763 struct remote_state
*rs
= get_remote_state ();
3764 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3767 set_thread (PIDGET (inferior_ptid
), 1);
3771 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3772 gdb_assert (reg
!= NULL
);
3774 /* If this register might be in the 'g' packet, try that first -
3775 we are likely to read more than one register. If this is the
3776 first 'g' packet, we might be overly optimistic about its
3777 contents, so fall back to 'p'. */
3778 if (reg
->in_g_packet
)
3780 fetch_registers_using_g (regcache
);
3781 if (reg
->in_g_packet
)
3785 if (fetch_register_using_p (regcache
, reg
))
3788 /* This register is not available. */
3789 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3794 fetch_registers_using_g (regcache
);
3796 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3797 if (!rsa
->regs
[i
].in_g_packet
)
3798 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3800 /* This register is not available. */
3801 regcache_raw_supply (regcache
, i
, NULL
);
3805 /* Prepare to store registers. Since we may send them all (using a
3806 'G' request), we have to read out the ones we don't want to change
3810 remote_prepare_to_store (struct regcache
*regcache
)
3812 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3814 gdb_byte buf
[MAX_REGISTER_SIZE
];
3816 /* Make sure the entire registers array is valid. */
3817 switch (remote_protocol_packets
[PACKET_P
].support
)
3819 case PACKET_DISABLE
:
3820 case PACKET_SUPPORT_UNKNOWN
:
3821 /* Make sure all the necessary registers are cached. */
3822 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3823 if (rsa
->regs
[i
].in_g_packet
)
3824 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3831 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3832 packet was not recognized. */
3835 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3837 struct remote_state
*rs
= get_remote_state ();
3838 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3839 /* Try storing a single register. */
3840 char *buf
= rs
->buf
;
3841 gdb_byte regp
[MAX_REGISTER_SIZE
];
3844 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3847 if (reg
->pnum
== -1)
3850 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3851 p
= buf
+ strlen (buf
);
3852 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3853 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3854 remote_send (&rs
->buf
, &rs
->buf_size
);
3856 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3861 error (_("Could not write register \"%s\""),
3862 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3863 case PACKET_UNKNOWN
:
3866 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3870 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3871 contents of the register cache buffer. FIXME: ignores errors. */
3874 store_registers_using_G (const struct regcache
*regcache
)
3876 struct remote_state
*rs
= get_remote_state ();
3877 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3881 /* Extract all the registers in the regcache copying them into a
3885 regs
= alloca (rsa
->sizeof_g_packet
);
3886 memset (regs
, 0, rsa
->sizeof_g_packet
);
3887 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3889 struct packet_reg
*r
= &rsa
->regs
[i
];
3891 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3895 /* Command describes registers byte by byte,
3896 each byte encoded as two hex characters. */
3899 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3901 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3902 remote_send (&rs
->buf
, &rs
->buf_size
);
3905 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3906 of the register cache buffer. FIXME: ignores errors. */
3909 remote_store_registers (struct regcache
*regcache
, int regnum
)
3911 struct remote_state
*rs
= get_remote_state ();
3912 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3915 set_thread (PIDGET (inferior_ptid
), 1);
3919 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3920 gdb_assert (reg
!= NULL
);
3922 /* Always prefer to store registers using the 'P' packet if
3923 possible; we often change only a small number of registers.
3924 Sometimes we change a larger number; we'd need help from a
3925 higher layer to know to use 'G'. */
3926 if (store_register_using_P (regcache
, reg
))
3929 /* For now, don't complain if we have no way to write the
3930 register. GDB loses track of unavailable registers too
3931 easily. Some day, this may be an error. We don't have
3932 any way to read the register, either... */
3933 if (!reg
->in_g_packet
)
3936 store_registers_using_G (regcache
);
3940 store_registers_using_G (regcache
);
3942 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3943 if (!rsa
->regs
[i
].in_g_packet
)
3944 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
3945 /* See above for why we do not issue an error here. */
3950 /* Return the number of hex digits in num. */
3953 hexnumlen (ULONGEST num
)
3957 for (i
= 0; num
!= 0; i
++)
3963 /* Set BUF to the minimum number of hex digits representing NUM. */
3966 hexnumstr (char *buf
, ULONGEST num
)
3968 int len
= hexnumlen (num
);
3969 return hexnumnstr (buf
, num
, len
);
3973 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3976 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3982 for (i
= width
- 1; i
>= 0; i
--)
3984 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3991 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3994 remote_address_masked (CORE_ADDR addr
)
3996 if (remote_address_size
> 0
3997 && remote_address_size
< (sizeof (ULONGEST
) * 8))
3999 /* Only create a mask when that mask can safely be constructed
4000 in a ULONGEST variable. */
4002 mask
= (mask
<< remote_address_size
) - 1;
4008 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
4009 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
4010 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
4011 (which may be more than *OUT_LEN due to escape characters). The
4012 total number of bytes in the output buffer will be at most
4016 remote_escape_output (const gdb_byte
*buffer
, int len
,
4017 gdb_byte
*out_buf
, int *out_len
,
4020 int input_index
, output_index
;
4023 for (input_index
= 0; input_index
< len
; input_index
++)
4025 gdb_byte b
= buffer
[input_index
];
4027 if (b
== '$' || b
== '#' || b
== '}')
4029 /* These must be escaped. */
4030 if (output_index
+ 2 > out_maxlen
)
4032 out_buf
[output_index
++] = '}';
4033 out_buf
[output_index
++] = b
^ 0x20;
4037 if (output_index
+ 1 > out_maxlen
)
4039 out_buf
[output_index
++] = b
;
4043 *out_len
= input_index
;
4044 return output_index
;
4047 /* Convert BUFFER, escaped data LEN bytes long, into binary data
4048 in OUT_BUF. Return the number of bytes written to OUT_BUF.
4049 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
4051 This function reverses remote_escape_output. It allows more
4052 escaped characters than that function does, in particular because
4053 '*' must be escaped to avoid the run-length encoding processing
4054 in reading packets. */
4057 remote_unescape_input (const gdb_byte
*buffer
, int len
,
4058 gdb_byte
*out_buf
, int out_maxlen
)
4060 int input_index
, output_index
;
4065 for (input_index
= 0; input_index
< len
; input_index
++)
4067 gdb_byte b
= buffer
[input_index
];
4069 if (output_index
+ 1 > out_maxlen
)
4071 warning (_("Received too much data from remote target;"
4072 " ignoring overflow."));
4073 return output_index
;
4078 out_buf
[output_index
++] = b
^ 0x20;
4084 out_buf
[output_index
++] = b
;
4088 error (_("Unmatched escape character in target response."));
4090 return output_index
;
4093 /* Determine whether the remote target supports binary downloading.
4094 This is accomplished by sending a no-op memory write of zero length
4095 to the target at the specified address. It does not suffice to send
4096 the whole packet, since many stubs strip the eighth bit and
4097 subsequently compute a wrong checksum, which causes real havoc with
4100 NOTE: This can still lose if the serial line is not eight-bit
4101 clean. In cases like this, the user should clear "remote
4105 check_binary_download (CORE_ADDR addr
)
4107 struct remote_state
*rs
= get_remote_state ();
4109 switch (remote_protocol_packets
[PACKET_X
].support
)
4111 case PACKET_DISABLE
:
4115 case PACKET_SUPPORT_UNKNOWN
:
4121 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4123 p
+= hexnumstr (p
, (ULONGEST
) 0);
4127 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4128 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4130 if (rs
->buf
[0] == '\0')
4133 fprintf_unfiltered (gdb_stdlog
,
4134 "binary downloading NOT suppported by target\n");
4135 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4140 fprintf_unfiltered (gdb_stdlog
,
4141 "binary downloading suppported by target\n");
4142 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4149 /* Write memory data directly to the remote machine.
4150 This does not inform the data cache; the data cache uses this.
4151 HEADER is the starting part of the packet.
4152 MEMADDR is the address in the remote memory space.
4153 MYADDR is the address of the buffer in our space.
4154 LEN is the number of bytes.
4155 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4156 should send data as binary ('X'), or hex-encoded ('M').
4158 The function creates packet of the form
4159 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4161 where encoding of <DATA> is termined by PACKET_FORMAT.
4163 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4166 Returns the number of bytes transferred, or 0 (setting errno) for
4167 error. Only transfer a single packet. */
4170 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4171 const gdb_byte
*myaddr
, int len
,
4172 char packet_format
, int use_length
)
4174 struct remote_state
*rs
= get_remote_state ();
4184 if (packet_format
!= 'X' && packet_format
!= 'M')
4185 internal_error (__FILE__
, __LINE__
,
4186 "remote_write_bytes_aux: bad packet format");
4191 payload_size
= get_memory_write_packet_size ();
4193 /* The packet buffer will be large enough for the payload;
4194 get_memory_packet_size ensures this. */
4197 /* Compute the size of the actual payload by subtracting out the
4198 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4200 payload_size
-= strlen ("$,:#NN");
4202 /* The comma won't be used. */
4204 header_length
= strlen (header
);
4205 payload_size
-= header_length
;
4206 payload_size
-= hexnumlen (memaddr
);
4208 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4210 strcat (rs
->buf
, header
);
4211 p
= rs
->buf
+ strlen (header
);
4213 /* Compute a best guess of the number of bytes actually transfered. */
4214 if (packet_format
== 'X')
4216 /* Best guess at number of bytes that will fit. */
4217 todo
= min (len
, payload_size
);
4219 payload_size
-= hexnumlen (todo
);
4220 todo
= min (todo
, payload_size
);
4224 /* Num bytes that will fit. */
4225 todo
= min (len
, payload_size
/ 2);
4227 payload_size
-= hexnumlen (todo
);
4228 todo
= min (todo
, payload_size
/ 2);
4232 internal_error (__FILE__
, __LINE__
,
4233 _("minumum packet size too small to write data"));
4235 /* If we already need another packet, then try to align the end
4236 of this packet to a useful boundary. */
4237 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4238 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4240 /* Append "<memaddr>". */
4241 memaddr
= remote_address_masked (memaddr
);
4242 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4249 /* Append <len>. Retain the location/size of <len>. It may need to
4250 be adjusted once the packet body has been created. */
4252 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4260 /* Append the packet body. */
4261 if (packet_format
== 'X')
4263 /* Binary mode. Send target system values byte by byte, in
4264 increasing byte addresses. Only escape certain critical
4266 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4269 /* If not all TODO bytes fit, then we'll need another packet. Make
4270 a second try to keep the end of the packet aligned. Don't do
4271 this if the packet is tiny. */
4272 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4276 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4278 if (new_nr_bytes
!= nr_bytes
)
4279 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4284 p
+= payload_length
;
4285 if (use_length
&& nr_bytes
< todo
)
4287 /* Escape chars have filled up the buffer prematurely,
4288 and we have actually sent fewer bytes than planned.
4289 Fix-up the length field of the packet. Use the same
4290 number of characters as before. */
4291 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4292 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4297 /* Normal mode: Send target system values byte by byte, in
4298 increasing byte addresses. Each byte is encoded as a two hex
4300 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4304 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4305 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4307 if (rs
->buf
[0] == 'E')
4309 /* There is no correspondance between what the remote protocol
4310 uses for errors and errno codes. We would like a cleaner way
4311 of representing errors (big enough to include errno codes,
4312 bfd_error codes, and others). But for now just return EIO. */
4317 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4318 fewer bytes than we'd planned. */
4322 /* Write memory data directly to the remote machine.
4323 This does not inform the data cache; the data cache uses this.
4324 MEMADDR is the address in the remote memory space.
4325 MYADDR is the address of the buffer in our space.
4326 LEN is the number of bytes.
4328 Returns number of bytes transferred, or 0 (setting errno) for
4329 error. Only transfer a single packet. */
4332 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4334 char *packet_format
= 0;
4336 /* Check whether the target supports binary download. */
4337 check_binary_download (memaddr
);
4339 switch (remote_protocol_packets
[PACKET_X
].support
)
4342 packet_format
= "X";
4344 case PACKET_DISABLE
:
4345 packet_format
= "M";
4347 case PACKET_SUPPORT_UNKNOWN
:
4348 internal_error (__FILE__
, __LINE__
,
4349 _("remote_write_bytes: bad internal state"));
4351 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4354 return remote_write_bytes_aux (packet_format
,
4355 memaddr
, myaddr
, len
, packet_format
[0], 1);
4358 /* Read memory data directly from the remote machine.
4359 This does not use the data cache; the data cache uses this.
4360 MEMADDR is the address in the remote memory space.
4361 MYADDR is the address of the buffer in our space.
4362 LEN is the number of bytes.
4364 Returns number of bytes transferred, or 0 for error. */
4366 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4367 remote targets) shouldn't attempt to read the entire buffer.
4368 Instead it should read a single packet worth of data and then
4369 return the byte size of that packet to the caller. The caller (its
4370 caller and its callers caller ;-) already contains code for
4371 handling partial reads. */
4374 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4376 struct remote_state
*rs
= get_remote_state ();
4377 int max_buf_size
; /* Max size of packet output buffer. */
4383 max_buf_size
= get_memory_read_packet_size ();
4384 /* The packet buffer will be large enough for the payload;
4385 get_memory_packet_size ensures this. */
4394 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4396 /* construct "m"<memaddr>","<len>" */
4397 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4398 memaddr
= remote_address_masked (memaddr
);
4401 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4403 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4407 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4409 if (rs
->buf
[0] == 'E'
4410 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4411 && rs
->buf
[3] == '\0')
4413 /* There is no correspondance between what the remote
4414 protocol uses for errors and errno codes. We would like
4415 a cleaner way of representing errors (big enough to
4416 include errno codes, bfd_error codes, and others). But
4417 for now just return EIO. */
4422 /* Reply describes memory byte by byte,
4423 each byte encoded as two hex characters. */
4426 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4428 /* Reply is short. This means that we were able to read
4429 only part of what we wanted to. */
4430 return i
+ (origlen
- len
);
4439 /* Read or write LEN bytes from inferior memory at MEMADDR,
4440 transferring to or from debugger address BUFFER. Write to inferior
4441 if SHOULD_WRITE is nonzero. Returns length of data written or
4442 read; 0 for error. TARGET is unused. */
4445 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4446 int should_write
, struct mem_attrib
*attrib
,
4447 struct target_ops
*target
)
4452 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4454 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4459 /* Sends a packet with content determined by the printf format string
4460 FORMAT and the remaining arguments, then gets the reply. Returns
4461 whether the packet was a success, a failure, or unknown. */
4464 remote_send_printf (const char *format
, ...)
4466 struct remote_state
*rs
= get_remote_state ();
4467 int max_size
= get_remote_packet_size ();
4470 va_start (ap
, format
);
4473 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4474 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4476 if (putpkt (rs
->buf
) < 0)
4477 error (_("Communication problem with target."));
4480 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4482 return packet_check_result (rs
->buf
);
4486 restore_remote_timeout (void *p
)
4488 int value
= *(int *)p
;
4489 remote_timeout
= value
;
4492 /* Flash writing can take quite some time. We'll set
4493 effectively infinite timeout for flash operations.
4494 In future, we'll need to decide on a better approach. */
4495 static const int remote_flash_timeout
= 1000;
4498 remote_flash_erase (struct target_ops
*ops
,
4499 ULONGEST address
, LONGEST length
)
4501 int saved_remote_timeout
= remote_timeout
;
4502 enum packet_result ret
;
4504 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4505 &saved_remote_timeout
);
4506 remote_timeout
= remote_flash_timeout
;
4508 ret
= remote_send_printf ("vFlashErase:%s,%s",
4513 case PACKET_UNKNOWN
:
4514 error (_("Remote target does not support flash erase"));
4516 error (_("Error erasing flash with vFlashErase packet"));
4521 do_cleanups (back_to
);
4525 remote_flash_write (struct target_ops
*ops
,
4526 ULONGEST address
, LONGEST length
,
4527 const gdb_byte
*data
)
4529 int saved_remote_timeout
= remote_timeout
;
4531 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4532 &saved_remote_timeout
);
4534 remote_timeout
= remote_flash_timeout
;
4535 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4536 do_cleanups (back_to
);
4542 remote_flash_done (struct target_ops
*ops
)
4544 int saved_remote_timeout
= remote_timeout
;
4546 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4547 &saved_remote_timeout
);
4549 remote_timeout
= remote_flash_timeout
;
4550 ret
= remote_send_printf ("vFlashDone");
4551 do_cleanups (back_to
);
4555 case PACKET_UNKNOWN
:
4556 error (_("Remote target does not support vFlashDone"));
4558 error (_("Error finishing flash operation"));
4565 remote_files_info (struct target_ops
*ignore
)
4567 puts_filtered ("Debugging a target over a serial line.\n");
4570 /* Stuff for dealing with the packets which are part of this protocol.
4571 See comment at top of file for details. */
4573 /* Read a single character from the remote end. */
4576 readchar (int timeout
)
4580 ch
= serial_readchar (remote_desc
, timeout
);
4585 switch ((enum serial_rc
) ch
)
4588 target_mourn_inferior ();
4589 error (_("Remote connection closed"));
4592 perror_with_name (_("Remote communication error"));
4594 case SERIAL_TIMEOUT
:
4600 /* Send the command in *BUF to the remote machine, and read the reply
4601 into *BUF. Report an error if we get an error reply. Resize
4602 *BUF using xrealloc if necessary to hold the result, and update
4606 remote_send (char **buf
,
4610 getpkt (buf
, sizeof_buf
, 0);
4612 if ((*buf
)[0] == 'E')
4613 error (_("Remote failure reply: %s"), *buf
);
4616 /* Display a null-terminated packet on stdout, for debugging, using C
4620 print_packet (char *buf
)
4622 puts_filtered ("\"");
4623 fputstr_filtered (buf
, '"', gdb_stdout
);
4624 puts_filtered ("\"");
4630 return putpkt_binary (buf
, strlen (buf
));
4633 /* Send a packet to the remote machine, with error checking. The data
4634 of the packet is in BUF. The string in BUF can be at most
4635 get_remote_packet_size () - 5 to account for the $, # and checksum,
4636 and for a possible /0 if we are debugging (remote_debug) and want
4637 to print the sent packet as a string. */
4640 putpkt_binary (char *buf
, int cnt
)
4643 unsigned char csum
= 0;
4644 char *buf2
= alloca (cnt
+ 6);
4650 /* Copy the packet into buffer BUF2, encapsulating it
4651 and giving it a checksum. */
4656 for (i
= 0; i
< cnt
; i
++)
4662 *p
++ = tohex ((csum
>> 4) & 0xf);
4663 *p
++ = tohex (csum
& 0xf);
4665 /* Send it over and over until we get a positive ack. */
4669 int started_error_output
= 0;
4674 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4675 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4676 fprintf_unfiltered (gdb_stdlog
, "...");
4677 gdb_flush (gdb_stdlog
);
4679 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4680 perror_with_name (_("putpkt: write failed"));
4682 /* Read until either a timeout occurs (-2) or '+' is read. */
4685 ch
= readchar (remote_timeout
);
4693 case SERIAL_TIMEOUT
:
4695 if (started_error_output
)
4697 putchar_unfiltered ('\n');
4698 started_error_output
= 0;
4707 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4711 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4712 case SERIAL_TIMEOUT
:
4716 break; /* Retransmit buffer. */
4720 fprintf_unfiltered (gdb_stdlog
,
4721 "Packet instead of Ack, ignoring it\n");
4722 /* It's probably an old response sent because an ACK
4723 was lost. Gobble up the packet and ack it so it
4724 doesn't get retransmitted when we resend this
4727 serial_write (remote_desc
, "+", 1);
4728 continue; /* Now, go look for +. */
4733 if (!started_error_output
)
4735 started_error_output
= 1;
4736 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4738 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4742 break; /* Here to retransmit. */
4746 /* This is wrong. If doing a long backtrace, the user should be
4747 able to get out next time we call QUIT, without anything as
4748 violent as interrupt_query. If we want to provide a way out of
4749 here without getting to the next QUIT, it should be based on
4750 hitting ^C twice as in remote_wait. */
4760 /* Come here after finding the start of a frame when we expected an
4761 ack. Do our best to discard the rest of this packet. */
4770 c
= readchar (remote_timeout
);
4773 case SERIAL_TIMEOUT
:
4774 /* Nothing we can do. */
4777 /* Discard the two bytes of checksum and stop. */
4778 c
= readchar (remote_timeout
);
4780 c
= readchar (remote_timeout
);
4783 case '*': /* Run length encoding. */
4784 /* Discard the repeat count. */
4785 c
= readchar (remote_timeout
);
4790 /* A regular character. */
4796 /* Come here after finding the start of the frame. Collect the rest
4797 into *BUF, verifying the checksum, length, and handling run-length
4798 compression. NUL terminate the buffer. If there is not enough room,
4799 expand *BUF using xrealloc.
4801 Returns -1 on error, number of characters in buffer (ignoring the
4802 trailing NULL) on success. (could be extended to return one of the
4803 SERIAL status indications). */
4806 read_frame (char **buf_p
,
4819 c
= readchar (remote_timeout
);
4822 case SERIAL_TIMEOUT
:
4824 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4828 fputs_filtered ("Saw new packet start in middle of old one\n",
4830 return -1; /* Start a new packet, count retries. */
4833 unsigned char pktcsum
;
4839 check_0
= readchar (remote_timeout
);
4841 check_1
= readchar (remote_timeout
);
4843 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4846 fputs_filtered ("Timeout in checksum, retrying\n",
4850 else if (check_0
< 0 || check_1
< 0)
4853 fputs_filtered ("Communication error in checksum\n",
4858 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4859 if (csum
== pktcsum
)
4864 fprintf_filtered (gdb_stdlog
,
4865 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4867 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4868 fputs_filtered ("\n", gdb_stdlog
);
4870 /* Number of characters in buffer ignoring trailing
4874 case '*': /* Run length encoding. */
4879 c
= readchar (remote_timeout
);
4881 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4883 /* The character before ``*'' is repeated. */
4885 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4887 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4889 /* Make some more room in the buffer. */
4890 *sizeof_buf
+= repeat
;
4891 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4895 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4901 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4905 if (bc
>= *sizeof_buf
- 1)
4907 /* Make some more room in the buffer. */
4909 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4920 /* Read a packet from the remote machine, with error checking, and
4921 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4922 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4923 rather than timing out; this is used (in synchronous mode) to wait
4924 for a target that is is executing user code to stop. */
4925 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4926 don't have to change all the calls to getpkt to deal with the
4927 return value, because at the moment I don't know what the right
4928 thing to do it for those. */
4936 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4940 /* Read a packet from the remote machine, with error checking, and
4941 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4942 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4943 rather than timing out; this is used (in synchronous mode) to wait
4944 for a target that is is executing user code to stop. If FOREVER ==
4945 0, this function is allowed to time out gracefully and return an
4946 indication of this to the caller. Otherwise return the number
4949 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4956 strcpy (*buf
, "timeout");
4960 timeout
= watchdog
> 0 ? watchdog
: -1;
4964 timeout
= remote_timeout
;
4968 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4970 /* This can loop forever if the remote side sends us characters
4971 continuously, but if it pauses, we'll get a zero from
4972 readchar because of timeout. Then we'll count that as a
4975 /* Note that we will only wait forever prior to the start of a
4976 packet. After that, we expect characters to arrive at a
4977 brisk pace. They should show up within remote_timeout
4982 c
= readchar (timeout
);
4984 if (c
== SERIAL_TIMEOUT
)
4986 if (forever
) /* Watchdog went off? Kill the target. */
4989 target_mourn_inferior ();
4990 error (_("Watchdog has expired. Target detached."));
4993 fputs_filtered ("Timed out.\n", gdb_stdlog
);
4999 /* We've found the start of a packet, now collect the data. */
5001 val
= read_frame (buf
, sizeof_buf
);
5007 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
5008 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
5009 fprintf_unfiltered (gdb_stdlog
, "\n");
5011 serial_write (remote_desc
, "+", 1);
5015 /* Try the whole thing again. */
5017 serial_write (remote_desc
, "-", 1);
5020 /* We have tried hard enough, and just can't receive the packet.
5023 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
5024 serial_write (remote_desc
, "+", 1);
5031 /* For some mysterious reason, wait_for_inferior calls kill instead of
5032 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5036 target_mourn_inferior ();
5040 /* Use catch_errors so the user can quit from gdb even when we aren't on
5041 speaking terms with the remote system. */
5042 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5044 /* Don't wait for it to die. I'm not really sure it matters whether
5045 we do or not. For the existing stubs, kill is a noop. */
5046 target_mourn_inferior ();
5049 /* Async version of remote_kill. */
5051 remote_async_kill (void)
5053 /* Unregister the file descriptor from the event loop. */
5054 if (target_is_async_p ())
5055 serial_async (remote_desc
, NULL
, 0);
5057 /* For some mysterious reason, wait_for_inferior calls kill instead of
5058 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
5062 target_mourn_inferior ();
5066 /* Use catch_errors so the user can quit from gdb even when we
5067 aren't on speaking terms with the remote system. */
5068 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
5070 /* Don't wait for it to die. I'm not really sure it matters whether
5071 we do or not. For the existing stubs, kill is a noop. */
5072 target_mourn_inferior ();
5078 remote_mourn_1 (&remote_ops
);
5082 remote_async_mourn (void)
5084 remote_mourn_1 (&remote_async_ops
);
5088 extended_remote_mourn (void)
5090 /* We do _not_ want to mourn the target like this; this will
5091 remove the extended remote target from the target stack,
5092 and the next time the user says "run" it'll fail.
5094 FIXME: What is the right thing to do here? */
5096 remote_mourn_1 (&extended_remote_ops
);
5100 /* Worker function for remote_mourn. */
5102 remote_mourn_1 (struct target_ops
*target
)
5104 unpush_target (target
);
5105 generic_mourn_inferior ();
5108 /* In the extended protocol we want to be able to do things like
5109 "run" and have them basically work as expected. So we need
5110 a special create_inferior function.
5112 FIXME: One day add support for changing the exec file
5113 we're debugging, arguments and an environment. */
5116 extended_remote_create_inferior (char *exec_file
, char *args
,
5117 char **env
, int from_tty
)
5119 /* Rip out the breakpoints; we'll reinsert them after restarting
5120 the remote server. */
5121 remove_breakpoints ();
5123 /* Now restart the remote server. */
5124 extended_remote_restart ();
5126 /* NOTE: We don't need to recheck for a target description here; but
5127 if we gain the ability to switch the remote executable we may
5128 need to, if for instance we are running a process which requested
5129 different emulated hardware from the operating system. A
5130 concrete example of this is ARM GNU/Linux, where some binaries
5131 will have a legacy FPA coprocessor emulated and others may have
5132 access to a hardware VFP unit. */
5134 /* Now put the breakpoints back in. This way we're safe if the
5135 restart function works via a unix fork on the remote side. */
5136 insert_breakpoints ();
5138 /* Clean up from the last time we were running. */
5139 clear_proceed_status ();
5142 /* Async version of extended_remote_create_inferior. */
5144 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5145 char **env
, int from_tty
)
5147 /* Rip out the breakpoints; we'll reinsert them after restarting
5148 the remote server. */
5149 remove_breakpoints ();
5151 /* If running asynchronously, register the target file descriptor
5152 with the event loop. */
5153 if (target_can_async_p ())
5154 target_async (inferior_event_handler
, 0);
5156 /* Now restart the remote server. */
5157 extended_remote_restart ();
5159 /* NOTE: We don't need to recheck for a target description here; but
5160 if we gain the ability to switch the remote executable we may
5161 need to, if for instance we are running a process which requested
5162 different emulated hardware from the operating system. A
5163 concrete example of this is ARM GNU/Linux, where some binaries
5164 will have a legacy FPA coprocessor emulated and others may have
5165 access to a hardware VFP unit. */
5167 /* Now put the breakpoints back in. This way we're safe if the
5168 restart function works via a unix fork on the remote side. */
5169 insert_breakpoints ();
5171 /* Clean up from the last time we were running. */
5172 clear_proceed_status ();
5176 /* Insert a breakpoint. On targets that have software breakpoint
5177 support, we ask the remote target to do the work; on targets
5178 which don't, we insert a traditional memory breakpoint. */
5181 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5183 CORE_ADDR addr
= bp_tgt
->placed_address
;
5184 struct remote_state
*rs
= get_remote_state ();
5186 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5187 If it succeeds, then set the support to PACKET_ENABLE. If it
5188 fails, and the user has explicitly requested the Z support then
5189 report an error, otherwise, mark it disabled and go on. */
5191 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5198 gdbarch_breakpoint_from_pc
5199 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5200 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5201 p
+= hexnumstr (p
, addr
);
5202 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5205 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5207 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5213 case PACKET_UNKNOWN
:
5218 return memory_insert_breakpoint (bp_tgt
);
5222 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5224 CORE_ADDR addr
= bp_tgt
->placed_address
;
5225 struct remote_state
*rs
= get_remote_state ();
5228 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5236 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5237 p
+= hexnumstr (p
, addr
);
5238 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5241 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5243 return (rs
->buf
[0] == 'E');
5246 return memory_remove_breakpoint (bp_tgt
);
5250 watchpoint_to_Z_packet (int type
)
5255 return Z_PACKET_WRITE_WP
;
5258 return Z_PACKET_READ_WP
;
5261 return Z_PACKET_ACCESS_WP
;
5264 internal_error (__FILE__
, __LINE__
,
5265 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5270 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5272 struct remote_state
*rs
= get_remote_state ();
5274 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5276 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5279 sprintf (rs
->buf
, "Z%x,", packet
);
5280 p
= strchr (rs
->buf
, '\0');
5281 addr
= remote_address_masked (addr
);
5282 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5283 sprintf (p
, ",%x", len
);
5286 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5288 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5291 case PACKET_UNKNOWN
:
5296 internal_error (__FILE__
, __LINE__
,
5297 _("remote_insert_watchpoint: reached end of function"));
5302 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5304 struct remote_state
*rs
= get_remote_state ();
5306 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5308 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5311 sprintf (rs
->buf
, "z%x,", packet
);
5312 p
= strchr (rs
->buf
, '\0');
5313 addr
= remote_address_masked (addr
);
5314 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5315 sprintf (p
, ",%x", len
);
5317 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5319 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5322 case PACKET_UNKNOWN
:
5327 internal_error (__FILE__
, __LINE__
,
5328 _("remote_remove_watchpoint: reached end of function"));
5332 int remote_hw_watchpoint_limit
= -1;
5333 int remote_hw_breakpoint_limit
= -1;
5336 remote_check_watch_resources (int type
, int cnt
, int ot
)
5338 if (type
== bp_hardware_breakpoint
)
5340 if (remote_hw_breakpoint_limit
== 0)
5342 else if (remote_hw_breakpoint_limit
< 0)
5344 else if (cnt
<= remote_hw_breakpoint_limit
)
5349 if (remote_hw_watchpoint_limit
== 0)
5351 else if (remote_hw_watchpoint_limit
< 0)
5355 else if (cnt
<= remote_hw_watchpoint_limit
)
5362 remote_stopped_by_watchpoint (void)
5364 return remote_stopped_by_watchpoint_p
;
5367 extern int stepped_after_stopped_by_watchpoint
;
5370 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5373 if (remote_stopped_by_watchpoint ()
5374 || stepped_after_stopped_by_watchpoint
)
5376 *addr_p
= remote_watch_data_address
;
5385 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5388 struct remote_state
*rs
= get_remote_state ();
5391 /* The length field should be set to the size of a breakpoint
5392 instruction, even though we aren't inserting one ourselves. */
5394 gdbarch_breakpoint_from_pc
5395 (current_gdbarch
, &bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5397 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5404 addr
= remote_address_masked (bp_tgt
->placed_address
);
5405 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5406 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5409 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5411 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5414 case PACKET_UNKNOWN
:
5419 internal_error (__FILE__
, __LINE__
,
5420 _("remote_insert_hw_breakpoint: reached end of function"));
5425 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5428 struct remote_state
*rs
= get_remote_state ();
5431 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5438 addr
= remote_address_masked (bp_tgt
->placed_address
);
5439 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5440 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5443 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5445 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5448 case PACKET_UNKNOWN
:
5453 internal_error (__FILE__
, __LINE__
,
5454 _("remote_remove_hw_breakpoint: reached end of function"));
5457 /* Some targets are only capable of doing downloads, and afterwards
5458 they switch to the remote serial protocol. This function provides
5459 a clean way to get from the download target to the remote target.
5460 It's basically just a wrapper so that we don't have to expose any
5461 of the internal workings of remote.c.
5463 Prior to calling this routine, you should shutdown the current
5464 target code, else you will get the "A program is being debugged
5465 already..." message. Usually a call to pop_target() suffices. */
5468 push_remote_target (char *name
, int from_tty
)
5470 printf_filtered (_("Switching to remote protocol\n"));
5471 remote_open (name
, from_tty
);
5474 /* Table used by the crc32 function to calcuate the checksum. */
5476 static unsigned long crc32_table
[256] =
5479 static unsigned long
5480 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5482 if (!crc32_table
[1])
5484 /* Initialize the CRC table and the decoding table. */
5488 for (i
= 0; i
< 256; i
++)
5490 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5491 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5498 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5504 /* compare-sections command
5506 With no arguments, compares each loadable section in the exec bfd
5507 with the same memory range on the target, and reports mismatches.
5508 Useful for verifying the image on the target against the exec file.
5509 Depends on the target understanding the new "qCRC:" request. */
5511 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5512 target method (target verify memory) and generic version of the
5513 actual command. This will allow other high-level code (especially
5514 generic_load()) to make use of this target functionality. */
5517 compare_sections_command (char *args
, int from_tty
)
5519 struct remote_state
*rs
= get_remote_state ();
5521 unsigned long host_crc
, target_crc
;
5522 extern bfd
*exec_bfd
;
5523 struct cleanup
*old_chain
;
5526 const char *sectname
;
5533 error (_("command cannot be used without an exec file"));
5534 if (!current_target
.to_shortname
||
5535 strcmp (current_target
.to_shortname
, "remote") != 0)
5536 error (_("command can only be used with remote target"));
5538 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5540 if (!(s
->flags
& SEC_LOAD
))
5541 continue; /* skip non-loadable section */
5543 size
= bfd_get_section_size (s
);
5545 continue; /* skip zero-length section */
5547 sectname
= bfd_get_section_name (exec_bfd
, s
);
5548 if (args
&& strcmp (args
, sectname
) != 0)
5549 continue; /* not the section selected by user */
5551 matched
= 1; /* do this section */
5553 /* FIXME: assumes lma can fit into long. */
5554 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5555 (long) lma
, (long) size
);
5558 /* Be clever; compute the host_crc before waiting for target
5560 sectdata
= xmalloc (size
);
5561 old_chain
= make_cleanup (xfree
, sectdata
);
5562 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5563 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5565 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5566 if (rs
->buf
[0] == 'E')
5567 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5568 sectname
, paddr (lma
), paddr (lma
+ size
));
5569 if (rs
->buf
[0] != 'C')
5570 error (_("remote target does not support this operation"));
5572 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5573 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5575 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5576 sectname
, paddr (lma
), paddr (lma
+ size
));
5577 if (host_crc
== target_crc
)
5578 printf_filtered ("matched.\n");
5581 printf_filtered ("MIS-MATCHED!\n");
5585 do_cleanups (old_chain
);
5588 warning (_("One or more sections of the remote executable does not match\n\
5589 the loaded file\n"));
5590 if (args
&& !matched
)
5591 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5594 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5595 into remote target. The number of bytes written to the remote
5596 target is returned, or -1 for error. */
5599 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
5600 const char *annex
, const gdb_byte
*writebuf
,
5601 ULONGEST offset
, LONGEST len
,
5602 struct packet_config
*packet
)
5607 struct remote_state
*rs
= get_remote_state ();
5608 int max_size
= get_memory_write_packet_size ();
5610 if (packet
->support
== PACKET_DISABLE
)
5613 /* Insert header. */
5614 i
= snprintf (rs
->buf
, max_size
,
5615 "qXfer:%s:write:%s:%s:",
5616 object_name
, annex
? annex
: "",
5617 phex_nz (offset
, sizeof offset
));
5618 max_size
-= (i
+ 1);
5620 /* Escape as much data as fits into rs->buf. */
5621 buf_len
= remote_escape_output
5622 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
5624 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
5625 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
5626 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5629 unpack_varlen_hex (rs
->buf
, &n
);
5633 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5634 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5635 number of bytes read is returned, or 0 for EOF, or -1 for error.
5636 The number of bytes read may be less than LEN without indicating an
5637 EOF. PACKET is checked and updated to indicate whether the remote
5638 target supports this object. */
5641 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5643 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5644 struct packet_config
*packet
)
5646 static char *finished_object
;
5647 static char *finished_annex
;
5648 static ULONGEST finished_offset
;
5650 struct remote_state
*rs
= get_remote_state ();
5651 unsigned int total
= 0;
5652 LONGEST i
, n
, packet_len
;
5654 if (packet
->support
== PACKET_DISABLE
)
5657 /* Check whether we've cached an end-of-object packet that matches
5659 if (finished_object
)
5661 if (strcmp (object_name
, finished_object
) == 0
5662 && strcmp (annex
? annex
: "", finished_annex
) == 0
5663 && offset
== finished_offset
)
5666 /* Otherwise, we're now reading something different. Discard
5668 xfree (finished_object
);
5669 xfree (finished_annex
);
5670 finished_object
= NULL
;
5671 finished_annex
= NULL
;
5674 /* Request only enough to fit in a single packet. The actual data
5675 may not, since we don't know how much of it will need to be escaped;
5676 the target is free to respond with slightly less data. We subtract
5677 five to account for the response type and the protocol frame. */
5678 n
= min (get_remote_packet_size () - 5, len
);
5679 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5680 object_name
, annex
? annex
: "",
5681 phex_nz (offset
, sizeof offset
),
5682 phex_nz (n
, sizeof n
));
5683 i
= putpkt (rs
->buf
);
5688 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5689 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5692 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5693 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5695 /* 'm' means there is (or at least might be) more data after this
5696 batch. That does not make sense unless there's at least one byte
5697 of data in this reply. */
5698 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5699 error (_("Remote qXfer reply contained no data."));
5701 /* Got some data. */
5702 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5704 /* 'l' is an EOF marker, possibly including a final block of data,
5705 or possibly empty. If we have the final block of a non-empty
5706 object, record this fact to bypass a subsequent partial read. */
5707 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
5709 finished_object
= xstrdup (object_name
);
5710 finished_annex
= xstrdup (annex
? annex
: "");
5711 finished_offset
= offset
+ i
;
5718 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5719 const char *annex
, gdb_byte
*readbuf
,
5720 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5722 struct remote_state
*rs
= get_remote_state ();
5727 /* Handle memory using the standard memory routines. */
5728 if (object
== TARGET_OBJECT_MEMORY
)
5733 if (writebuf
!= NULL
)
5734 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5736 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5740 else if (xfered
== 0 && errno
== 0)
5746 /* Handle SPU memory using qxfer packets. */
5747 if (object
== TARGET_OBJECT_SPU
)
5750 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
5751 &remote_protocol_packets
5752 [PACKET_qXfer_spu_read
]);
5754 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
5755 &remote_protocol_packets
5756 [PACKET_qXfer_spu_write
]);
5759 /* Only handle flash writes. */
5760 if (writebuf
!= NULL
)
5766 case TARGET_OBJECT_FLASH
:
5767 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5771 else if (xfered
== 0 && errno
== 0)
5781 /* Map pre-existing objects onto letters. DO NOT do this for new
5782 objects!!! Instead specify new query packets. */
5785 case TARGET_OBJECT_AVR
:
5789 case TARGET_OBJECT_AUXV
:
5790 gdb_assert (annex
== NULL
);
5791 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5792 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5794 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5795 return remote_read_qxfer
5796 (ops
, "features", annex
, readbuf
, offset
, len
,
5797 &remote_protocol_packets
[PACKET_qXfer_features
]);
5799 case TARGET_OBJECT_MEMORY_MAP
:
5800 gdb_assert (annex
== NULL
);
5801 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5802 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5808 /* Note: a zero OFFSET and LEN can be used to query the minimum
5810 if (offset
== 0 && len
== 0)
5811 return (get_remote_packet_size ());
5812 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5813 large enough let the caller deal with it. */
5814 if (len
< get_remote_packet_size ())
5816 len
= get_remote_packet_size ();
5818 /* Except for querying the minimum buffer size, target must be open. */
5820 error (_("remote query is only available after target open"));
5822 gdb_assert (annex
!= NULL
);
5823 gdb_assert (readbuf
!= NULL
);
5829 /* We used one buffer char for the remote protocol q command and
5830 another for the query type. As the remote protocol encapsulation
5831 uses 4 chars plus one extra in case we are debugging
5832 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5835 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5837 /* Bad caller may have sent forbidden characters. */
5838 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5843 gdb_assert (annex
[i
] == '\0');
5845 i
= putpkt (rs
->buf
);
5849 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5850 strcpy ((char *) readbuf
, rs
->buf
);
5852 return strlen ((char *) readbuf
);
5856 remote_rcmd (char *command
,
5857 struct ui_file
*outbuf
)
5859 struct remote_state
*rs
= get_remote_state ();
5863 error (_("remote rcmd is only available after target open"));
5865 /* Send a NULL command across as an empty command. */
5866 if (command
== NULL
)
5869 /* The query prefix. */
5870 strcpy (rs
->buf
, "qRcmd,");
5871 p
= strchr (rs
->buf
, '\0');
5873 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5874 error (_("\"monitor\" command ``%s'' is too long."), command
);
5876 /* Encode the actual command. */
5877 bin2hex ((gdb_byte
*) command
, p
, 0);
5879 if (putpkt (rs
->buf
) < 0)
5880 error (_("Communication problem with target."));
5882 /* get/display the response */
5887 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5889 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5892 error (_("Target does not support this command."));
5893 if (buf
[0] == 'O' && buf
[1] != 'K')
5895 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5898 if (strcmp (buf
, "OK") == 0)
5900 if (strlen (buf
) == 3 && buf
[0] == 'E'
5901 && isdigit (buf
[1]) && isdigit (buf
[2]))
5903 error (_("Protocol error with Rcmd"));
5905 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5907 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5908 fputc_unfiltered (c
, outbuf
);
5914 static VEC(mem_region_s
) *
5915 remote_memory_map (struct target_ops
*ops
)
5917 VEC(mem_region_s
) *result
= NULL
;
5918 char *text
= target_read_stralloc (¤t_target
,
5919 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5923 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5924 result
= parse_memory_map (text
);
5925 do_cleanups (back_to
);
5932 packet_command (char *args
, int from_tty
)
5934 struct remote_state
*rs
= get_remote_state ();
5937 error (_("command can only be used with remote target"));
5940 error (_("remote-packet command requires packet text as argument"));
5942 puts_filtered ("sending: ");
5943 print_packet (args
);
5944 puts_filtered ("\n");
5947 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5948 puts_filtered ("received: ");
5949 print_packet (rs
->buf
);
5950 puts_filtered ("\n");
5954 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5956 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5958 static void threadset_test_cmd (char *cmd
, int tty
);
5960 static void threadalive_test (char *cmd
, int tty
);
5962 static void threadlist_test_cmd (char *cmd
, int tty
);
5964 int get_and_display_threadinfo (threadref
*ref
);
5966 static void threadinfo_test_cmd (char *cmd
, int tty
);
5968 static int thread_display_step (threadref
*ref
, void *context
);
5970 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5972 static void init_remote_threadtests (void);
5974 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5977 threadset_test_cmd (char *cmd
, int tty
)
5979 int sample_thread
= SAMPLE_THREAD
;
5981 printf_filtered (_("Remote threadset test\n"));
5982 set_thread (sample_thread
, 1);
5987 threadalive_test (char *cmd
, int tty
)
5989 int sample_thread
= SAMPLE_THREAD
;
5991 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5992 printf_filtered ("PASS: Thread alive test\n");
5994 printf_filtered ("FAIL: Thread alive test\n");
5997 void output_threadid (char *title
, threadref
*ref
);
6000 output_threadid (char *title
, threadref
*ref
)
6004 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
6006 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
6010 threadlist_test_cmd (char *cmd
, int tty
)
6013 threadref nextthread
;
6014 int done
, result_count
;
6015 threadref threadlist
[3];
6017 printf_filtered ("Remote Threadlist test\n");
6018 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
6019 &result_count
, &threadlist
[0]))
6020 printf_filtered ("FAIL: threadlist test\n");
6023 threadref
*scan
= threadlist
;
6024 threadref
*limit
= scan
+ result_count
;
6026 while (scan
< limit
)
6027 output_threadid (" thread ", scan
++);
6032 display_thread_info (struct gdb_ext_thread_info
*info
)
6034 output_threadid ("Threadid: ", &info
->threadid
);
6035 printf_filtered ("Name: %s\n ", info
->shortname
);
6036 printf_filtered ("State: %s\n", info
->display
);
6037 printf_filtered ("other: %s\n\n", info
->more_display
);
6041 get_and_display_threadinfo (threadref
*ref
)
6045 struct gdb_ext_thread_info threadinfo
;
6047 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
6048 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
6049 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
6050 display_thread_info (&threadinfo
);
6055 threadinfo_test_cmd (char *cmd
, int tty
)
6057 int athread
= SAMPLE_THREAD
;
6061 int_to_threadref (&thread
, athread
);
6062 printf_filtered ("Remote Threadinfo test\n");
6063 if (!get_and_display_threadinfo (&thread
))
6064 printf_filtered ("FAIL cannot get thread info\n");
6068 thread_display_step (threadref
*ref
, void *context
)
6070 /* output_threadid(" threadstep ",ref); *//* simple test */
6071 return get_and_display_threadinfo (ref
);
6075 threadlist_update_test_cmd (char *cmd
, int tty
)
6077 printf_filtered ("Remote Threadlist update test\n");
6078 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
6082 init_remote_threadtests (void)
6084 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
6085 Fetch and print the remote list of thread identifiers, one pkt only"));
6086 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
6087 _("Fetch and display info about one thread"));
6088 add_com ("tset", class_obscure
, threadset_test_cmd
,
6089 _("Test setting to a different thread"));
6090 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
6091 _("Iterate through updating all remote thread info"));
6092 add_com ("talive", class_obscure
, threadalive_test
,
6093 _(" Remote thread alive test "));
6098 /* Convert a thread ID to a string. Returns the string in a static
6102 remote_pid_to_str (ptid_t ptid
)
6104 static char buf
[32];
6106 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
6110 /* Get the address of the thread local variable in OBJFILE which is
6111 stored at OFFSET within the thread local storage for thread PTID. */
6114 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
6116 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
6118 struct remote_state
*rs
= get_remote_state ();
6120 enum packet_result result
;
6122 strcpy (p
, "qGetTLSAddr:");
6124 p
+= hexnumstr (p
, PIDGET (ptid
));
6126 p
+= hexnumstr (p
, offset
);
6128 p
+= hexnumstr (p
, lm
);
6132 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6133 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6134 if (result
== PACKET_OK
)
6138 unpack_varlen_hex (rs
->buf
, &result
);
6141 else if (result
== PACKET_UNKNOWN
)
6142 throw_error (TLS_GENERIC_ERROR
,
6143 _("Remote target doesn't support qGetTLSAddr packet"));
6145 throw_error (TLS_GENERIC_ERROR
,
6146 _("Remote target failed to process qGetTLSAddr request"));
6149 throw_error (TLS_GENERIC_ERROR
,
6150 _("TLS not supported or disabled on this target"));
6155 /* Support for inferring a target description based on the current
6156 architecture and the size of a 'g' packet. While the 'g' packet
6157 can have any size (since optional registers can be left off the
6158 end), some sizes are easily recognizable given knowledge of the
6159 approximate architecture. */
6161 struct remote_g_packet_guess
6164 const struct target_desc
*tdesc
;
6166 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6167 DEF_VEC_O(remote_g_packet_guess_s
);
6169 struct remote_g_packet_data
6171 VEC(remote_g_packet_guess_s
) *guesses
;
6174 static struct gdbarch_data
*remote_g_packet_data_handle
;
6177 remote_g_packet_data_init (struct obstack
*obstack
)
6179 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6183 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6184 const struct target_desc
*tdesc
)
6186 struct remote_g_packet_data
*data
6187 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6188 struct remote_g_packet_guess new_guess
, *guess
;
6191 gdb_assert (tdesc
!= NULL
);
6194 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6196 if (guess
->bytes
== bytes
)
6197 internal_error (__FILE__
, __LINE__
,
6198 "Duplicate g packet description added for size %d",
6201 new_guess
.bytes
= bytes
;
6202 new_guess
.tdesc
= tdesc
;
6203 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6206 static const struct target_desc
*
6207 remote_read_description (struct target_ops
*target
)
6209 struct remote_g_packet_data
*data
6210 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6212 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6214 struct remote_g_packet_guess
*guess
;
6216 int bytes
= send_g_packet ();
6219 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6221 if (guess
->bytes
== bytes
)
6222 return guess
->tdesc
;
6224 /* We discard the g packet. A minor optimization would be to
6225 hold on to it, and fill the register cache once we have selected
6226 an architecture, but it's too tricky to do safely. */
6233 init_remote_ops (void)
6235 remote_ops
.to_shortname
= "remote";
6236 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6238 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6239 Specify the serial device it is connected to\n\
6240 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6241 remote_ops
.to_open
= remote_open
;
6242 remote_ops
.to_close
= remote_close
;
6243 remote_ops
.to_detach
= remote_detach
;
6244 remote_ops
.to_disconnect
= remote_disconnect
;
6245 remote_ops
.to_resume
= remote_resume
;
6246 remote_ops
.to_wait
= remote_wait
;
6247 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6248 remote_ops
.to_store_registers
= remote_store_registers
;
6249 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6250 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6251 remote_ops
.to_files_info
= remote_files_info
;
6252 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6253 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6254 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6255 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6256 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6257 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6258 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6259 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6260 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6261 remote_ops
.to_kill
= remote_kill
;
6262 remote_ops
.to_load
= generic_load
;
6263 remote_ops
.to_mourn_inferior
= remote_mourn
;
6264 remote_ops
.to_thread_alive
= remote_thread_alive
;
6265 remote_ops
.to_find_new_threads
= remote_threads_info
;
6266 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6267 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6268 remote_ops
.to_stop
= remote_stop
;
6269 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6270 remote_ops
.to_rcmd
= remote_rcmd
;
6271 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6272 remote_ops
.to_stratum
= process_stratum
;
6273 remote_ops
.to_has_all_memory
= 1;
6274 remote_ops
.to_has_memory
= 1;
6275 remote_ops
.to_has_stack
= 1;
6276 remote_ops
.to_has_registers
= 1;
6277 remote_ops
.to_has_execution
= 1;
6278 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6279 remote_ops
.to_magic
= OPS_MAGIC
;
6280 remote_ops
.to_memory_map
= remote_memory_map
;
6281 remote_ops
.to_flash_erase
= remote_flash_erase
;
6282 remote_ops
.to_flash_done
= remote_flash_done
;
6283 remote_ops
.to_read_description
= remote_read_description
;
6286 /* Set up the extended remote vector by making a copy of the standard
6287 remote vector and adding to it. */
6290 init_extended_remote_ops (void)
6292 extended_remote_ops
= remote_ops
;
6294 extended_remote_ops
.to_shortname
= "extended-remote";
6295 extended_remote_ops
.to_longname
=
6296 "Extended remote serial target in gdb-specific protocol";
6297 extended_remote_ops
.to_doc
=
6298 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6299 Specify the serial device it is connected to (e.g. /dev/ttya).",
6300 extended_remote_ops
.to_open
= extended_remote_open
;
6301 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6302 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6306 remote_can_async_p (void)
6308 /* We're async whenever the serial device is. */
6309 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6313 remote_is_async_p (void)
6315 /* We're async whenever the serial device is. */
6316 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6319 /* Pass the SERIAL event on and up to the client. One day this code
6320 will be able to delay notifying the client of an event until the
6321 point where an entire packet has been received. */
6323 static void (*async_client_callback
) (enum inferior_event_type event_type
,
6325 static void *async_client_context
;
6326 static serial_event_ftype remote_async_serial_handler
;
6329 remote_async_serial_handler (struct serial
*scb
, void *context
)
6331 /* Don't propogate error information up to the client. Instead let
6332 the client find out about the error by querying the target. */
6333 async_client_callback (INF_REG_EVENT
, async_client_context
);
6337 remote_async (void (*callback
) (enum inferior_event_type event_type
,
6338 void *context
), void *context
)
6340 if (current_target
.to_async_mask_value
== 0)
6341 internal_error (__FILE__
, __LINE__
,
6342 _("Calling remote_async when async is masked"));
6344 if (callback
!= NULL
)
6346 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
6347 async_client_callback
= callback
;
6348 async_client_context
= context
;
6351 serial_async (remote_desc
, NULL
, NULL
);
6354 /* Target async and target extended-async.
6356 This are temporary targets, until it is all tested. Eventually
6357 async support will be incorporated int the usual 'remote'
6361 init_remote_async_ops (void)
6363 remote_async_ops
.to_shortname
= "async";
6364 remote_async_ops
.to_longname
=
6365 "Remote serial target in async version of the gdb-specific protocol";
6366 remote_async_ops
.to_doc
=
6367 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6368 Specify the serial device it is connected to (e.g. /dev/ttya).";
6369 remote_async_ops
.to_open
= remote_async_open
;
6370 remote_async_ops
.to_close
= remote_close
;
6371 remote_async_ops
.to_detach
= remote_detach
;
6372 remote_async_ops
.to_disconnect
= remote_disconnect
;
6373 remote_async_ops
.to_resume
= remote_async_resume
;
6374 remote_async_ops
.to_wait
= remote_async_wait
;
6375 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
6376 remote_async_ops
.to_store_registers
= remote_store_registers
;
6377 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6378 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6379 remote_async_ops
.to_files_info
= remote_files_info
;
6380 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6381 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6382 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6383 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6384 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6385 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6386 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6387 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6388 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6389 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
6390 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
6391 remote_async_ops
.to_kill
= remote_async_kill
;
6392 remote_async_ops
.to_load
= generic_load
;
6393 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
6394 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
6395 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
6396 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
6397 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6398 remote_async_ops
.to_stop
= remote_stop
;
6399 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
6400 remote_async_ops
.to_rcmd
= remote_rcmd
;
6401 remote_async_ops
.to_stratum
= process_stratum
;
6402 remote_async_ops
.to_has_all_memory
= 1;
6403 remote_async_ops
.to_has_memory
= 1;
6404 remote_async_ops
.to_has_stack
= 1;
6405 remote_async_ops
.to_has_registers
= 1;
6406 remote_async_ops
.to_has_execution
= 1;
6407 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6408 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
6409 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
6410 remote_async_ops
.to_async
= remote_async
;
6411 remote_async_ops
.to_async_mask_value
= 1;
6412 remote_async_ops
.to_magic
= OPS_MAGIC
;
6413 remote_async_ops
.to_memory_map
= remote_memory_map
;
6414 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
6415 remote_async_ops
.to_flash_done
= remote_flash_done
;
6416 remote_ops
.to_read_description
= remote_read_description
;
6419 /* Set up the async extended remote vector by making a copy of the standard
6420 remote vector and adding to it. */
6423 init_extended_async_remote_ops (void)
6425 extended_async_remote_ops
= remote_async_ops
;
6427 extended_async_remote_ops
.to_shortname
= "extended-async";
6428 extended_async_remote_ops
.to_longname
=
6429 "Extended remote serial target in async gdb-specific protocol";
6430 extended_async_remote_ops
.to_doc
=
6431 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6432 Specify the serial device it is connected to (e.g. /dev/ttya).",
6433 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
6434 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
6435 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6439 set_remote_cmd (char *args
, int from_tty
)
6441 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
6445 show_remote_cmd (char *args
, int from_tty
)
6447 /* We can't just use cmd_show_list here, because we want to skip
6448 the redundant "show remote Z-packet" and the legacy aliases. */
6449 struct cleanup
*showlist_chain
;
6450 struct cmd_list_element
*list
= remote_show_cmdlist
;
6452 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
6453 for (; list
!= NULL
; list
= list
->next
)
6454 if (strcmp (list
->name
, "Z-packet") == 0)
6456 else if (list
->type
== not_set_cmd
)
6457 /* Alias commands are exactly like the original, except they
6458 don't have the normal type. */
6462 struct cleanup
*option_chain
6463 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
6464 ui_out_field_string (uiout
, "name", list
->name
);
6465 ui_out_text (uiout
, ": ");
6466 if (list
->type
== show_cmd
)
6467 do_setshow_command ((char *) NULL
, from_tty
, list
);
6469 cmd_func (list
, NULL
, from_tty
);
6470 /* Close the tuple. */
6471 do_cleanups (option_chain
);
6474 /* Close the tuple. */
6475 do_cleanups (showlist_chain
);
6479 build_remote_gdbarch_data (void)
6481 remote_address_size
= gdbarch_addr_bit (current_gdbarch
);
6484 /* Function to be called whenever a new objfile (shlib) is detected. */
6486 remote_new_objfile (struct objfile
*objfile
)
6488 if (remote_desc
!= 0) /* Have a remote connection. */
6489 remote_check_symbols (objfile
);
6493 _initialize_remote (void)
6495 struct remote_state
*rs
;
6497 /* architecture specific data */
6498 remote_gdbarch_data_handle
=
6499 gdbarch_data_register_post_init (init_remote_state
);
6500 remote_g_packet_data_handle
=
6501 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
6503 /* Old tacky stuff. NOTE: This comes after the remote protocol so
6504 that the remote protocol has been initialized. */
6505 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size
);
6506 deprecated_register_gdbarch_swap (NULL
, 0, build_remote_gdbarch_data
);
6508 /* Initialize the per-target state. At the moment there is only one
6509 of these, not one per target. Only one target is active at a
6510 time. The default buffer size is unimportant; it will be expanded
6511 whenever a larger buffer is needed. */
6512 rs
= get_remote_state_raw ();
6514 rs
->buf
= xmalloc (rs
->buf_size
);
6517 add_target (&remote_ops
);
6519 init_extended_remote_ops ();
6520 add_target (&extended_remote_ops
);
6522 init_remote_async_ops ();
6523 add_target (&remote_async_ops
);
6525 init_extended_async_remote_ops ();
6526 add_target (&extended_async_remote_ops
);
6528 /* Hook into new objfile notification. */
6529 observer_attach_new_objfile (remote_new_objfile
);
6532 init_remote_threadtests ();
6535 /* set/show remote ... */
6537 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
6538 Remote protocol specific variables\n\
6539 Configure various remote-protocol specific variables such as\n\
6540 the packets being used"),
6541 &remote_set_cmdlist
, "set remote ",
6542 0 /* allow-unknown */, &setlist
);
6543 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
6544 Remote protocol specific variables\n\
6545 Configure various remote-protocol specific variables such as\n\
6546 the packets being used"),
6547 &remote_show_cmdlist
, "show remote ",
6548 0 /* allow-unknown */, &showlist
);
6550 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
6551 Compare section data on target to the exec file.\n\
6552 Argument is a single section name (default: all loaded sections)."),
6555 add_cmd ("packet", class_maintenance
, packet_command
, _("\
6556 Send an arbitrary packet to a remote target.\n\
6557 maintenance packet TEXT\n\
6558 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6559 this command sends the string TEXT to the inferior, and displays the\n\
6560 response packet. GDB supplies the initial `$' character, and the\n\
6561 terminating `#' character and checksum."),
6564 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
6565 Set whether to send break if interrupted."), _("\
6566 Show whether to send break if interrupted."), _("\
6567 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6568 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6569 &setlist
, &showlist
);
6571 /* Install commands for configuring memory read/write packets. */
6573 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
6574 Set the maximum number of bytes per memory write packet (deprecated)."),
6576 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
6577 Show the maximum number of bytes per memory write packet (deprecated)."),
6579 add_cmd ("memory-write-packet-size", no_class
,
6580 set_memory_write_packet_size
, _("\
6581 Set the maximum number of bytes per memory-write packet.\n\
6582 Specify the number of bytes in a packet or 0 (zero) for the\n\
6583 default packet size. The actual limit is further reduced\n\
6584 dependent on the target. Specify ``fixed'' to disable the\n\
6585 further restriction and ``limit'' to enable that restriction."),
6586 &remote_set_cmdlist
);
6587 add_cmd ("memory-read-packet-size", no_class
,
6588 set_memory_read_packet_size
, _("\
6589 Set the maximum number of bytes per memory-read packet.\n\
6590 Specify the number of bytes in a packet or 0 (zero) for the\n\
6591 default packet size. The actual limit is further reduced\n\
6592 dependent on the target. Specify ``fixed'' to disable the\n\
6593 further restriction and ``limit'' to enable that restriction."),
6594 &remote_set_cmdlist
);
6595 add_cmd ("memory-write-packet-size", no_class
,
6596 show_memory_write_packet_size
,
6597 _("Show the maximum number of bytes per memory-write packet."),
6598 &remote_show_cmdlist
);
6599 add_cmd ("memory-read-packet-size", no_class
,
6600 show_memory_read_packet_size
,
6601 _("Show the maximum number of bytes per memory-read packet."),
6602 &remote_show_cmdlist
);
6604 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6605 &remote_hw_watchpoint_limit
, _("\
6606 Set the maximum number of target hardware watchpoints."), _("\
6607 Show the maximum number of target hardware watchpoints."), _("\
6608 Specify a negative limit for unlimited."),
6609 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6610 &remote_set_cmdlist
, &remote_show_cmdlist
);
6611 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6612 &remote_hw_breakpoint_limit
, _("\
6613 Set the maximum number of target hardware breakpoints."), _("\
6614 Show the maximum number of target hardware breakpoints."), _("\
6615 Specify a negative limit for unlimited."),
6616 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6617 &remote_set_cmdlist
, &remote_show_cmdlist
);
6619 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6620 &remote_address_size
, _("\
6621 Set the maximum size of the address (in bits) in a memory packet."), _("\
6622 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6624 NULL
, /* FIXME: i18n: */
6625 &setlist
, &showlist
);
6627 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6628 "X", "binary-download", 1);
6630 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6631 "vCont", "verbose-resume", 0);
6633 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
6634 "QPassSignals", "pass-signals", 0);
6636 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6637 "qSymbol", "symbol-lookup", 0);
6639 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6640 "P", "set-register", 1);
6642 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6643 "p", "fetch-register", 1);
6645 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6646 "Z0", "software-breakpoint", 0);
6648 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6649 "Z1", "hardware-breakpoint", 0);
6651 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6652 "Z2", "write-watchpoint", 0);
6654 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6655 "Z3", "read-watchpoint", 0);
6657 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6658 "Z4", "access-watchpoint", 0);
6660 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6661 "qXfer:auxv:read", "read-aux-vector", 0);
6663 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
6664 "qXfer:features:read", "target-features", 0);
6666 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
6667 "qXfer:memory-map:read", "memory-map", 0);
6669 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
6670 "qXfer:spu:read", "read-spu-object", 0);
6672 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
6673 "qXfer:spu:write", "write-spu-object", 0);
6675 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6676 "qGetTLSAddr", "get-thread-local-storage-address",
6679 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6680 "qSupported", "supported-packets", 0);
6682 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6683 Z sub-packet has its own set and show commands, but users may
6684 have sets to this variable in their .gdbinit files (or in their
6686 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6687 &remote_Z_packet_detect
, _("\
6688 Set use of remote protocol `Z' packets"), _("\
6689 Show use of remote protocol `Z' packets "), _("\
6690 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6692 set_remote_protocol_Z_packet_cmd
,
6693 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6694 &remote_set_cmdlist
, &remote_show_cmdlist
);
6696 /* Eventually initialize fileio. See fileio.c */
6697 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);