1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* See the GDB User Guide for details of the GDB remote protocol. */
27 #include "gdb_string.h"
33 #include "exceptions.h"
35 /*#include "terminal.h" */
38 #include "gdb-stabs.h"
39 #include "gdbthread.h"
43 #include "gdb_assert.h"
46 #include "cli/cli-decode.h"
47 #include "cli/cli-setshow.h"
48 #include "target-descriptions.h"
53 #include "event-loop.h"
54 #include "event-top.h"
60 #include "gdbcore.h" /* for exec_bfd */
62 #include "remote-fileio.h"
64 #include "memory-map.h"
66 /* The size to align memory write packets, when practical. The protocol
67 does not guarantee any alignment, and gdb will generate short
68 writes and unaligned writes, but even as a best-effort attempt this
69 can improve bulk transfers. For instance, if a write is misaligned
70 relative to the target's data bus, the stub may need to make an extra
71 round trip fetching data from the target. This doesn't make a
72 huge difference, but it's easy to do, so we try to be helpful.
74 The alignment chosen is arbitrary; usually data bus width is
75 important here, not the possibly larger cache line size. */
76 enum { REMOTE_ALIGN_WRITES
= 16 };
78 /* Prototypes for local functions. */
79 static void cleanup_sigint_signal_handler (void *dummy
);
80 static void initialize_sigint_signal_handler (void);
81 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
83 static void handle_remote_sigint (int);
84 static void handle_remote_sigint_twice (int);
85 static void async_remote_interrupt (gdb_client_data
);
86 void async_remote_interrupt_twice (gdb_client_data
);
88 static void build_remote_gdbarch_data (void);
90 static void remote_files_info (struct target_ops
*ignore
);
92 static void remote_prepare_to_store (struct regcache
*regcache
);
94 static void remote_fetch_registers (struct regcache
*regcache
, int regno
);
96 static void remote_resume (ptid_t ptid
, int step
,
97 enum target_signal siggnal
);
98 static void remote_async_resume (ptid_t ptid
, int step
,
99 enum target_signal siggnal
);
100 static void remote_open (char *name
, int from_tty
);
101 static void remote_async_open (char *name
, int from_tty
);
103 static void extended_remote_open (char *name
, int from_tty
);
104 static void extended_remote_async_open (char *name
, int from_tty
);
106 static void remote_open_1 (char *, int, struct target_ops
*, int extended_p
,
109 static void remote_close (int quitting
);
111 static void remote_store_registers (struct regcache
*regcache
, int regno
);
113 static void remote_mourn (void);
114 static void remote_async_mourn (void);
116 static void extended_remote_restart (void);
118 static void extended_remote_mourn (void);
120 static void remote_mourn_1 (struct target_ops
*);
122 static void remote_send (char **buf
, long *sizeof_buf_p
);
124 static int readchar (int timeout
);
126 static ptid_t
remote_wait (ptid_t ptid
,
127 struct target_waitstatus
*status
);
128 static ptid_t
remote_async_wait (ptid_t ptid
,
129 struct target_waitstatus
*status
);
131 static void remote_kill (void);
132 static void remote_async_kill (void);
134 static int tohex (int nib
);
136 static void remote_detach (char *args
, int from_tty
);
138 static void remote_interrupt (int signo
);
140 static void remote_interrupt_twice (int signo
);
142 static void interrupt_query (void);
144 static void set_thread (int, int);
146 static int remote_thread_alive (ptid_t
);
148 static void get_offsets (void);
150 static void skip_frame (void);
152 static long read_frame (char **buf_p
, long *sizeof_buf
);
154 static int hexnumlen (ULONGEST num
);
156 static void init_remote_ops (void);
158 static void init_extended_remote_ops (void);
160 static void remote_stop (void);
162 static int ishex (int ch
, int *val
);
164 static int stubhex (int ch
);
166 static int hexnumstr (char *, ULONGEST
);
168 static int hexnumnstr (char *, ULONGEST
, int);
170 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
172 static void print_packet (char *);
174 static unsigned long crc32 (unsigned char *, int, unsigned int);
176 static void compare_sections_command (char *, int);
178 static void packet_command (char *, int);
180 static int stub_unpack_int (char *buff
, int fieldlength
);
182 static ptid_t
remote_current_thread (ptid_t oldptid
);
184 static void remote_find_new_threads (void);
186 static void record_currthread (int currthread
);
188 static int fromhex (int a
);
190 static int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
192 static int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
194 static int putpkt_binary (char *buf
, int cnt
);
196 static void check_binary_download (CORE_ADDR addr
);
198 struct packet_config
;
200 static void show_packet_config_cmd (struct packet_config
*config
);
202 static void update_packet_config (struct packet_config
*config
);
204 static void set_remote_protocol_packet_cmd (char *args
, int from_tty
,
205 struct cmd_list_element
*c
);
207 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
209 struct cmd_list_element
*c
,
212 void _initialize_remote (void);
214 /* For "set remote" and "show remote". */
216 static struct cmd_list_element
*remote_set_cmdlist
;
217 static struct cmd_list_element
*remote_show_cmdlist
;
219 /* Description of the remote protocol state for the currently
220 connected target. This is per-target state, and independent of the
221 selected architecture. */
225 /* A buffer to use for incoming packets, and its current size. The
226 buffer is grown dynamically for larger incoming packets.
227 Outgoing packets may also be constructed in this buffer.
228 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
229 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
234 /* If we negotiated packet size explicitly (and thus can bypass
235 heuristics for the largest packet size that will not overflow
236 a buffer in the stub), this will be set to that packet size.
237 Otherwise zero, meaning to use the guessed size. */
238 long explicit_packet_size
;
241 /* This data could be associated with a target, but we do not always
242 have access to the current target when we need it, so for now it is
243 static. This will be fine for as long as only one target is in use
245 static struct remote_state remote_state
;
247 static struct remote_state
*
248 get_remote_state_raw (void)
250 return &remote_state
;
253 /* Description of the remote protocol for a given architecture. */
257 long offset
; /* Offset into G packet. */
258 long regnum
; /* GDB's internal register number. */
259 LONGEST pnum
; /* Remote protocol register number. */
260 int in_g_packet
; /* Always part of G packet. */
261 /* long size in bytes; == register_size (current_gdbarch, regnum);
263 /* char *name; == gdbarch_register_name (current_gdbarch, regnum);
267 struct remote_arch_state
269 /* Description of the remote protocol registers. */
270 long sizeof_g_packet
;
272 /* Description of the remote protocol registers indexed by REGNUM
273 (making an array gdbarch_num_regs in size). */
274 struct packet_reg
*regs
;
276 /* This is the size (in chars) of the first response to the ``g''
277 packet. It is used as a heuristic when determining the maximum
278 size of memory-read and memory-write packets. A target will
279 typically only reserve a buffer large enough to hold the ``g''
280 packet. The size does not include packet overhead (headers and
282 long actual_register_packet_size
;
284 /* This is the maximum size (in chars) of a non read/write packet.
285 It is also used as a cap on the size of read/write packets. */
286 long remote_packet_size
;
290 /* Handle for retreving the remote protocol data from gdbarch. */
291 static struct gdbarch_data
*remote_gdbarch_data_handle
;
293 static struct remote_arch_state
*
294 get_remote_arch_state (void)
296 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
299 /* Fetch the global remote target state. */
301 static struct remote_state
*
302 get_remote_state (void)
304 /* Make sure that the remote architecture state has been
305 initialized, because doing so might reallocate rs->buf. Any
306 function which calls getpkt also needs to be mindful of changes
307 to rs->buf, but this call limits the number of places which run
309 get_remote_arch_state ();
311 return get_remote_state_raw ();
315 compare_pnums (const void *lhs_
, const void *rhs_
)
317 const struct packet_reg
* const *lhs
= lhs_
;
318 const struct packet_reg
* const *rhs
= rhs_
;
320 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
322 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
329 init_remote_state (struct gdbarch
*gdbarch
)
331 int regnum
, num_remote_regs
, offset
;
332 struct remote_state
*rs
= get_remote_state_raw ();
333 struct remote_arch_state
*rsa
;
334 struct packet_reg
**remote_regs
;
336 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
338 /* Use the architecture to build a regnum<->pnum table, which will be
339 1:1 unless a feature set specifies otherwise. */
340 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
341 gdbarch_num_regs (current_gdbarch
),
343 for (regnum
= 0; regnum
< gdbarch_num_regs (current_gdbarch
); regnum
++)
345 struct packet_reg
*r
= &rsa
->regs
[regnum
];
347 if (register_size (current_gdbarch
, regnum
) == 0)
348 /* Do not try to fetch zero-sized (placeholder) registers. */
351 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
356 /* Define the g/G packet format as the contents of each register
357 with a remote protocol number, in order of ascending protocol
360 remote_regs
= alloca (gdbarch_num_regs (current_gdbarch
)
361 * sizeof (struct packet_reg
*));
362 for (num_remote_regs
= 0, regnum
= 0;
363 regnum
< gdbarch_num_regs (current_gdbarch
);
365 if (rsa
->regs
[regnum
].pnum
!= -1)
366 remote_regs
[num_remote_regs
++] = &rsa
->regs
[regnum
];
368 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
371 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
373 remote_regs
[regnum
]->in_g_packet
= 1;
374 remote_regs
[regnum
]->offset
= offset
;
375 offset
+= register_size (current_gdbarch
, remote_regs
[regnum
]->regnum
);
378 /* Record the maximum possible size of the g packet - it may turn out
380 rsa
->sizeof_g_packet
= offset
;
382 /* Default maximum number of characters in a packet body. Many
383 remote stubs have a hardwired buffer size of 400 bytes
384 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
385 as the maximum packet-size to ensure that the packet and an extra
386 NUL character can always fit in the buffer. This stops GDB
387 trashing stubs that try to squeeze an extra NUL into what is
388 already a full buffer (As of 1999-12-04 that was most stubs). */
389 rsa
->remote_packet_size
= 400 - 1;
391 /* This one is filled in when a ``g'' packet is received. */
392 rsa
->actual_register_packet_size
= 0;
394 /* Should rsa->sizeof_g_packet needs more space than the
395 default, adjust the size accordingly. Remember that each byte is
396 encoded as two characters. 32 is the overhead for the packet
397 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
398 (``$NN:G...#NN'') is a better guess, the below has been padded a
400 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
401 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
403 /* Make sure that the packet buffer is plenty big enough for
404 this architecture. */
405 if (rs
->buf_size
< rsa
->remote_packet_size
)
407 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
408 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
414 /* Return the current allowed size of a remote packet. This is
415 inferred from the current architecture, and should be used to
416 limit the length of outgoing packets. */
418 get_remote_packet_size (void)
420 struct remote_state
*rs
= get_remote_state ();
421 struct remote_arch_state
*rsa
= get_remote_arch_state ();
423 if (rs
->explicit_packet_size
)
424 return rs
->explicit_packet_size
;
426 return rsa
->remote_packet_size
;
429 static struct packet_reg
*
430 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
432 if (regnum
< 0 && regnum
>= gdbarch_num_regs (current_gdbarch
))
436 struct packet_reg
*r
= &rsa
->regs
[regnum
];
437 gdb_assert (r
->regnum
== regnum
);
442 static struct packet_reg
*
443 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
446 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
448 struct packet_reg
*r
= &rsa
->regs
[i
];
455 /* FIXME: graces/2002-08-08: These variables should eventually be
456 bound to an instance of the target object (as in gdbarch-tdep()),
457 when such a thing exists. */
459 /* This is set to the data address of the access causing the target
460 to stop for a watchpoint. */
461 static CORE_ADDR remote_watch_data_address
;
463 /* This is non-zero if target stopped for a watchpoint. */
464 static int remote_stopped_by_watchpoint_p
;
466 static struct target_ops remote_ops
;
468 static struct target_ops extended_remote_ops
;
470 /* Temporary target ops. Just like the remote_ops and
471 extended_remote_ops, but with asynchronous support. */
472 static struct target_ops remote_async_ops
;
474 static struct target_ops extended_async_remote_ops
;
476 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
477 ``forever'' still use the normal timeout mechanism. This is
478 currently used by the ASYNC code to guarentee that target reads
479 during the initial connect always time-out. Once getpkt has been
480 modified to return a timeout indication and, in turn
481 remote_wait()/wait_for_inferior() have gained a timeout parameter
483 static int wait_forever_enabled_p
= 1;
486 /* This variable chooses whether to send a ^C or a break when the user
487 requests program interruption. Although ^C is usually what remote
488 systems expect, and that is the default here, sometimes a break is
489 preferable instead. */
491 static int remote_break
;
493 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
494 remote_open knows that we don't have a file open when the program
496 static struct serial
*remote_desc
= NULL
;
498 /* This variable sets the number of bits in an address that are to be
499 sent in a memory ("M" or "m") packet. Normally, after stripping
500 leading zeros, the entire address would be sent. This variable
501 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
502 initial implementation of remote.c restricted the address sent in
503 memory packets to ``host::sizeof long'' bytes - (typically 32
504 bits). Consequently, for 64 bit targets, the upper 32 bits of an
505 address was never sent. Since fixing this bug may cause a break in
506 some remote targets this variable is principly provided to
507 facilitate backward compatibility. */
509 static int remote_address_size
;
511 /* Tempoary to track who currently owns the terminal. See
512 target_async_terminal_* for more details. */
514 static int remote_async_terminal_ours_p
;
517 /* User configurable variables for the number of characters in a
518 memory read/write packet. MIN (rsa->remote_packet_size,
519 rsa->sizeof_g_packet) is the default. Some targets need smaller
520 values (fifo overruns, et.al.) and some users need larger values
521 (speed up transfers). The variables ``preferred_*'' (the user
522 request), ``current_*'' (what was actually set) and ``forced_*''
523 (Positive - a soft limit, negative - a hard limit). */
525 struct memory_packet_config
532 /* Compute the current size of a read/write packet. Since this makes
533 use of ``actual_register_packet_size'' the computation is dynamic. */
536 get_memory_packet_size (struct memory_packet_config
*config
)
538 struct remote_state
*rs
= get_remote_state ();
539 struct remote_arch_state
*rsa
= get_remote_arch_state ();
541 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
542 law?) that some hosts don't cope very well with large alloca()
543 calls. Eventually the alloca() code will be replaced by calls to
544 xmalloc() and make_cleanups() allowing this restriction to either
545 be lifted or removed. */
546 #ifndef MAX_REMOTE_PACKET_SIZE
547 #define MAX_REMOTE_PACKET_SIZE 16384
549 /* NOTE: 20 ensures we can write at least one byte. */
550 #ifndef MIN_REMOTE_PACKET_SIZE
551 #define MIN_REMOTE_PACKET_SIZE 20
556 if (config
->size
<= 0)
557 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
559 what_they_get
= config
->size
;
563 what_they_get
= get_remote_packet_size ();
564 /* Limit the packet to the size specified by the user. */
566 && what_they_get
> config
->size
)
567 what_they_get
= config
->size
;
569 /* Limit it to the size of the targets ``g'' response unless we have
570 permission from the stub to use a larger packet size. */
571 if (rs
->explicit_packet_size
== 0
572 && rsa
->actual_register_packet_size
> 0
573 && what_they_get
> rsa
->actual_register_packet_size
)
574 what_they_get
= rsa
->actual_register_packet_size
;
576 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
577 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
578 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
579 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
581 /* Make sure there is room in the global buffer for this packet
582 (including its trailing NUL byte). */
583 if (rs
->buf_size
< what_they_get
+ 1)
585 rs
->buf_size
= 2 * what_they_get
;
586 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
589 return what_they_get
;
592 /* Update the size of a read/write packet. If they user wants
593 something really big then do a sanity check. */
596 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
598 int fixed_p
= config
->fixed_p
;
599 long size
= config
->size
;
601 error (_("Argument required (integer, `fixed' or `limited')."));
602 else if (strcmp (args
, "hard") == 0
603 || strcmp (args
, "fixed") == 0)
605 else if (strcmp (args
, "soft") == 0
606 || strcmp (args
, "limit") == 0)
611 size
= strtoul (args
, &end
, 0);
613 error (_("Invalid %s (bad syntax)."), config
->name
);
615 /* Instead of explicitly capping the size of a packet to
616 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
617 instead allowed to set the size to something arbitrarily
619 if (size
> MAX_REMOTE_PACKET_SIZE
)
620 error (_("Invalid %s (too large)."), config
->name
);
624 if (fixed_p
&& !config
->fixed_p
)
626 if (! query (_("The target may not be able to correctly handle a %s\n"
627 "of %ld bytes. Change the packet size? "),
629 error (_("Packet size not changed."));
631 /* Update the config. */
632 config
->fixed_p
= fixed_p
;
637 show_memory_packet_size (struct memory_packet_config
*config
)
639 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
641 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
642 get_memory_packet_size (config
));
644 printf_filtered (_("Packets are limited to %ld bytes.\n"),
645 get_memory_packet_size (config
));
648 static struct memory_packet_config memory_write_packet_config
=
650 "memory-write-packet-size",
654 set_memory_write_packet_size (char *args
, int from_tty
)
656 set_memory_packet_size (args
, &memory_write_packet_config
);
660 show_memory_write_packet_size (char *args
, int from_tty
)
662 show_memory_packet_size (&memory_write_packet_config
);
666 get_memory_write_packet_size (void)
668 return get_memory_packet_size (&memory_write_packet_config
);
671 static struct memory_packet_config memory_read_packet_config
=
673 "memory-read-packet-size",
677 set_memory_read_packet_size (char *args
, int from_tty
)
679 set_memory_packet_size (args
, &memory_read_packet_config
);
683 show_memory_read_packet_size (char *args
, int from_tty
)
685 show_memory_packet_size (&memory_read_packet_config
);
689 get_memory_read_packet_size (void)
691 long size
= get_memory_packet_size (&memory_read_packet_config
);
692 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
693 extra buffer size argument before the memory read size can be
694 increased beyond this. */
695 if (size
> get_remote_packet_size ())
696 size
= get_remote_packet_size ();
701 /* Generic configuration support for packets the stub optionally
702 supports. Allows the user to specify the use of the packet as well
703 as allowing GDB to auto-detect support in the remote stub. */
707 PACKET_SUPPORT_UNKNOWN
= 0,
716 enum auto_boolean detect
;
717 enum packet_support support
;
720 /* Analyze a packet's return value and update the packet config
731 update_packet_config (struct packet_config
*config
)
733 switch (config
->detect
)
735 case AUTO_BOOLEAN_TRUE
:
736 config
->support
= PACKET_ENABLE
;
738 case AUTO_BOOLEAN_FALSE
:
739 config
->support
= PACKET_DISABLE
;
741 case AUTO_BOOLEAN_AUTO
:
742 config
->support
= PACKET_SUPPORT_UNKNOWN
;
748 show_packet_config_cmd (struct packet_config
*config
)
750 char *support
= "internal-error";
751 switch (config
->support
)
757 support
= "disabled";
759 case PACKET_SUPPORT_UNKNOWN
:
763 switch (config
->detect
)
765 case AUTO_BOOLEAN_AUTO
:
766 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
767 config
->name
, support
);
769 case AUTO_BOOLEAN_TRUE
:
770 case AUTO_BOOLEAN_FALSE
:
771 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
772 config
->name
, support
);
778 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
779 const char *title
, int legacy
)
786 config
->title
= title
;
787 config
->detect
= AUTO_BOOLEAN_AUTO
;
788 config
->support
= PACKET_SUPPORT_UNKNOWN
;
789 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
791 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
793 /* set/show TITLE-packet {auto,on,off} */
794 cmd_name
= xstrprintf ("%s-packet", title
);
795 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
796 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
797 set_remote_protocol_packet_cmd
,
798 show_remote_protocol_packet_cmd
,
799 &remote_set_cmdlist
, &remote_show_cmdlist
);
800 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
804 legacy_name
= xstrprintf ("%s-packet", name
);
805 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
806 &remote_set_cmdlist
);
807 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
808 &remote_show_cmdlist
);
812 static enum packet_result
813 packet_check_result (const char *buf
)
817 /* The stub recognized the packet request. Check that the
818 operation succeeded. */
820 && isxdigit (buf
[1]) && isxdigit (buf
[2])
822 /* "Enn" - definitly an error. */
825 /* Always treat "E." as an error. This will be used for
826 more verbose error messages, such as E.memtypes. */
827 if (buf
[0] == 'E' && buf
[1] == '.')
830 /* The packet may or may not be OK. Just assume it is. */
834 /* The stub does not support the packet. */
835 return PACKET_UNKNOWN
;
838 static enum packet_result
839 packet_ok (const char *buf
, struct packet_config
*config
)
841 enum packet_result result
;
843 result
= packet_check_result (buf
);
848 /* The stub recognized the packet request. */
849 switch (config
->support
)
851 case PACKET_SUPPORT_UNKNOWN
:
853 fprintf_unfiltered (gdb_stdlog
,
854 "Packet %s (%s) is supported\n",
855 config
->name
, config
->title
);
856 config
->support
= PACKET_ENABLE
;
859 internal_error (__FILE__
, __LINE__
,
860 _("packet_ok: attempt to use a disabled packet"));
867 /* The stub does not support the packet. */
868 switch (config
->support
)
871 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
872 /* If the stub previously indicated that the packet was
873 supported then there is a protocol error.. */
874 error (_("Protocol error: %s (%s) conflicting enabled responses."),
875 config
->name
, config
->title
);
877 /* The user set it wrong. */
878 error (_("Enabled packet %s (%s) not recognized by stub"),
879 config
->name
, config
->title
);
881 case PACKET_SUPPORT_UNKNOWN
:
883 fprintf_unfiltered (gdb_stdlog
,
884 "Packet %s (%s) is NOT supported\n",
885 config
->name
, config
->title
);
886 config
->support
= PACKET_DISABLE
;
909 PACKET_qXfer_features
,
910 PACKET_qXfer_memory_map
,
911 PACKET_qXfer_spu_read
,
912 PACKET_qXfer_spu_write
,
919 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
922 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
923 struct cmd_list_element
*c
)
925 struct packet_config
*packet
;
927 for (packet
= remote_protocol_packets
;
928 packet
< &remote_protocol_packets
[PACKET_MAX
];
931 if (&packet
->detect
== c
->var
)
933 update_packet_config (packet
);
937 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
942 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
943 struct cmd_list_element
*c
,
946 struct packet_config
*packet
;
948 for (packet
= remote_protocol_packets
;
949 packet
< &remote_protocol_packets
[PACKET_MAX
];
952 if (&packet
->detect
== c
->var
)
954 show_packet_config_cmd (packet
);
958 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
962 /* Should we try one of the 'Z' requests? */
966 Z_PACKET_SOFTWARE_BP
,
967 Z_PACKET_HARDWARE_BP
,
974 /* For compatibility with older distributions. Provide a ``set remote
975 Z-packet ...'' command that updates all the Z packet types. */
977 static enum auto_boolean remote_Z_packet_detect
;
980 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
981 struct cmd_list_element
*c
)
984 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
986 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
987 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
992 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
993 struct cmd_list_element
*c
,
997 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
999 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1003 /* Should we try the 'ThreadInfo' query packet?
1005 This variable (NOT available to the user: auto-detect only!)
1006 determines whether GDB will use the new, simpler "ThreadInfo"
1007 query or the older, more complex syntax for thread queries.
1008 This is an auto-detect variable (set to true at each connect,
1009 and set to false when the target fails to recognize it). */
1011 static int use_threadinfo_query
;
1012 static int use_threadextra_query
;
1014 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1015 static struct async_signal_handler
*sigint_remote_twice_token
;
1016 static struct async_signal_handler
*sigint_remote_token
;
1018 /* These are pointers to hook functions that may be set in order to
1019 modify resume/wait behavior for a particular architecture. */
1021 void (*deprecated_target_resume_hook
) (void);
1022 void (*deprecated_target_wait_loop_hook
) (void);
1026 /* These are the threads which we last sent to the remote system.
1027 -1 for all or -2 for not sent yet. */
1028 static int general_thread
;
1029 static int continue_thread
;
1031 /* Call this function as a result of
1032 1) A halt indication (T packet) containing a thread id
1033 2) A direct query of currthread
1034 3) Successful execution of set thread
1038 record_currthread (int currthread
)
1040 general_thread
= currthread
;
1042 /* If this is a new thread, add it to GDB's thread list.
1043 If we leave it up to WFI to do this, bad things will happen. */
1044 if (!in_thread_list (pid_to_ptid (currthread
)))
1046 add_thread (pid_to_ptid (currthread
));
1047 ui_out_text (uiout
, "[New ");
1048 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
1049 ui_out_text (uiout
, "]\n");
1053 static char *last_pass_packet
;
1055 /* If 'QPassSignals' is supported, tell the remote stub what signals
1056 it can simply pass through to the inferior without reporting. */
1059 remote_pass_signals (void)
1061 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1063 char *pass_packet
, *p
;
1064 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1067 gdb_assert (numsigs
< 256);
1068 for (i
= 0; i
< numsigs
; i
++)
1070 if (signal_stop_state (i
) == 0
1071 && signal_print_state (i
) == 0
1072 && signal_pass_state (i
) == 1)
1075 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1076 strcpy (pass_packet
, "QPassSignals:");
1077 p
= pass_packet
+ strlen (pass_packet
);
1078 for (i
= 0; i
< numsigs
; i
++)
1080 if (signal_stop_state (i
) == 0
1081 && signal_print_state (i
) == 0
1082 && signal_pass_state (i
) == 1)
1085 *p
++ = tohex (i
>> 4);
1086 *p
++ = tohex (i
& 15);
1095 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1097 struct remote_state
*rs
= get_remote_state ();
1098 char *buf
= rs
->buf
;
1100 putpkt (pass_packet
);
1101 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1102 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1103 if (last_pass_packet
)
1104 xfree (last_pass_packet
);
1105 last_pass_packet
= pass_packet
;
1108 xfree (pass_packet
);
1112 #define MAGIC_NULL_PID 42000
1115 set_thread (int th
, int gen
)
1117 struct remote_state
*rs
= get_remote_state ();
1118 char *buf
= rs
->buf
;
1119 int state
= gen
? general_thread
: continue_thread
;
1125 buf
[1] = gen
? 'g' : 'c';
1126 if (th
== MAGIC_NULL_PID
)
1132 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
1134 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
1136 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1138 general_thread
= th
;
1140 continue_thread
= th
;
1143 /* Return nonzero if the thread TH is still alive on the remote system. */
1146 remote_thread_alive (ptid_t ptid
)
1148 struct remote_state
*rs
= get_remote_state ();
1149 int tid
= PIDGET (ptid
);
1152 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1154 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1156 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1157 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1160 /* About these extended threadlist and threadinfo packets. They are
1161 variable length packets but, the fields within them are often fixed
1162 length. They are redundent enough to send over UDP as is the
1163 remote protocol in general. There is a matching unit test module
1166 #define OPAQUETHREADBYTES 8
1168 /* a 64 bit opaque identifier */
1169 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1171 /* WARNING: This threadref data structure comes from the remote O.S.,
1172 libstub protocol encoding, and remote.c. it is not particularly
1175 /* Right now, the internal structure is int. We want it to be bigger.
1179 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1181 /* gdb_ext_thread_info is an internal GDB data structure which is
1182 equivalent to the reply of the remote threadinfo packet. */
1184 struct gdb_ext_thread_info
1186 threadref threadid
; /* External form of thread reference. */
1187 int active
; /* Has state interesting to GDB?
1189 char display
[256]; /* Brief state display, name,
1190 blocked/suspended. */
1191 char shortname
[32]; /* To be used to name threads. */
1192 char more_display
[256]; /* Long info, statistics, queue depth,
1196 /* The volume of remote transfers can be limited by submitting
1197 a mask containing bits specifying the desired information.
1198 Use a union of these values as the 'selection' parameter to
1199 get_thread_info. FIXME: Make these TAG names more thread specific.
1202 #define TAG_THREADID 1
1203 #define TAG_EXISTS 2
1204 #define TAG_DISPLAY 4
1205 #define TAG_THREADNAME 8
1206 #define TAG_MOREDISPLAY 16
1208 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1210 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1212 static char *unpack_nibble (char *buf
, int *val
);
1214 static char *pack_nibble (char *buf
, int nibble
);
1216 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1218 static char *unpack_byte (char *buf
, int *value
);
1220 static char *pack_int (char *buf
, int value
);
1222 static char *unpack_int (char *buf
, int *value
);
1224 static char *unpack_string (char *src
, char *dest
, int length
);
1226 static char *pack_threadid (char *pkt
, threadref
*id
);
1228 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1230 void int_to_threadref (threadref
*id
, int value
);
1232 static int threadref_to_int (threadref
*ref
);
1234 static void copy_threadref (threadref
*dest
, threadref
*src
);
1236 static int threadmatch (threadref
*dest
, threadref
*src
);
1238 static char *pack_threadinfo_request (char *pkt
, int mode
,
1241 static int remote_unpack_thread_info_response (char *pkt
,
1242 threadref
*expectedref
,
1243 struct gdb_ext_thread_info
1247 static int remote_get_threadinfo (threadref
*threadid
,
1248 int fieldset
, /*TAG mask */
1249 struct gdb_ext_thread_info
*info
);
1251 static char *pack_threadlist_request (char *pkt
, int startflag
,
1253 threadref
*nextthread
);
1255 static int parse_threadlist_response (char *pkt
,
1257 threadref
*original_echo
,
1258 threadref
*resultlist
,
1261 static int remote_get_threadlist (int startflag
,
1262 threadref
*nextthread
,
1266 threadref
*threadlist
);
1268 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1270 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1271 void *context
, int looplimit
);
1273 static int remote_newthread_step (threadref
*ref
, void *context
);
1275 /* Encode 64 bits in 16 chars of hex. */
1277 static const char hexchars
[] = "0123456789abcdef";
1280 ishex (int ch
, int *val
)
1282 if ((ch
>= 'a') && (ch
<= 'f'))
1284 *val
= ch
- 'a' + 10;
1287 if ((ch
>= 'A') && (ch
<= 'F'))
1289 *val
= ch
- 'A' + 10;
1292 if ((ch
>= '0') && (ch
<= '9'))
1303 if (ch
>= 'a' && ch
<= 'f')
1304 return ch
- 'a' + 10;
1305 if (ch
>= '0' && ch
<= '9')
1307 if (ch
>= 'A' && ch
<= 'F')
1308 return ch
- 'A' + 10;
1313 stub_unpack_int (char *buff
, int fieldlength
)
1320 nibble
= stubhex (*buff
++);
1324 retval
= retval
<< 4;
1330 unpack_varlen_hex (char *buff
, /* packet to parse */
1334 ULONGEST retval
= 0;
1336 while (ishex (*buff
, &nibble
))
1339 retval
= retval
<< 4;
1340 retval
|= nibble
& 0x0f;
1347 unpack_nibble (char *buf
, int *val
)
1349 ishex (*buf
++, val
);
1354 pack_nibble (char *buf
, int nibble
)
1356 *buf
++ = hexchars
[(nibble
& 0x0f)];
1361 pack_hex_byte (char *pkt
, int byte
)
1363 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1364 *pkt
++ = hexchars
[(byte
& 0xf)];
1369 unpack_byte (char *buf
, int *value
)
1371 *value
= stub_unpack_int (buf
, 2);
1376 pack_int (char *buf
, int value
)
1378 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1379 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1380 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1381 buf
= pack_hex_byte (buf
, (value
& 0xff));
1386 unpack_int (char *buf
, int *value
)
1388 *value
= stub_unpack_int (buf
, 8);
1392 #if 0 /* Currently unused, uncomment when needed. */
1393 static char *pack_string (char *pkt
, char *string
);
1396 pack_string (char *pkt
, char *string
)
1401 len
= strlen (string
);
1403 len
= 200; /* Bigger than most GDB packets, junk??? */
1404 pkt
= pack_hex_byte (pkt
, len
);
1408 if ((ch
== '\0') || (ch
== '#'))
1409 ch
= '*'; /* Protect encapsulation. */
1414 #endif /* 0 (unused) */
1417 unpack_string (char *src
, char *dest
, int length
)
1426 pack_threadid (char *pkt
, threadref
*id
)
1429 unsigned char *altid
;
1431 altid
= (unsigned char *) id
;
1432 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1434 pkt
= pack_hex_byte (pkt
, *altid
++);
1440 unpack_threadid (char *inbuf
, threadref
*id
)
1443 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1446 altref
= (char *) id
;
1448 while (inbuf
< limit
)
1450 x
= stubhex (*inbuf
++);
1451 y
= stubhex (*inbuf
++);
1452 *altref
++ = (x
<< 4) | y
;
1457 /* Externally, threadrefs are 64 bits but internally, they are still
1458 ints. This is due to a mismatch of specifications. We would like
1459 to use 64bit thread references internally. This is an adapter
1463 int_to_threadref (threadref
*id
, int value
)
1465 unsigned char *scan
;
1467 scan
= (unsigned char *) id
;
1473 *scan
++ = (value
>> 24) & 0xff;
1474 *scan
++ = (value
>> 16) & 0xff;
1475 *scan
++ = (value
>> 8) & 0xff;
1476 *scan
++ = (value
& 0xff);
1480 threadref_to_int (threadref
*ref
)
1483 unsigned char *scan
;
1489 value
= (value
<< 8) | ((*scan
++) & 0xff);
1494 copy_threadref (threadref
*dest
, threadref
*src
)
1497 unsigned char *csrc
, *cdest
;
1499 csrc
= (unsigned char *) src
;
1500 cdest
= (unsigned char *) dest
;
1507 threadmatch (threadref
*dest
, threadref
*src
)
1509 /* Things are broken right now, so just assume we got a match. */
1511 unsigned char *srcp
, *destp
;
1513 srcp
= (char *) src
;
1514 destp
= (char *) dest
;
1518 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1525 threadid:1, # always request threadid
1532 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1535 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1537 *pkt
++ = 'q'; /* Info Query */
1538 *pkt
++ = 'P'; /* process or thread info */
1539 pkt
= pack_int (pkt
, mode
); /* mode */
1540 pkt
= pack_threadid (pkt
, id
); /* threadid */
1541 *pkt
= '\0'; /* terminate */
1545 /* These values tag the fields in a thread info response packet. */
1546 /* Tagging the fields allows us to request specific fields and to
1547 add more fields as time goes by. */
1549 #define TAG_THREADID 1 /* Echo the thread identifier. */
1550 #define TAG_EXISTS 2 /* Is this process defined enough to
1551 fetch registers and its stack? */
1552 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1553 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1554 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1558 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1559 struct gdb_ext_thread_info
*info
)
1561 struct remote_state
*rs
= get_remote_state ();
1565 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1568 /* info->threadid = 0; FIXME: implement zero_threadref. */
1570 info
->display
[0] = '\0';
1571 info
->shortname
[0] = '\0';
1572 info
->more_display
[0] = '\0';
1574 /* Assume the characters indicating the packet type have been
1576 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1577 pkt
= unpack_threadid (pkt
, &ref
);
1580 warning (_("Incomplete response to threadinfo request."));
1581 if (!threadmatch (&ref
, expectedref
))
1582 { /* This is an answer to a different request. */
1583 warning (_("ERROR RMT Thread info mismatch."));
1586 copy_threadref (&info
->threadid
, &ref
);
1588 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1590 /* Packets are terminated with nulls. */
1591 while ((pkt
< limit
) && mask
&& *pkt
)
1593 pkt
= unpack_int (pkt
, &tag
); /* tag */
1594 pkt
= unpack_byte (pkt
, &length
); /* length */
1595 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1597 warning (_("ERROR RMT: threadinfo tag mismatch."));
1601 if (tag
== TAG_THREADID
)
1605 warning (_("ERROR RMT: length of threadid is not 16."));
1609 pkt
= unpack_threadid (pkt
, &ref
);
1610 mask
= mask
& ~TAG_THREADID
;
1613 if (tag
== TAG_EXISTS
)
1615 info
->active
= stub_unpack_int (pkt
, length
);
1617 mask
= mask
& ~(TAG_EXISTS
);
1620 warning (_("ERROR RMT: 'exists' length too long."));
1626 if (tag
== TAG_THREADNAME
)
1628 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1629 mask
= mask
& ~TAG_THREADNAME
;
1632 if (tag
== TAG_DISPLAY
)
1634 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1635 mask
= mask
& ~TAG_DISPLAY
;
1638 if (tag
== TAG_MOREDISPLAY
)
1640 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1641 mask
= mask
& ~TAG_MOREDISPLAY
;
1644 warning (_("ERROR RMT: unknown thread info tag."));
1645 break; /* Not a tag we know about. */
1651 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1652 struct gdb_ext_thread_info
*info
)
1654 struct remote_state
*rs
= get_remote_state ();
1657 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1659 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1660 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1665 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1668 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1669 threadref
*nextthread
)
1671 *pkt
++ = 'q'; /* info query packet */
1672 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1673 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1674 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1675 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1680 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1683 parse_threadlist_response (char *pkt
, int result_limit
,
1684 threadref
*original_echo
, threadref
*resultlist
,
1687 struct remote_state
*rs
= get_remote_state ();
1689 int count
, resultcount
, done
;
1692 /* Assume the 'q' and 'M chars have been stripped. */
1693 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1694 /* done parse past here */
1695 pkt
= unpack_byte (pkt
, &count
); /* count field */
1696 pkt
= unpack_nibble (pkt
, &done
);
1697 /* The first threadid is the argument threadid. */
1698 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1699 while ((count
-- > 0) && (pkt
< limit
))
1701 pkt
= unpack_threadid (pkt
, resultlist
++);
1702 if (resultcount
++ >= result_limit
)
1711 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1712 int *done
, int *result_count
, threadref
*threadlist
)
1714 struct remote_state
*rs
= get_remote_state ();
1715 static threadref echo_nextthread
;
1718 /* Trancate result limit to be smaller than the packet size. */
1719 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1720 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1722 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1724 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1727 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1730 if (!threadmatch (&echo_nextthread
, nextthread
))
1732 /* FIXME: This is a good reason to drop the packet. */
1733 /* Possably, there is a duplicate response. */
1735 retransmit immediatly - race conditions
1736 retransmit after timeout - yes
1738 wait for packet, then exit
1740 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1741 return 0; /* I choose simply exiting. */
1743 if (*result_count
<= 0)
1747 warning (_("RMT ERROR : failed to get remote thread list."));
1750 return result
; /* break; */
1752 if (*result_count
> result_limit
)
1755 warning (_("RMT ERROR: threadlist response longer than requested."));
1761 /* This is the interface between remote and threads, remotes upper
1764 /* remote_find_new_threads retrieves the thread list and for each
1765 thread in the list, looks up the thread in GDB's internal list,
1766 ading the thread if it does not already exist. This involves
1767 getting partial thread lists from the remote target so, polling the
1768 quit_flag is required. */
1771 /* About this many threadisds fit in a packet. */
1773 #define MAXTHREADLISTRESULTS 32
1776 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1779 int done
, i
, result_count
;
1783 static threadref nextthread
;
1784 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1789 if (loopcount
++ > looplimit
)
1792 warning (_("Remote fetch threadlist -infinite loop-."));
1795 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1796 &done
, &result_count
, resultthreadlist
))
1801 /* Clear for later iterations. */
1803 /* Setup to resume next batch of thread references, set nextthread. */
1804 if (result_count
>= 1)
1805 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1807 while (result_count
--)
1808 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1815 remote_newthread_step (threadref
*ref
, void *context
)
1819 ptid
= pid_to_ptid (threadref_to_int (ref
));
1821 if (!in_thread_list (ptid
))
1823 return 1; /* continue iterator */
1826 #define CRAZY_MAX_THREADS 1000
1829 remote_current_thread (ptid_t oldpid
)
1831 struct remote_state
*rs
= get_remote_state ();
1834 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1835 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1836 /* Use strtoul here, so we'll correctly parse values whose highest
1837 bit is set. The protocol carries them as a simple series of
1838 hex digits; in the absence of a sign, strtol will see such
1839 values as positive numbers out of range for signed 'long', and
1840 return LONG_MAX to indicate an overflow. */
1841 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1846 /* Find new threads for info threads command.
1847 * Original version, using John Metzler's thread protocol.
1851 remote_find_new_threads (void)
1853 remote_threadlist_iterator (remote_newthread_step
, 0,
1855 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1856 inferior_ptid
= remote_current_thread (inferior_ptid
);
1860 * Find all threads for info threads command.
1861 * Uses new thread protocol contributed by Cisco.
1862 * Falls back and attempts to use the older method (above)
1863 * if the target doesn't respond to the new method.
1867 remote_threads_info (void)
1869 struct remote_state
*rs
= get_remote_state ();
1873 if (remote_desc
== 0) /* paranoia */
1874 error (_("Command can only be used when connected to the remote target."));
1876 if (use_threadinfo_query
)
1878 putpkt ("qfThreadInfo");
1879 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1881 if (bufp
[0] != '\0') /* q packet recognized */
1883 while (*bufp
++ == 'm') /* reply contains one or more TID */
1887 /* Use strtoul here, so we'll correctly parse values
1888 whose highest bit is set. The protocol carries
1889 them as a simple series of hex digits; in the
1890 absence of a sign, strtol will see such values as
1891 positive numbers out of range for signed 'long',
1892 and return LONG_MAX to indicate an overflow. */
1893 tid
= strtoul (bufp
, &bufp
, 16);
1894 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1895 add_thread (pid_to_ptid (tid
));
1897 while (*bufp
++ == ','); /* comma-separated list */
1898 putpkt ("qsThreadInfo");
1899 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1906 /* Else fall back to old method based on jmetzler protocol. */
1907 use_threadinfo_query
= 0;
1908 remote_find_new_threads ();
1913 * Collect a descriptive string about the given thread.
1914 * The target may say anything it wants to about the thread
1915 * (typically info about its blocked / runnable state, name, etc.).
1916 * This string will appear in the info threads display.
1918 * Optional: targets are not required to implement this function.
1922 remote_threads_extra_info (struct thread_info
*tp
)
1924 struct remote_state
*rs
= get_remote_state ();
1928 struct gdb_ext_thread_info threadinfo
;
1929 static char display_buf
[100]; /* arbitrary... */
1930 int n
= 0; /* position in display_buf */
1932 if (remote_desc
== 0) /* paranoia */
1933 internal_error (__FILE__
, __LINE__
,
1934 _("remote_threads_extra_info"));
1936 if (use_threadextra_query
)
1938 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1941 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1942 if (rs
->buf
[0] != 0)
1944 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1945 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1946 display_buf
[result
] = '\0';
1951 /* If the above query fails, fall back to the old method. */
1952 use_threadextra_query
= 0;
1953 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1954 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1955 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1956 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1957 if (threadinfo
.active
)
1959 if (*threadinfo
.shortname
)
1960 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1961 " Name: %s,", threadinfo
.shortname
);
1962 if (*threadinfo
.display
)
1963 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1964 " State: %s,", threadinfo
.display
);
1965 if (*threadinfo
.more_display
)
1966 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1967 " Priority: %s", threadinfo
.more_display
);
1971 /* For purely cosmetic reasons, clear up trailing commas. */
1972 if (',' == display_buf
[n
-1])
1973 display_buf
[n
-1] = ' ';
1981 /* Restart the remote side; this is an extended protocol operation. */
1984 extended_remote_restart (void)
1986 struct remote_state
*rs
= get_remote_state ();
1988 /* Send the restart command; for reasons I don't understand the
1989 remote side really expects a number after the "R". */
1990 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1993 remote_fileio_reset ();
1995 /* Now query for status so this looks just like we restarted
1996 gdbserver from scratch. */
1998 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2001 /* Clean up connection to a remote debugger. */
2004 remote_close (int quitting
)
2007 serial_close (remote_desc
);
2011 /* Query the remote side for the text, data and bss offsets. */
2016 struct remote_state
*rs
= get_remote_state ();
2020 CORE_ADDR text_addr
, data_addr
, bss_addr
;
2021 struct section_offsets
*offs
;
2023 putpkt ("qOffsets");
2024 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2027 if (buf
[0] == '\000')
2028 return; /* Return silently. Stub doesn't support
2032 warning (_("Remote failure reply: %s"), buf
);
2036 /* Pick up each field in turn. This used to be done with scanf, but
2037 scanf will make trouble if CORE_ADDR size doesn't match
2038 conversion directives correctly. The following code will work
2039 with any size of CORE_ADDR. */
2040 text_addr
= data_addr
= bss_addr
= 0;
2044 if (strncmp (ptr
, "Text=", 5) == 0)
2047 /* Don't use strtol, could lose on big values. */
2048 while (*ptr
&& *ptr
!= ';')
2049 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2054 if (!lose
&& strncmp (ptr
, ";Data=", 6) == 0)
2057 while (*ptr
&& *ptr
!= ';')
2058 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2063 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2066 while (*ptr
&& *ptr
!= ';')
2067 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2073 error (_("Malformed response to offset query, %s"), buf
);
2075 if (symfile_objfile
== NULL
)
2078 offs
= ((struct section_offsets
*)
2079 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2080 memcpy (offs
, symfile_objfile
->section_offsets
,
2081 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2083 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2085 /* This is a temporary kludge to force data and bss to use the same offsets
2086 because that's what nlmconv does now. The real solution requires changes
2087 to the stub and remote.c that I don't have time to do right now. */
2089 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2090 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2092 objfile_relocate (symfile_objfile
, offs
);
2095 /* Stub for catch_exception. */
2098 remote_start_remote (struct ui_out
*uiout
, void *from_tty_p
)
2100 int from_tty
= * (int *) from_tty_p
;
2102 immediate_quit
++; /* Allow user to interrupt it. */
2104 /* Ack any packet which the remote side has already sent. */
2105 serial_write (remote_desc
, "+", 1);
2107 /* Let the stub know that we want it to return the thread. */
2110 inferior_ptid
= remote_current_thread (inferior_ptid
);
2112 get_offsets (); /* Get text, data & bss offsets. */
2114 putpkt ("?"); /* Initiate a query from remote machine. */
2117 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
2120 /* Open a connection to a remote debugger.
2121 NAME is the filename used for communication. */
2124 remote_open (char *name
, int from_tty
)
2126 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2129 /* Just like remote_open, but with asynchronous support. */
2131 remote_async_open (char *name
, int from_tty
)
2133 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2136 /* Open a connection to a remote debugger using the extended
2137 remote gdb protocol. NAME is the filename used for communication. */
2140 extended_remote_open (char *name
, int from_tty
)
2142 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2146 /* Just like extended_remote_open, but with asynchronous support. */
2148 extended_remote_async_open (char *name
, int from_tty
)
2150 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2151 1 /*extended_p */, 1 /* async_p */);
2154 /* Generic code for opening a connection to a remote target. */
2157 init_all_packet_configs (void)
2160 for (i
= 0; i
< PACKET_MAX
; i
++)
2161 update_packet_config (&remote_protocol_packets
[i
]);
2164 /* Symbol look-up. */
2167 remote_check_symbols (struct objfile
*objfile
)
2169 struct remote_state
*rs
= get_remote_state ();
2170 char *msg
, *reply
, *tmp
;
2171 struct minimal_symbol
*sym
;
2174 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2177 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2178 because we need both at the same time. */
2179 msg
= alloca (get_remote_packet_size ());
2181 /* Invite target to request symbol lookups. */
2183 putpkt ("qSymbol::");
2184 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2185 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2188 while (strncmp (reply
, "qSymbol:", 8) == 0)
2191 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2193 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2195 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2197 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2198 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2201 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2206 static struct serial
*
2207 remote_serial_open (char *name
)
2209 static int udp_warning
= 0;
2211 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2212 of in ser-tcp.c, because it is the remote protocol assuming that the
2213 serial connection is reliable and not the serial connection promising
2215 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2218 The remote protocol may be unreliable over UDP.\n\
2219 Some events may be lost, rendering further debugging impossible."));
2223 return serial_open (name
);
2226 /* This type describes each known response to the qSupported
2228 struct protocol_feature
2230 /* The name of this protocol feature. */
2233 /* The default for this protocol feature. */
2234 enum packet_support default_support
;
2236 /* The function to call when this feature is reported, or after
2237 qSupported processing if the feature is not supported.
2238 The first argument points to this structure. The second
2239 argument indicates whether the packet requested support be
2240 enabled, disabled, or probed (or the default, if this function
2241 is being called at the end of processing and this feature was
2242 not reported). The third argument may be NULL; if not NULL, it
2243 is a NUL-terminated string taken from the packet following
2244 this feature's name and an equals sign. */
2245 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2248 /* The corresponding packet for this feature. Only used if
2249 FUNC is remote_supported_packet. */
2254 remote_supported_packet (const struct protocol_feature
*feature
,
2255 enum packet_support support
,
2256 const char *argument
)
2260 warning (_("Remote qSupported response supplied an unexpected value for"
2261 " \"%s\"."), feature
->name
);
2265 if (remote_protocol_packets
[feature
->packet
].support
2266 == PACKET_SUPPORT_UNKNOWN
)
2267 remote_protocol_packets
[feature
->packet
].support
= support
;
2271 remote_packet_size (const struct protocol_feature
*feature
,
2272 enum packet_support support
, const char *value
)
2274 struct remote_state
*rs
= get_remote_state ();
2279 if (support
!= PACKET_ENABLE
)
2282 if (value
== NULL
|| *value
== '\0')
2284 warning (_("Remote target reported \"%s\" without a size."),
2290 packet_size
= strtol (value
, &value_end
, 16);
2291 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2293 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2294 feature
->name
, value
);
2298 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2300 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2301 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2302 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2305 /* Record the new maximum packet size. */
2306 rs
->explicit_packet_size
= packet_size
;
2309 static struct protocol_feature remote_protocol_features
[] = {
2310 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2311 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2312 PACKET_qXfer_auxv
},
2313 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2314 PACKET_qXfer_features
},
2315 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2316 PACKET_qXfer_memory_map
},
2317 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2318 PACKET_QPassSignals
},
2322 remote_query_supported (void)
2324 struct remote_state
*rs
= get_remote_state ();
2327 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2329 /* The packet support flags are handled differently for this packet
2330 than for most others. We treat an error, a disabled packet, and
2331 an empty response identically: any features which must be reported
2332 to be used will be automatically disabled. An empty buffer
2333 accomplishes this, since that is also the representation for a list
2334 containing no features. */
2337 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2339 putpkt ("qSupported");
2340 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2342 /* If an error occured, warn, but do not return - just reset the
2343 buffer to empty and go on to disable features. */
2344 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2347 warning (_("Remote failure reply: %s"), rs
->buf
);
2352 memset (seen
, 0, sizeof (seen
));
2357 enum packet_support is_supported
;
2358 char *p
, *end
, *name_end
, *value
;
2360 /* First separate out this item from the rest of the packet. If
2361 there's another item after this, we overwrite the separator
2362 (terminated strings are much easier to work with). */
2364 end
= strchr (p
, ';');
2367 end
= p
+ strlen (p
);
2377 warning (_("empty item in \"qSupported\" response"));
2382 name_end
= strchr (p
, '=');
2385 /* This is a name=value entry. */
2386 is_supported
= PACKET_ENABLE
;
2387 value
= name_end
+ 1;
2396 is_supported
= PACKET_ENABLE
;
2400 is_supported
= PACKET_DISABLE
;
2404 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2408 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2414 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2415 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2417 const struct protocol_feature
*feature
;
2420 feature
= &remote_protocol_features
[i
];
2421 feature
->func (feature
, is_supported
, value
);
2426 /* If we increased the packet size, make sure to increase the global
2427 buffer size also. We delay this until after parsing the entire
2428 qSupported packet, because this is the same buffer we were
2430 if (rs
->buf_size
< rs
->explicit_packet_size
)
2432 rs
->buf_size
= rs
->explicit_packet_size
;
2433 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2436 /* Handle the defaults for unmentioned features. */
2437 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2440 const struct protocol_feature
*feature
;
2442 feature
= &remote_protocol_features
[i
];
2443 feature
->func (feature
, feature
->default_support
, NULL
);
2449 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2450 int extended_p
, int async_p
)
2452 struct remote_state
*rs
= get_remote_state ();
2454 error (_("To open a remote debug connection, you need to specify what\n"
2455 "serial device is attached to the remote system\n"
2456 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2458 /* See FIXME above. */
2460 wait_forever_enabled_p
= 1;
2462 target_preopen (from_tty
);
2464 unpush_target (target
);
2466 /* Make sure we send the passed signals list the next time we resume. */
2467 xfree (last_pass_packet
);
2468 last_pass_packet
= NULL
;
2470 remote_fileio_reset ();
2471 reopen_exec_file ();
2474 remote_desc
= remote_serial_open (name
);
2476 perror_with_name (name
);
2478 if (baud_rate
!= -1)
2480 if (serial_setbaudrate (remote_desc
, baud_rate
))
2482 /* The requested speed could not be set. Error out to
2483 top level after closing remote_desc. Take care to
2484 set remote_desc to NULL to avoid closing remote_desc
2486 serial_close (remote_desc
);
2488 perror_with_name (name
);
2492 serial_raw (remote_desc
);
2494 /* If there is something sitting in the buffer we might take it as a
2495 response to a command, which would be bad. */
2496 serial_flush_input (remote_desc
);
2500 puts_filtered ("Remote debugging using ");
2501 puts_filtered (name
);
2502 puts_filtered ("\n");
2504 push_target (target
); /* Switch to using remote target now. */
2506 /* Reset the target state; these things will be queried either by
2507 remote_query_supported or as they are needed. */
2508 init_all_packet_configs ();
2509 rs
->explicit_packet_size
= 0;
2511 general_thread
= -2;
2512 continue_thread
= -2;
2514 /* Probe for ability to use "ThreadInfo" query, as required. */
2515 use_threadinfo_query
= 1;
2516 use_threadextra_query
= 1;
2518 /* The first packet we send to the target is the optional "supported
2519 packets" request. If the target can answer this, it will tell us
2520 which later probes to skip. */
2521 remote_query_supported ();
2523 /* Next, if the target can specify a description, read it. We do
2524 this before anything involving memory or registers. */
2525 target_find_description ();
2527 /* Without this, some commands which require an active target (such
2528 as kill) won't work. This variable serves (at least) double duty
2529 as both the pid of the target process (if it has such), and as a
2530 flag indicating that a target is active. These functions should
2531 be split out into seperate variables, especially since GDB will
2532 someday have a notion of debugging several processes. */
2534 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2538 /* With this target we start out by owning the terminal. */
2539 remote_async_terminal_ours_p
= 1;
2541 /* FIXME: cagney/1999-09-23: During the initial connection it is
2542 assumed that the target is already ready and able to respond to
2543 requests. Unfortunately remote_start_remote() eventually calls
2544 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2545 around this. Eventually a mechanism that allows
2546 wait_for_inferior() to expect/get timeouts will be
2548 wait_forever_enabled_p
= 0;
2551 /* First delete any symbols previously loaded from shared libraries. */
2552 no_shared_libraries (NULL
, 0);
2554 /* Start the remote connection. If error() or QUIT, discard this
2555 target (we'd otherwise be in an inconsistent state) and then
2556 propogate the error on up the exception chain. This ensures that
2557 the caller doesn't stumble along blindly assuming that the
2558 function succeeded. The CLI doesn't have this problem but other
2559 UI's, such as MI do.
2561 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2562 this function should return an error indication letting the
2563 caller restore the previous state. Unfortunately the command
2564 ``target remote'' is directly wired to this function making that
2565 impossible. On a positive note, the CLI side of this problem has
2566 been fixed - the function set_cmd_context() makes it possible for
2567 all the ``target ....'' commands to share a common callback
2568 function. See cli-dump.c. */
2570 struct gdb_exception ex
2571 = catch_exception (uiout
, remote_start_remote
, &from_tty
,
2577 wait_forever_enabled_p
= 1;
2578 throw_exception (ex
);
2583 wait_forever_enabled_p
= 1;
2587 /* Tell the remote that we are using the extended protocol. */
2589 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2592 if (exec_bfd
) /* No use without an exec file. */
2593 remote_check_symbols (symfile_objfile
);
2596 /* This takes a program previously attached to and detaches it. After
2597 this is done, GDB can be used to debug some other program. We
2598 better not have left any breakpoints in the target program or it'll
2599 die when it hits one. */
2602 remote_detach (char *args
, int from_tty
)
2604 struct remote_state
*rs
= get_remote_state ();
2607 error (_("Argument given to \"detach\" when remotely debugging."));
2609 /* Tell the remote target to detach. */
2610 strcpy (rs
->buf
, "D");
2612 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2614 if (rs
->buf
[0] == 'E')
2615 error (_("Can't detach process."));
2617 /* Unregister the file descriptor from the event loop. */
2618 if (target_is_async_p ())
2619 serial_async (remote_desc
, NULL
, 0);
2621 target_mourn_inferior ();
2623 puts_filtered ("Ending remote debugging.\n");
2626 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2629 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2632 error (_("Argument given to \"detach\" when remotely debugging."));
2634 /* Unregister the file descriptor from the event loop. */
2635 if (target_is_async_p ())
2636 serial_async (remote_desc
, NULL
, 0);
2638 target_mourn_inferior ();
2640 puts_filtered ("Ending remote debugging.\n");
2643 /* Convert hex digit A to a number. */
2648 if (a
>= '0' && a
<= '9')
2650 else if (a
>= 'a' && a
<= 'f')
2651 return a
- 'a' + 10;
2652 else if (a
>= 'A' && a
<= 'F')
2653 return a
- 'A' + 10;
2655 error (_("Reply contains invalid hex digit %d"), a
);
2659 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2663 for (i
= 0; i
< count
; i
++)
2665 if (hex
[0] == 0 || hex
[1] == 0)
2667 /* Hex string is short, or of uneven length.
2668 Return the count that has been converted so far. */
2671 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2677 /* Convert number NIB to a hex digit. */
2685 return 'a' + nib
- 10;
2689 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2692 /* May use a length, or a nul-terminated string as input. */
2694 count
= strlen ((char *) bin
);
2696 for (i
= 0; i
< count
; i
++)
2698 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2699 *hex
++ = tohex (*bin
++ & 0xf);
2705 /* Check for the availability of vCont. This function should also check
2709 remote_vcont_probe (struct remote_state
*rs
)
2713 strcpy (rs
->buf
, "vCont?");
2715 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2718 /* Make sure that the features we assume are supported. */
2719 if (strncmp (buf
, "vCont", 5) == 0)
2722 int support_s
, support_S
, support_c
, support_C
;
2728 while (p
&& *p
== ';')
2731 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2733 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2735 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2737 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2740 p
= strchr (p
, ';');
2743 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2744 BUF will make packet_ok disable the packet. */
2745 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2749 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2752 /* Resume the remote inferior by using a "vCont" packet. The thread
2753 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2754 resumed thread should be single-stepped and/or signalled. If PTID's
2755 PID is -1, then all threads are resumed; the thread to be stepped and/or
2756 signalled is given in the global INFERIOR_PTID. This function returns
2757 non-zero iff it resumes the inferior.
2759 This function issues a strict subset of all possible vCont commands at the
2763 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2765 struct remote_state
*rs
= get_remote_state ();
2766 int pid
= PIDGET (ptid
);
2767 char *buf
= NULL
, *outbuf
;
2768 struct cleanup
*old_cleanup
;
2770 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2771 remote_vcont_probe (rs
);
2773 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2776 /* If we could generate a wider range of packets, we'd have to worry
2777 about overflowing BUF. Should there be a generic
2778 "multi-part-packet" packet? */
2780 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2782 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2783 don't have any PID numbers the inferior will understand. Make sure
2784 to only send forms that do not specify a PID. */
2785 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2786 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2788 outbuf
= xstrprintf ("vCont;s");
2789 else if (siggnal
!= TARGET_SIGNAL_0
)
2790 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2792 outbuf
= xstrprintf ("vCont;c");
2796 /* Resume all threads, with preference for INFERIOR_PTID. */
2797 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2798 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2799 PIDGET (inferior_ptid
));
2801 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2802 else if (siggnal
!= TARGET_SIGNAL_0
)
2803 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2804 PIDGET (inferior_ptid
));
2806 outbuf
= xstrprintf ("vCont;c");
2810 /* Scheduler locking; resume only PTID. */
2811 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2812 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2814 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2815 else if (siggnal
!= TARGET_SIGNAL_0
)
2816 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2818 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2821 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2822 old_cleanup
= make_cleanup (xfree
, outbuf
);
2826 do_cleanups (old_cleanup
);
2831 /* Tell the remote machine to resume. */
2833 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2835 static int last_sent_step
;
2838 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2840 struct remote_state
*rs
= get_remote_state ();
2842 int pid
= PIDGET (ptid
);
2844 last_sent_signal
= siggnal
;
2845 last_sent_step
= step
;
2847 /* A hook for when we need to do something at the last moment before
2849 if (deprecated_target_resume_hook
)
2850 (*deprecated_target_resume_hook
) ();
2852 /* Update the inferior on signals to silently pass, if they've changed. */
2853 remote_pass_signals ();
2855 /* The vCont packet doesn't need to specify threads via Hc. */
2856 if (remote_vcont_resume (ptid
, step
, siggnal
))
2859 /* All other supported resume packets do use Hc, so call set_thread. */
2861 set_thread (0, 0); /* Run any thread. */
2863 set_thread (pid
, 0); /* Run this thread. */
2866 if (siggnal
!= TARGET_SIGNAL_0
)
2868 buf
[0] = step
? 'S' : 'C';
2869 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2870 buf
[2] = tohex (((int) siggnal
) & 0xf);
2874 strcpy (buf
, step
? "s" : "c");
2879 /* Same as remote_resume, but with async support. */
2881 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2883 remote_resume (ptid
, step
, siggnal
);
2885 /* We are about to start executing the inferior, let's register it
2886 with the event loop. NOTE: this is the one place where all the
2887 execution commands end up. We could alternatively do this in each
2888 of the execution commands in infcmd.c. */
2889 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2890 into infcmd.c in order to allow inferior function calls to work
2891 NOT asynchronously. */
2892 if (target_can_async_p ())
2893 target_async (inferior_event_handler
, 0);
2894 /* Tell the world that the target is now executing. */
2895 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2896 this? Instead, should the client of target just assume (for
2897 async targets) that the target is going to start executing? Is
2898 this information already found in the continuation block? */
2899 if (target_is_async_p ())
2900 target_executing
= 1;
2904 /* Set up the signal handler for SIGINT, while the target is
2905 executing, ovewriting the 'regular' SIGINT signal handler. */
2907 initialize_sigint_signal_handler (void)
2909 sigint_remote_token
=
2910 create_async_signal_handler (async_remote_interrupt
, NULL
);
2911 signal (SIGINT
, handle_remote_sigint
);
2914 /* Signal handler for SIGINT, while the target is executing. */
2916 handle_remote_sigint (int sig
)
2918 signal (sig
, handle_remote_sigint_twice
);
2919 sigint_remote_twice_token
=
2920 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2921 mark_async_signal_handler_wrapper (sigint_remote_token
);
2924 /* Signal handler for SIGINT, installed after SIGINT has already been
2925 sent once. It will take effect the second time that the user sends
2928 handle_remote_sigint_twice (int sig
)
2930 signal (sig
, handle_sigint
);
2931 sigint_remote_twice_token
=
2932 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
2933 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
2936 /* Perform the real interruption of the target execution, in response
2939 async_remote_interrupt (gdb_client_data arg
)
2942 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2947 /* Perform interrupt, if the first attempt did not succeed. Just give
2948 up on the target alltogether. */
2950 async_remote_interrupt_twice (gdb_client_data arg
)
2953 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
2954 /* Do something only if the target was not killed by the previous
2956 if (target_executing
)
2959 signal (SIGINT
, handle_remote_sigint
);
2963 /* Reinstall the usual SIGINT handlers, after the target has
2966 cleanup_sigint_signal_handler (void *dummy
)
2968 signal (SIGINT
, handle_sigint
);
2969 if (sigint_remote_twice_token
)
2970 delete_async_signal_handler (&sigint_remote_twice_token
);
2971 if (sigint_remote_token
)
2972 delete_async_signal_handler (&sigint_remote_token
);
2975 /* Send ^C to target to halt it. Target will respond, and send us a
2977 static void (*ofunc
) (int);
2979 /* The command line interface's stop routine. This function is installed
2980 as a signal handler for SIGINT. The first time a user requests a
2981 stop, we call remote_stop to send a break or ^C. If there is no
2982 response from the target (it didn't stop when the user requested it),
2983 we ask the user if he'd like to detach from the target. */
2985 remote_interrupt (int signo
)
2987 /* If this doesn't work, try more severe steps. */
2988 signal (signo
, remote_interrupt_twice
);
2991 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2996 /* The user typed ^C twice. */
2999 remote_interrupt_twice (int signo
)
3001 signal (signo
, ofunc
);
3003 signal (signo
, remote_interrupt
);
3006 /* This is the generic stop called via the target vector. When a target
3007 interrupt is requested, either by the command line or the GUI, we
3008 will eventually end up here. */
3012 /* Send a break or a ^C, depending on user preference. */
3014 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
3017 serial_send_break (remote_desc
);
3019 serial_write (remote_desc
, "\003", 1);
3022 /* Ask the user what to do when an interrupt is received. */
3025 interrupt_query (void)
3027 target_terminal_ours ();
3029 if (query ("Interrupted while waiting for the program.\n\
3030 Give up (and stop debugging it)? "))
3032 target_mourn_inferior ();
3033 deprecated_throw_reason (RETURN_QUIT
);
3036 target_terminal_inferior ();
3039 /* Enable/disable target terminal ownership. Most targets can use
3040 terminal groups to control terminal ownership. Remote targets are
3041 different in that explicit transfer of ownership to/from GDB/target
3045 remote_async_terminal_inferior (void)
3047 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3048 sync_execution here. This function should only be called when
3049 GDB is resuming the inferior in the forground. A background
3050 resume (``run&'') should leave GDB in control of the terminal and
3051 consequently should not call this code. */
3052 if (!sync_execution
)
3054 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3055 calls target_terminal_*() idenpotent. The event-loop GDB talking
3056 to an asynchronous target with a synchronous command calls this
3057 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3058 stops trying to transfer the terminal to the target when it
3059 shouldn't this guard can go away. */
3060 if (!remote_async_terminal_ours_p
)
3062 delete_file_handler (input_fd
);
3063 remote_async_terminal_ours_p
= 0;
3064 initialize_sigint_signal_handler ();
3065 /* NOTE: At this point we could also register our selves as the
3066 recipient of all input. Any characters typed could then be
3067 passed on down to the target. */
3071 remote_async_terminal_ours (void)
3073 /* See FIXME in remote_async_terminal_inferior. */
3074 if (!sync_execution
)
3076 /* See FIXME in remote_async_terminal_inferior. */
3077 if (remote_async_terminal_ours_p
)
3079 cleanup_sigint_signal_handler (NULL
);
3080 add_file_handler (input_fd
, stdin_event_handler
, 0);
3081 remote_async_terminal_ours_p
= 1;
3084 /* If nonzero, ignore the next kill. */
3089 remote_console_output (char *msg
)
3093 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3096 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3099 fputs_unfiltered (tb
, gdb_stdtarg
);
3101 gdb_flush (gdb_stdtarg
);
3104 /* Wait until the remote machine stops, then return,
3105 storing status in STATUS just as `wait' would.
3106 Returns "pid", which in the case of a multi-threaded
3107 remote OS, is the thread-id. */
3110 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3112 struct remote_state
*rs
= get_remote_state ();
3113 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3114 ULONGEST thread_num
= -1;
3117 status
->kind
= TARGET_WAITKIND_EXITED
;
3118 status
->value
.integer
= 0;
3124 ofunc
= signal (SIGINT
, remote_interrupt
);
3125 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3126 signal (SIGINT
, ofunc
);
3130 /* This is a hook for when we need to do something (perhaps the
3131 collection of trace data) every time the target stops. */
3132 if (deprecated_target_wait_loop_hook
)
3133 (*deprecated_target_wait_loop_hook
) ();
3135 remote_stopped_by_watchpoint_p
= 0;
3139 case 'E': /* Error of some sort. */
3140 warning (_("Remote failure reply: %s"), buf
);
3142 case 'F': /* File-I/O request. */
3143 remote_fileio_request (buf
);
3145 case 'T': /* Status with PC, SP, FP, ... */
3147 gdb_byte regs
[MAX_REGISTER_SIZE
];
3149 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3150 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3152 n... = register number
3153 r... = register contents
3155 p
= &buf
[3]; /* after Txx */
3164 /* If the packet contains a register number save it in
3165 pnum and set p1 to point to the character following
3166 it. Otherwise p1 points to p. */
3168 /* If this packet is an awatch packet, don't parse the
3169 'a' as a register number. */
3171 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3173 /* Read the ``P'' register number. */
3174 pnum
= strtol (p
, &p_temp
, 16);
3180 if (p1
== p
) /* No register number present here. */
3182 p1
= strchr (p
, ':');
3184 error (_("Malformed packet(a) (missing colon): %s\n\
3187 if (strncmp (p
, "thread", p1
- p
) == 0)
3189 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3190 record_currthread (thread_num
);
3193 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3194 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3195 || (strncmp (p
, "awatch", p1
- p
) == 0))
3197 remote_stopped_by_watchpoint_p
= 1;
3198 p
= unpack_varlen_hex (++p1
, &addr
);
3199 remote_watch_data_address
= (CORE_ADDR
)addr
;
3203 /* Silently skip unknown optional info. */
3204 p_temp
= strchr (p1
+ 1, ';');
3211 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3215 error (_("Malformed packet(b) (missing colon): %s\n\
3220 error (_("Remote sent bad register number %s: %s\n\
3222 phex_nz (pnum
, 0), p
, buf
);
3224 fieldsize
= hex2bin (p
, regs
,
3225 register_size (current_gdbarch
,
3228 if (fieldsize
< register_size (current_gdbarch
,
3230 warning (_("Remote reply is too short: %s"), buf
);
3231 regcache_raw_supply (current_regcache
,
3236 error (_("Remote register badly formatted: %s\nhere: %s"),
3241 case 'S': /* Old style status, just signal only. */
3242 status
->kind
= TARGET_WAITKIND_STOPPED
;
3243 status
->value
.sig
= (enum target_signal
)
3244 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3248 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3249 record_currthread (thread_num
);
3252 case 'W': /* Target exited. */
3254 /* The remote process exited. */
3255 status
->kind
= TARGET_WAITKIND_EXITED
;
3256 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3260 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3261 status
->value
.sig
= (enum target_signal
)
3262 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3266 case 'O': /* Console output. */
3267 remote_console_output (buf
+ 1);
3270 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3272 /* Zero length reply means that we tried 'S' or 'C' and
3273 the remote system doesn't support it. */
3274 target_terminal_ours_for_output ();
3276 ("Can't send signals to this remote system. %s not sent.\n",
3277 target_signal_to_name (last_sent_signal
));
3278 last_sent_signal
= TARGET_SIGNAL_0
;
3279 target_terminal_inferior ();
3281 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3282 putpkt ((char *) buf
);
3285 /* else fallthrough */
3287 warning (_("Invalid remote reply: %s"), buf
);
3292 if (thread_num
!= -1)
3294 return pid_to_ptid (thread_num
);
3296 return inferior_ptid
;
3299 /* Async version of remote_wait. */
3301 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3303 struct remote_state
*rs
= get_remote_state ();
3304 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3305 ULONGEST thread_num
= -1;
3308 status
->kind
= TARGET_WAITKIND_EXITED
;
3309 status
->value
.integer
= 0;
3311 remote_stopped_by_watchpoint_p
= 0;
3317 if (!target_is_async_p ())
3318 ofunc
= signal (SIGINT
, remote_interrupt
);
3319 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3320 _never_ wait for ever -> test on target_is_async_p().
3321 However, before we do that we need to ensure that the caller
3322 knows how to take the target into/out of async mode. */
3323 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3324 if (!target_is_async_p ())
3325 signal (SIGINT
, ofunc
);
3329 /* This is a hook for when we need to do something (perhaps the
3330 collection of trace data) every time the target stops. */
3331 if (deprecated_target_wait_loop_hook
)
3332 (*deprecated_target_wait_loop_hook
) ();
3336 case 'E': /* Error of some sort. */
3337 warning (_("Remote failure reply: %s"), buf
);
3339 case 'F': /* File-I/O request. */
3340 remote_fileio_request (buf
);
3342 case 'T': /* Status with PC, SP, FP, ... */
3344 gdb_byte regs
[MAX_REGISTER_SIZE
];
3346 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3347 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3349 n... = register number
3350 r... = register contents
3352 p
= &buf
[3]; /* after Txx */
3361 /* If the packet contains a register number, save it
3362 in pnum and set p1 to point to the character
3363 following it. Otherwise p1 points to p. */
3365 /* If this packet is an awatch packet, don't parse the 'a'
3366 as a register number. */
3368 if (!strncmp (p
, "awatch", strlen ("awatch")) != 0)
3370 /* Read the register number. */
3371 pnum
= strtol (p
, &p_temp
, 16);
3377 if (p1
== p
) /* No register number present here. */
3379 p1
= strchr (p
, ':');
3381 error (_("Malformed packet(a) (missing colon): %s\n\
3384 if (strncmp (p
, "thread", p1
- p
) == 0)
3386 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3387 record_currthread (thread_num
);
3390 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3391 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3392 || (strncmp (p
, "awatch", p1
- p
) == 0))
3394 remote_stopped_by_watchpoint_p
= 1;
3395 p
= unpack_varlen_hex (++p1
, &addr
);
3396 remote_watch_data_address
= (CORE_ADDR
)addr
;
3400 /* Silently skip unknown optional info. */
3401 p_temp
= strchr (p1
+ 1, ';');
3409 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3412 error (_("Malformed packet(b) (missing colon): %s\n\
3417 error (_("Remote sent bad register number %ld: %s\n\
3421 fieldsize
= hex2bin (p
, regs
,
3422 register_size (current_gdbarch
,
3425 if (fieldsize
< register_size (current_gdbarch
,
3427 warning (_("Remote reply is too short: %s"), buf
);
3428 regcache_raw_supply (current_regcache
, reg
->regnum
, regs
);
3432 error (_("Remote register badly formatted: %s\nhere: %s"),
3437 case 'S': /* Old style status, just signal only. */
3438 status
->kind
= TARGET_WAITKIND_STOPPED
;
3439 status
->value
.sig
= (enum target_signal
)
3440 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3444 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3445 record_currthread (thread_num
);
3448 case 'W': /* Target exited. */
3450 /* The remote process exited. */
3451 status
->kind
= TARGET_WAITKIND_EXITED
;
3452 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3456 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3457 status
->value
.sig
= (enum target_signal
)
3458 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3462 case 'O': /* Console output. */
3463 remote_console_output (buf
+ 1);
3464 /* Return immediately to the event loop. The event loop will
3465 still be waiting on the inferior afterwards. */
3466 status
->kind
= TARGET_WAITKIND_IGNORE
;
3469 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3471 /* Zero length reply means that we tried 'S' or 'C' and
3472 the remote system doesn't support it. */
3473 target_terminal_ours_for_output ();
3475 ("Can't send signals to this remote system. %s not sent.\n",
3476 target_signal_to_name (last_sent_signal
));
3477 last_sent_signal
= TARGET_SIGNAL_0
;
3478 target_terminal_inferior ();
3480 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3481 putpkt ((char *) buf
);
3484 /* else fallthrough */
3486 warning (_("Invalid remote reply: %s"), buf
);
3491 if (thread_num
!= -1)
3493 return pid_to_ptid (thread_num
);
3495 return inferior_ptid
;
3498 /* Fetch a single register using a 'p' packet. */
3501 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3503 struct remote_state
*rs
= get_remote_state ();
3505 char regp
[MAX_REGISTER_SIZE
];
3508 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3511 if (reg
->pnum
== -1)
3516 p
+= hexnumstr (p
, reg
->pnum
);
3518 remote_send (&rs
->buf
, &rs
->buf_size
);
3522 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3526 case PACKET_UNKNOWN
:
3529 error (_("Could not fetch register \"%s\""),
3530 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3533 /* If this register is unfetchable, tell the regcache. */
3536 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3540 /* Otherwise, parse and supply the value. */
3546 error (_("fetch_register_using_p: early buf termination"));
3548 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3551 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3555 /* Fetch the registers included in the target's 'g' packet. */
3558 send_g_packet (void)
3560 struct remote_state
*rs
= get_remote_state ();
3565 sprintf (rs
->buf
, "g");
3566 remote_send (&rs
->buf
, &rs
->buf_size
);
3568 /* We can get out of synch in various cases. If the first character
3569 in the buffer is not a hex character, assume that has happened
3570 and try to fetch another packet to read. */
3571 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3572 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3573 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3574 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3577 fprintf_unfiltered (gdb_stdlog
,
3578 "Bad register packet; fetching a new packet\n");
3579 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3582 buf_len
= strlen (rs
->buf
);
3584 /* Sanity check the received packet. */
3585 if (buf_len
% 2 != 0)
3586 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3592 process_g_packet (struct regcache
*regcache
)
3594 struct remote_state
*rs
= get_remote_state ();
3595 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3600 buf_len
= strlen (rs
->buf
);
3602 /* Further sanity checks, with knowledge of the architecture. */
3603 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3604 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3606 /* Save the size of the packet sent to us by the target. It is used
3607 as a heuristic when determining the max size of packets that the
3608 target can safely receive. */
3609 if (rsa
->actual_register_packet_size
== 0)
3610 rsa
->actual_register_packet_size
= buf_len
;
3612 /* If this is smaller than we guessed the 'g' packet would be,
3613 update our records. A 'g' reply that doesn't include a register's
3614 value implies either that the register is not available, or that
3615 the 'p' packet must be used. */
3616 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3618 rsa
->sizeof_g_packet
= buf_len
/ 2;
3620 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3622 if (rsa
->regs
[i
].pnum
== -1)
3625 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3626 rsa
->regs
[i
].in_g_packet
= 0;
3628 rsa
->regs
[i
].in_g_packet
= 1;
3632 regs
= alloca (rsa
->sizeof_g_packet
);
3634 /* Unimplemented registers read as all bits zero. */
3635 memset (regs
, 0, rsa
->sizeof_g_packet
);
3637 /* Reply describes registers byte by byte, each byte encoded as two
3638 hex characters. Suck them all up, then supply them to the
3639 register cacheing/storage mechanism. */
3642 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3644 if (p
[0] == 0 || p
[1] == 0)
3645 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3646 internal_error (__FILE__
, __LINE__
,
3647 "unexpected end of 'g' packet reply");
3649 if (p
[0] == 'x' && p
[1] == 'x')
3650 regs
[i
] = 0; /* 'x' */
3652 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3658 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3660 struct packet_reg
*r
= &rsa
->regs
[i
];
3663 if (r
->offset
* 2 >= strlen (rs
->buf
))
3664 /* This shouldn't happen - we adjusted in_g_packet above. */
3665 internal_error (__FILE__
, __LINE__
,
3666 "unexpected end of 'g' packet reply");
3667 else if (rs
->buf
[r
->offset
* 2] == 'x')
3669 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3670 /* The register isn't available, mark it as such (at
3671 the same time setting the value to zero). */
3672 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3675 regcache_raw_supply (regcache
, r
->regnum
,
3683 fetch_registers_using_g (struct regcache
*regcache
)
3686 process_g_packet (regcache
);
3690 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3692 struct remote_state
*rs
= get_remote_state ();
3693 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3696 set_thread (PIDGET (inferior_ptid
), 1);
3700 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3701 gdb_assert (reg
!= NULL
);
3703 /* If this register might be in the 'g' packet, try that first -
3704 we are likely to read more than one register. If this is the
3705 first 'g' packet, we might be overly optimistic about its
3706 contents, so fall back to 'p'. */
3707 if (reg
->in_g_packet
)
3709 fetch_registers_using_g (regcache
);
3710 if (reg
->in_g_packet
)
3714 if (fetch_register_using_p (regcache
, reg
))
3717 /* This register is not available. */
3718 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3723 fetch_registers_using_g (regcache
);
3725 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3726 if (!rsa
->regs
[i
].in_g_packet
)
3727 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3729 /* This register is not available. */
3730 regcache_raw_supply (regcache
, i
, NULL
);
3734 /* Prepare to store registers. Since we may send them all (using a
3735 'G' request), we have to read out the ones we don't want to change
3739 remote_prepare_to_store (struct regcache
*regcache
)
3741 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3743 gdb_byte buf
[MAX_REGISTER_SIZE
];
3745 /* Make sure the entire registers array is valid. */
3746 switch (remote_protocol_packets
[PACKET_P
].support
)
3748 case PACKET_DISABLE
:
3749 case PACKET_SUPPORT_UNKNOWN
:
3750 /* Make sure all the necessary registers are cached. */
3751 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3752 if (rsa
->regs
[i
].in_g_packet
)
3753 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3760 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3761 packet was not recognized. */
3764 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3766 struct remote_state
*rs
= get_remote_state ();
3767 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3768 /* Try storing a single register. */
3769 char *buf
= rs
->buf
;
3770 gdb_byte regp
[MAX_REGISTER_SIZE
];
3773 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3776 if (reg
->pnum
== -1)
3779 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3780 p
= buf
+ strlen (buf
);
3781 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3782 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3783 remote_send (&rs
->buf
, &rs
->buf_size
);
3785 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3790 error (_("Could not write register \"%s\""),
3791 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3792 case PACKET_UNKNOWN
:
3795 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3799 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3800 contents of the register cache buffer. FIXME: ignores errors. */
3803 store_registers_using_G (const struct regcache
*regcache
)
3805 struct remote_state
*rs
= get_remote_state ();
3806 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3810 /* Extract all the registers in the regcache copying them into a
3814 regs
= alloca (rsa
->sizeof_g_packet
);
3815 memset (regs
, 0, rsa
->sizeof_g_packet
);
3816 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3818 struct packet_reg
*r
= &rsa
->regs
[i
];
3820 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3824 /* Command describes registers byte by byte,
3825 each byte encoded as two hex characters. */
3828 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3830 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3831 remote_send (&rs
->buf
, &rs
->buf_size
);
3834 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3835 of the register cache buffer. FIXME: ignores errors. */
3838 remote_store_registers (struct regcache
*regcache
, int regnum
)
3840 struct remote_state
*rs
= get_remote_state ();
3841 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3844 set_thread (PIDGET (inferior_ptid
), 1);
3848 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3849 gdb_assert (reg
!= NULL
);
3851 /* Always prefer to store registers using the 'P' packet if
3852 possible; we often change only a small number of registers.
3853 Sometimes we change a larger number; we'd need help from a
3854 higher layer to know to use 'G'. */
3855 if (store_register_using_P (regcache
, reg
))
3858 /* For now, don't complain if we have no way to write the
3859 register. GDB loses track of unavailable registers too
3860 easily. Some day, this may be an error. We don't have
3861 any way to read the register, either... */
3862 if (!reg
->in_g_packet
)
3865 store_registers_using_G (regcache
);
3869 store_registers_using_G (regcache
);
3871 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3872 if (!rsa
->regs
[i
].in_g_packet
)
3873 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
3874 /* See above for why we do not issue an error here. */
3879 /* Return the number of hex digits in num. */
3882 hexnumlen (ULONGEST num
)
3886 for (i
= 0; num
!= 0; i
++)
3892 /* Set BUF to the minimum number of hex digits representing NUM. */
3895 hexnumstr (char *buf
, ULONGEST num
)
3897 int len
= hexnumlen (num
);
3898 return hexnumnstr (buf
, num
, len
);
3902 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3905 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3911 for (i
= width
- 1; i
>= 0; i
--)
3913 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3920 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3923 remote_address_masked (CORE_ADDR addr
)
3925 if (remote_address_size
> 0
3926 && remote_address_size
< (sizeof (ULONGEST
) * 8))
3928 /* Only create a mask when that mask can safely be constructed
3929 in a ULONGEST variable. */
3931 mask
= (mask
<< remote_address_size
) - 1;
3937 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
3938 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
3939 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
3940 (which may be more than *OUT_LEN due to escape characters). The
3941 total number of bytes in the output buffer will be at most
3945 remote_escape_output (const gdb_byte
*buffer
, int len
,
3946 gdb_byte
*out_buf
, int *out_len
,
3949 int input_index
, output_index
;
3952 for (input_index
= 0; input_index
< len
; input_index
++)
3954 gdb_byte b
= buffer
[input_index
];
3956 if (b
== '$' || b
== '#' || b
== '}')
3958 /* These must be escaped. */
3959 if (output_index
+ 2 > out_maxlen
)
3961 out_buf
[output_index
++] = '}';
3962 out_buf
[output_index
++] = b
^ 0x20;
3966 if (output_index
+ 1 > out_maxlen
)
3968 out_buf
[output_index
++] = b
;
3972 *out_len
= input_index
;
3973 return output_index
;
3976 /* Convert BUFFER, escaped data LEN bytes long, into binary data
3977 in OUT_BUF. Return the number of bytes written to OUT_BUF.
3978 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
3980 This function reverses remote_escape_output. It allows more
3981 escaped characters than that function does, in particular because
3982 '*' must be escaped to avoid the run-length encoding processing
3983 in reading packets. */
3986 remote_unescape_input (const gdb_byte
*buffer
, int len
,
3987 gdb_byte
*out_buf
, int out_maxlen
)
3989 int input_index
, output_index
;
3994 for (input_index
= 0; input_index
< len
; input_index
++)
3996 gdb_byte b
= buffer
[input_index
];
3998 if (output_index
+ 1 > out_maxlen
)
4000 warning (_("Received too much data from remote target;"
4001 " ignoring overflow."));
4002 return output_index
;
4007 out_buf
[output_index
++] = b
^ 0x20;
4013 out_buf
[output_index
++] = b
;
4017 error (_("Unmatched escape character in target response."));
4019 return output_index
;
4022 /* Determine whether the remote target supports binary downloading.
4023 This is accomplished by sending a no-op memory write of zero length
4024 to the target at the specified address. It does not suffice to send
4025 the whole packet, since many stubs strip the eighth bit and
4026 subsequently compute a wrong checksum, which causes real havoc with
4029 NOTE: This can still lose if the serial line is not eight-bit
4030 clean. In cases like this, the user should clear "remote
4034 check_binary_download (CORE_ADDR addr
)
4036 struct remote_state
*rs
= get_remote_state ();
4038 switch (remote_protocol_packets
[PACKET_X
].support
)
4040 case PACKET_DISABLE
:
4044 case PACKET_SUPPORT_UNKNOWN
:
4050 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4052 p
+= hexnumstr (p
, (ULONGEST
) 0);
4056 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4057 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4059 if (rs
->buf
[0] == '\0')
4062 fprintf_unfiltered (gdb_stdlog
,
4063 "binary downloading NOT suppported by target\n");
4064 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4069 fprintf_unfiltered (gdb_stdlog
,
4070 "binary downloading suppported by target\n");
4071 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4078 /* Write memory data directly to the remote machine.
4079 This does not inform the data cache; the data cache uses this.
4080 HEADER is the starting part of the packet.
4081 MEMADDR is the address in the remote memory space.
4082 MYADDR is the address of the buffer in our space.
4083 LEN is the number of bytes.
4084 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4085 should send data as binary ('X'), or hex-encoded ('M').
4087 The function creates packet of the form
4088 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4090 where encoding of <DATA> is termined by PACKET_FORMAT.
4092 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4095 Returns the number of bytes transferred, or 0 (setting errno) for
4096 error. Only transfer a single packet. */
4099 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4100 const gdb_byte
*myaddr
, int len
,
4101 char packet_format
, int use_length
)
4103 struct remote_state
*rs
= get_remote_state ();
4113 if (packet_format
!= 'X' && packet_format
!= 'M')
4114 internal_error (__FILE__
, __LINE__
,
4115 "remote_write_bytes_aux: bad packet format");
4120 payload_size
= get_memory_write_packet_size ();
4122 /* The packet buffer will be large enough for the payload;
4123 get_memory_packet_size ensures this. */
4126 /* Compute the size of the actual payload by subtracting out the
4127 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4129 payload_size
-= strlen ("$,:#NN");
4131 /* The comma won't be used. */
4133 header_length
= strlen (header
);
4134 payload_size
-= header_length
;
4135 payload_size
-= hexnumlen (memaddr
);
4137 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4139 strcat (rs
->buf
, header
);
4140 p
= rs
->buf
+ strlen (header
);
4142 /* Compute a best guess of the number of bytes actually transfered. */
4143 if (packet_format
== 'X')
4145 /* Best guess at number of bytes that will fit. */
4146 todo
= min (len
, payload_size
);
4148 payload_size
-= hexnumlen (todo
);
4149 todo
= min (todo
, payload_size
);
4153 /* Num bytes that will fit. */
4154 todo
= min (len
, payload_size
/ 2);
4156 payload_size
-= hexnumlen (todo
);
4157 todo
= min (todo
, payload_size
/ 2);
4161 internal_error (__FILE__
, __LINE__
,
4162 _("minumum packet size too small to write data"));
4164 /* If we already need another packet, then try to align the end
4165 of this packet to a useful boundary. */
4166 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4167 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4169 /* Append "<memaddr>". */
4170 memaddr
= remote_address_masked (memaddr
);
4171 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4178 /* Append <len>. Retain the location/size of <len>. It may need to
4179 be adjusted once the packet body has been created. */
4181 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4189 /* Append the packet body. */
4190 if (packet_format
== 'X')
4192 /* Binary mode. Send target system values byte by byte, in
4193 increasing byte addresses. Only escape certain critical
4195 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4198 /* If not all TODO bytes fit, then we'll need another packet. Make
4199 a second try to keep the end of the packet aligned. Don't do
4200 this if the packet is tiny. */
4201 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4205 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4207 if (new_nr_bytes
!= nr_bytes
)
4208 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4213 p
+= payload_length
;
4214 if (use_length
&& nr_bytes
< todo
)
4216 /* Escape chars have filled up the buffer prematurely,
4217 and we have actually sent fewer bytes than planned.
4218 Fix-up the length field of the packet. Use the same
4219 number of characters as before. */
4220 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4221 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4226 /* Normal mode: Send target system values byte by byte, in
4227 increasing byte addresses. Each byte is encoded as a two hex
4229 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4233 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4234 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4236 if (rs
->buf
[0] == 'E')
4238 /* There is no correspondance between what the remote protocol
4239 uses for errors and errno codes. We would like a cleaner way
4240 of representing errors (big enough to include errno codes,
4241 bfd_error codes, and others). But for now just return EIO. */
4246 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4247 fewer bytes than we'd planned. */
4251 /* Write memory data directly to the remote machine.
4252 This does not inform the data cache; the data cache uses this.
4253 MEMADDR is the address in the remote memory space.
4254 MYADDR is the address of the buffer in our space.
4255 LEN is the number of bytes.
4257 Returns number of bytes transferred, or 0 (setting errno) for
4258 error. Only transfer a single packet. */
4261 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4263 char *packet_format
= 0;
4265 /* Check whether the target supports binary download. */
4266 check_binary_download (memaddr
);
4268 switch (remote_protocol_packets
[PACKET_X
].support
)
4271 packet_format
= "X";
4273 case PACKET_DISABLE
:
4274 packet_format
= "M";
4276 case PACKET_SUPPORT_UNKNOWN
:
4277 internal_error (__FILE__
, __LINE__
,
4278 _("remote_write_bytes: bad internal state"));
4280 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4283 return remote_write_bytes_aux (packet_format
,
4284 memaddr
, myaddr
, len
, packet_format
[0], 1);
4287 /* Read memory data directly from the remote machine.
4288 This does not use the data cache; the data cache uses this.
4289 MEMADDR is the address in the remote memory space.
4290 MYADDR is the address of the buffer in our space.
4291 LEN is the number of bytes.
4293 Returns number of bytes transferred, or 0 for error. */
4295 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4296 remote targets) shouldn't attempt to read the entire buffer.
4297 Instead it should read a single packet worth of data and then
4298 return the byte size of that packet to the caller. The caller (its
4299 caller and its callers caller ;-) already contains code for
4300 handling partial reads. */
4303 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4305 struct remote_state
*rs
= get_remote_state ();
4306 int max_buf_size
; /* Max size of packet output buffer. */
4312 max_buf_size
= get_memory_read_packet_size ();
4313 /* The packet buffer will be large enough for the payload;
4314 get_memory_packet_size ensures this. */
4323 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4325 /* construct "m"<memaddr>","<len>" */
4326 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4327 memaddr
= remote_address_masked (memaddr
);
4330 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4332 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4336 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4338 if (rs
->buf
[0] == 'E'
4339 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4340 && rs
->buf
[3] == '\0')
4342 /* There is no correspondance between what the remote
4343 protocol uses for errors and errno codes. We would like
4344 a cleaner way of representing errors (big enough to
4345 include errno codes, bfd_error codes, and others). But
4346 for now just return EIO. */
4351 /* Reply describes memory byte by byte,
4352 each byte encoded as two hex characters. */
4355 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4357 /* Reply is short. This means that we were able to read
4358 only part of what we wanted to. */
4359 return i
+ (origlen
- len
);
4368 /* Read or write LEN bytes from inferior memory at MEMADDR,
4369 transferring to or from debugger address BUFFER. Write to inferior
4370 if SHOULD_WRITE is nonzero. Returns length of data written or
4371 read; 0 for error. TARGET is unused. */
4374 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4375 int should_write
, struct mem_attrib
*attrib
,
4376 struct target_ops
*target
)
4381 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4383 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4388 /* Sends a packet with content determined by the printf format string
4389 FORMAT and the remaining arguments, then gets the reply. Returns
4390 whether the packet was a success, a failure, or unknown. */
4393 remote_send_printf (const char *format
, ...)
4395 struct remote_state
*rs
= get_remote_state ();
4396 int max_size
= get_remote_packet_size ();
4399 va_start (ap
, format
);
4402 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4403 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4405 if (putpkt (rs
->buf
) < 0)
4406 error (_("Communication problem with target."));
4409 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4411 return packet_check_result (rs
->buf
);
4415 restore_remote_timeout (void *p
)
4417 int value
= *(int *)p
;
4418 remote_timeout
= value
;
4421 /* Flash writing can take quite some time. We'll set
4422 effectively infinite timeout for flash operations.
4423 In future, we'll need to decide on a better approach. */
4424 static const int remote_flash_timeout
= 1000;
4427 remote_flash_erase (struct target_ops
*ops
,
4428 ULONGEST address
, LONGEST length
)
4430 int saved_remote_timeout
= remote_timeout
;
4431 enum packet_result ret
;
4433 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4434 &saved_remote_timeout
);
4435 remote_timeout
= remote_flash_timeout
;
4437 ret
= remote_send_printf ("vFlashErase:%s,%s",
4442 case PACKET_UNKNOWN
:
4443 error (_("Remote target does not support flash erase"));
4445 error (_("Error erasing flash with vFlashErase packet"));
4450 do_cleanups (back_to
);
4454 remote_flash_write (struct target_ops
*ops
,
4455 ULONGEST address
, LONGEST length
,
4456 const gdb_byte
*data
)
4458 int saved_remote_timeout
= remote_timeout
;
4460 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4461 &saved_remote_timeout
);
4463 remote_timeout
= remote_flash_timeout
;
4464 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4465 do_cleanups (back_to
);
4471 remote_flash_done (struct target_ops
*ops
)
4473 int saved_remote_timeout
= remote_timeout
;
4475 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4476 &saved_remote_timeout
);
4478 remote_timeout
= remote_flash_timeout
;
4479 ret
= remote_send_printf ("vFlashDone");
4480 do_cleanups (back_to
);
4484 case PACKET_UNKNOWN
:
4485 error (_("Remote target does not support vFlashDone"));
4487 error (_("Error finishing flash operation"));
4494 remote_files_info (struct target_ops
*ignore
)
4496 puts_filtered ("Debugging a target over a serial line.\n");
4499 /* Stuff for dealing with the packets which are part of this protocol.
4500 See comment at top of file for details. */
4502 /* Read a single character from the remote end. */
4505 readchar (int timeout
)
4509 ch
= serial_readchar (remote_desc
, timeout
);
4514 switch ((enum serial_rc
) ch
)
4517 target_mourn_inferior ();
4518 error (_("Remote connection closed"));
4521 perror_with_name (_("Remote communication error"));
4523 case SERIAL_TIMEOUT
:
4529 /* Send the command in *BUF to the remote machine, and read the reply
4530 into *BUF. Report an error if we get an error reply. Resize
4531 *BUF using xrealloc if necessary to hold the result, and update
4535 remote_send (char **buf
,
4539 getpkt (buf
, sizeof_buf
, 0);
4541 if ((*buf
)[0] == 'E')
4542 error (_("Remote failure reply: %s"), *buf
);
4545 /* Display a null-terminated packet on stdout, for debugging, using C
4549 print_packet (char *buf
)
4551 puts_filtered ("\"");
4552 fputstr_filtered (buf
, '"', gdb_stdout
);
4553 puts_filtered ("\"");
4559 return putpkt_binary (buf
, strlen (buf
));
4562 /* Send a packet to the remote machine, with error checking. The data
4563 of the packet is in BUF. The string in BUF can be at most
4564 get_remote_packet_size () - 5 to account for the $, # and checksum,
4565 and for a possible /0 if we are debugging (remote_debug) and want
4566 to print the sent packet as a string. */
4569 putpkt_binary (char *buf
, int cnt
)
4572 unsigned char csum
= 0;
4573 char *buf2
= alloca (cnt
+ 6);
4579 /* Copy the packet into buffer BUF2, encapsulating it
4580 and giving it a checksum. */
4585 for (i
= 0; i
< cnt
; i
++)
4591 *p
++ = tohex ((csum
>> 4) & 0xf);
4592 *p
++ = tohex (csum
& 0xf);
4594 /* Send it over and over until we get a positive ack. */
4598 int started_error_output
= 0;
4603 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4604 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4605 fprintf_unfiltered (gdb_stdlog
, "...");
4606 gdb_flush (gdb_stdlog
);
4608 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4609 perror_with_name (_("putpkt: write failed"));
4611 /* Read until either a timeout occurs (-2) or '+' is read. */
4614 ch
= readchar (remote_timeout
);
4622 case SERIAL_TIMEOUT
:
4624 if (started_error_output
)
4626 putchar_unfiltered ('\n');
4627 started_error_output
= 0;
4636 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4640 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4641 case SERIAL_TIMEOUT
:
4645 break; /* Retransmit buffer. */
4649 fprintf_unfiltered (gdb_stdlog
,
4650 "Packet instead of Ack, ignoring it\n");
4651 /* It's probably an old response sent because an ACK
4652 was lost. Gobble up the packet and ack it so it
4653 doesn't get retransmitted when we resend this
4656 serial_write (remote_desc
, "+", 1);
4657 continue; /* Now, go look for +. */
4662 if (!started_error_output
)
4664 started_error_output
= 1;
4665 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4667 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4671 break; /* Here to retransmit. */
4675 /* This is wrong. If doing a long backtrace, the user should be
4676 able to get out next time we call QUIT, without anything as
4677 violent as interrupt_query. If we want to provide a way out of
4678 here without getting to the next QUIT, it should be based on
4679 hitting ^C twice as in remote_wait. */
4689 /* Come here after finding the start of a frame when we expected an
4690 ack. Do our best to discard the rest of this packet. */
4699 c
= readchar (remote_timeout
);
4702 case SERIAL_TIMEOUT
:
4703 /* Nothing we can do. */
4706 /* Discard the two bytes of checksum and stop. */
4707 c
= readchar (remote_timeout
);
4709 c
= readchar (remote_timeout
);
4712 case '*': /* Run length encoding. */
4713 /* Discard the repeat count. */
4714 c
= readchar (remote_timeout
);
4719 /* A regular character. */
4725 /* Come here after finding the start of the frame. Collect the rest
4726 into *BUF, verifying the checksum, length, and handling run-length
4727 compression. NUL terminate the buffer. If there is not enough room,
4728 expand *BUF using xrealloc.
4730 Returns -1 on error, number of characters in buffer (ignoring the
4731 trailing NULL) on success. (could be extended to return one of the
4732 SERIAL status indications). */
4735 read_frame (char **buf_p
,
4748 c
= readchar (remote_timeout
);
4751 case SERIAL_TIMEOUT
:
4753 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4757 fputs_filtered ("Saw new packet start in middle of old one\n",
4759 return -1; /* Start a new packet, count retries. */
4762 unsigned char pktcsum
;
4768 check_0
= readchar (remote_timeout
);
4770 check_1
= readchar (remote_timeout
);
4772 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4775 fputs_filtered ("Timeout in checksum, retrying\n",
4779 else if (check_0
< 0 || check_1
< 0)
4782 fputs_filtered ("Communication error in checksum\n",
4787 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4788 if (csum
== pktcsum
)
4793 fprintf_filtered (gdb_stdlog
,
4794 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4796 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4797 fputs_filtered ("\n", gdb_stdlog
);
4799 /* Number of characters in buffer ignoring trailing
4803 case '*': /* Run length encoding. */
4808 c
= readchar (remote_timeout
);
4810 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4812 /* The character before ``*'' is repeated. */
4814 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4816 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4818 /* Make some more room in the buffer. */
4819 *sizeof_buf
+= repeat
;
4820 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4824 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4830 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4834 if (bc
>= *sizeof_buf
- 1)
4836 /* Make some more room in the buffer. */
4838 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4849 /* Read a packet from the remote machine, with error checking, and
4850 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4851 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4852 rather than timing out; this is used (in synchronous mode) to wait
4853 for a target that is is executing user code to stop. */
4854 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4855 don't have to change all the calls to getpkt to deal with the
4856 return value, because at the moment I don't know what the right
4857 thing to do it for those. */
4865 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4869 /* Read a packet from the remote machine, with error checking, and
4870 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4871 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4872 rather than timing out; this is used (in synchronous mode) to wait
4873 for a target that is is executing user code to stop. If FOREVER ==
4874 0, this function is allowed to time out gracefully and return an
4875 indication of this to the caller. Otherwise return the number
4878 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4885 strcpy (*buf
, "timeout");
4889 timeout
= watchdog
> 0 ? watchdog
: -1;
4893 timeout
= remote_timeout
;
4897 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4899 /* This can loop forever if the remote side sends us characters
4900 continuously, but if it pauses, we'll get a zero from
4901 readchar because of timeout. Then we'll count that as a
4904 /* Note that we will only wait forever prior to the start of a
4905 packet. After that, we expect characters to arrive at a
4906 brisk pace. They should show up within remote_timeout
4911 c
= readchar (timeout
);
4913 if (c
== SERIAL_TIMEOUT
)
4915 if (forever
) /* Watchdog went off? Kill the target. */
4918 target_mourn_inferior ();
4919 error (_("Watchdog has expired. Target detached."));
4922 fputs_filtered ("Timed out.\n", gdb_stdlog
);
4928 /* We've found the start of a packet, now collect the data. */
4930 val
= read_frame (buf
, sizeof_buf
);
4936 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
4937 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
4938 fprintf_unfiltered (gdb_stdlog
, "\n");
4940 serial_write (remote_desc
, "+", 1);
4944 /* Try the whole thing again. */
4946 serial_write (remote_desc
, "-", 1);
4949 /* We have tried hard enough, and just can't receive the packet.
4952 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
4953 serial_write (remote_desc
, "+", 1);
4960 /* For some mysterious reason, wait_for_inferior calls kill instead of
4961 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4965 target_mourn_inferior ();
4969 /* Use catch_errors so the user can quit from gdb even when we aren't on
4970 speaking terms with the remote system. */
4971 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4973 /* Don't wait for it to die. I'm not really sure it matters whether
4974 we do or not. For the existing stubs, kill is a noop. */
4975 target_mourn_inferior ();
4978 /* Async version of remote_kill. */
4980 remote_async_kill (void)
4982 /* Unregister the file descriptor from the event loop. */
4983 if (target_is_async_p ())
4984 serial_async (remote_desc
, NULL
, 0);
4986 /* For some mysterious reason, wait_for_inferior calls kill instead of
4987 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4991 target_mourn_inferior ();
4995 /* Use catch_errors so the user can quit from gdb even when we
4996 aren't on speaking terms with the remote system. */
4997 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4999 /* Don't wait for it to die. I'm not really sure it matters whether
5000 we do or not. For the existing stubs, kill is a noop. */
5001 target_mourn_inferior ();
5007 remote_mourn_1 (&remote_ops
);
5011 remote_async_mourn (void)
5013 remote_mourn_1 (&remote_async_ops
);
5017 extended_remote_mourn (void)
5019 /* We do _not_ want to mourn the target like this; this will
5020 remove the extended remote target from the target stack,
5021 and the next time the user says "run" it'll fail.
5023 FIXME: What is the right thing to do here? */
5025 remote_mourn_1 (&extended_remote_ops
);
5029 /* Worker function for remote_mourn. */
5031 remote_mourn_1 (struct target_ops
*target
)
5033 unpush_target (target
);
5034 generic_mourn_inferior ();
5037 /* In the extended protocol we want to be able to do things like
5038 "run" and have them basically work as expected. So we need
5039 a special create_inferior function.
5041 FIXME: One day add support for changing the exec file
5042 we're debugging, arguments and an environment. */
5045 extended_remote_create_inferior (char *exec_file
, char *args
,
5046 char **env
, int from_tty
)
5048 /* Rip out the breakpoints; we'll reinsert them after restarting
5049 the remote server. */
5050 remove_breakpoints ();
5052 /* Now restart the remote server. */
5053 extended_remote_restart ();
5055 /* NOTE: We don't need to recheck for a target description here; but
5056 if we gain the ability to switch the remote executable we may
5057 need to, if for instance we are running a process which requested
5058 different emulated hardware from the operating system. A
5059 concrete example of this is ARM GNU/Linux, where some binaries
5060 will have a legacy FPA coprocessor emulated and others may have
5061 access to a hardware VFP unit. */
5063 /* Now put the breakpoints back in. This way we're safe if the
5064 restart function works via a unix fork on the remote side. */
5065 insert_breakpoints ();
5067 /* Clean up from the last time we were running. */
5068 clear_proceed_status ();
5071 /* Async version of extended_remote_create_inferior. */
5073 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5074 char **env
, int from_tty
)
5076 /* Rip out the breakpoints; we'll reinsert them after restarting
5077 the remote server. */
5078 remove_breakpoints ();
5080 /* If running asynchronously, register the target file descriptor
5081 with the event loop. */
5082 if (target_can_async_p ())
5083 target_async (inferior_event_handler
, 0);
5085 /* Now restart the remote server. */
5086 extended_remote_restart ();
5088 /* NOTE: We don't need to recheck for a target description here; but
5089 if we gain the ability to switch the remote executable we may
5090 need to, if for instance we are running a process which requested
5091 different emulated hardware from the operating system. A
5092 concrete example of this is ARM GNU/Linux, where some binaries
5093 will have a legacy FPA coprocessor emulated and others may have
5094 access to a hardware VFP unit. */
5096 /* Now put the breakpoints back in. This way we're safe if the
5097 restart function works via a unix fork on the remote side. */
5098 insert_breakpoints ();
5100 /* Clean up from the last time we were running. */
5101 clear_proceed_status ();
5105 /* Insert a breakpoint. On targets that have software breakpoint
5106 support, we ask the remote target to do the work; on targets
5107 which don't, we insert a traditional memory breakpoint. */
5110 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5112 CORE_ADDR addr
= bp_tgt
->placed_address
;
5113 struct remote_state
*rs
= get_remote_state ();
5115 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5116 If it succeeds, then set the support to PACKET_ENABLE. If it
5117 fails, and the user has explicitly requested the Z support then
5118 report an error, otherwise, mark it disabled and go on. */
5120 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5127 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5128 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5129 p
+= hexnumstr (p
, addr
);
5130 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5133 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5135 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5141 case PACKET_UNKNOWN
:
5146 return memory_insert_breakpoint (bp_tgt
);
5150 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5152 CORE_ADDR addr
= bp_tgt
->placed_address
;
5153 struct remote_state
*rs
= get_remote_state ();
5156 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5164 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5165 p
+= hexnumstr (p
, addr
);
5166 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5169 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5171 return (rs
->buf
[0] == 'E');
5174 return memory_remove_breakpoint (bp_tgt
);
5178 watchpoint_to_Z_packet (int type
)
5183 return Z_PACKET_WRITE_WP
;
5186 return Z_PACKET_READ_WP
;
5189 return Z_PACKET_ACCESS_WP
;
5192 internal_error (__FILE__
, __LINE__
,
5193 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5198 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5200 struct remote_state
*rs
= get_remote_state ();
5202 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5204 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5207 sprintf (rs
->buf
, "Z%x,", packet
);
5208 p
= strchr (rs
->buf
, '\0');
5209 addr
= remote_address_masked (addr
);
5210 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5211 sprintf (p
, ",%x", len
);
5214 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5216 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5219 case PACKET_UNKNOWN
:
5224 internal_error (__FILE__
, __LINE__
,
5225 _("remote_insert_watchpoint: reached end of function"));
5230 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5232 struct remote_state
*rs
= get_remote_state ();
5234 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5236 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5239 sprintf (rs
->buf
, "z%x,", packet
);
5240 p
= strchr (rs
->buf
, '\0');
5241 addr
= remote_address_masked (addr
);
5242 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5243 sprintf (p
, ",%x", len
);
5245 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5247 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5250 case PACKET_UNKNOWN
:
5255 internal_error (__FILE__
, __LINE__
,
5256 _("remote_remove_watchpoint: reached end of function"));
5260 int remote_hw_watchpoint_limit
= -1;
5261 int remote_hw_breakpoint_limit
= -1;
5264 remote_check_watch_resources (int type
, int cnt
, int ot
)
5266 if (type
== bp_hardware_breakpoint
)
5268 if (remote_hw_breakpoint_limit
== 0)
5270 else if (remote_hw_breakpoint_limit
< 0)
5272 else if (cnt
<= remote_hw_breakpoint_limit
)
5277 if (remote_hw_watchpoint_limit
== 0)
5279 else if (remote_hw_watchpoint_limit
< 0)
5283 else if (cnt
<= remote_hw_watchpoint_limit
)
5290 remote_stopped_by_watchpoint (void)
5292 return remote_stopped_by_watchpoint_p
;
5295 extern int stepped_after_stopped_by_watchpoint
;
5298 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5301 if (remote_stopped_by_watchpoint ()
5302 || stepped_after_stopped_by_watchpoint
)
5304 *addr_p
= remote_watch_data_address
;
5313 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5316 struct remote_state
*rs
= get_remote_state ();
5319 /* The length field should be set to the size of a breakpoint
5320 instruction, even though we aren't inserting one ourselves. */
5322 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5324 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5331 addr
= remote_address_masked (bp_tgt
->placed_address
);
5332 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5333 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5336 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5338 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5341 case PACKET_UNKNOWN
:
5346 internal_error (__FILE__
, __LINE__
,
5347 _("remote_insert_hw_breakpoint: reached end of function"));
5352 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5355 struct remote_state
*rs
= get_remote_state ();
5358 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5365 addr
= remote_address_masked (bp_tgt
->placed_address
);
5366 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5367 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5370 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5372 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5375 case PACKET_UNKNOWN
:
5380 internal_error (__FILE__
, __LINE__
,
5381 _("remote_remove_hw_breakpoint: reached end of function"));
5384 /* Some targets are only capable of doing downloads, and afterwards
5385 they switch to the remote serial protocol. This function provides
5386 a clean way to get from the download target to the remote target.
5387 It's basically just a wrapper so that we don't have to expose any
5388 of the internal workings of remote.c.
5390 Prior to calling this routine, you should shutdown the current
5391 target code, else you will get the "A program is being debugged
5392 already..." message. Usually a call to pop_target() suffices. */
5395 push_remote_target (char *name
, int from_tty
)
5397 printf_filtered (_("Switching to remote protocol\n"));
5398 remote_open (name
, from_tty
);
5401 /* Table used by the crc32 function to calcuate the checksum. */
5403 static unsigned long crc32_table
[256] =
5406 static unsigned long
5407 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5409 if (!crc32_table
[1])
5411 /* Initialize the CRC table and the decoding table. */
5415 for (i
= 0; i
< 256; i
++)
5417 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5418 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5425 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5431 /* compare-sections command
5433 With no arguments, compares each loadable section in the exec bfd
5434 with the same memory range on the target, and reports mismatches.
5435 Useful for verifying the image on the target against the exec file.
5436 Depends on the target understanding the new "qCRC:" request. */
5438 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5439 target method (target verify memory) and generic version of the
5440 actual command. This will allow other high-level code (especially
5441 generic_load()) to make use of this target functionality. */
5444 compare_sections_command (char *args
, int from_tty
)
5446 struct remote_state
*rs
= get_remote_state ();
5448 unsigned long host_crc
, target_crc
;
5449 extern bfd
*exec_bfd
;
5450 struct cleanup
*old_chain
;
5453 const char *sectname
;
5460 error (_("command cannot be used without an exec file"));
5461 if (!current_target
.to_shortname
||
5462 strcmp (current_target
.to_shortname
, "remote") != 0)
5463 error (_("command can only be used with remote target"));
5465 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5467 if (!(s
->flags
& SEC_LOAD
))
5468 continue; /* skip non-loadable section */
5470 size
= bfd_get_section_size (s
);
5472 continue; /* skip zero-length section */
5474 sectname
= bfd_get_section_name (exec_bfd
, s
);
5475 if (args
&& strcmp (args
, sectname
) != 0)
5476 continue; /* not the section selected by user */
5478 matched
= 1; /* do this section */
5480 /* FIXME: assumes lma can fit into long. */
5481 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5482 (long) lma
, (long) size
);
5485 /* Be clever; compute the host_crc before waiting for target
5487 sectdata
= xmalloc (size
);
5488 old_chain
= make_cleanup (xfree
, sectdata
);
5489 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5490 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5492 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5493 if (rs
->buf
[0] == 'E')
5494 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5495 sectname
, paddr (lma
), paddr (lma
+ size
));
5496 if (rs
->buf
[0] != 'C')
5497 error (_("remote target does not support this operation"));
5499 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5500 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5502 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5503 sectname
, paddr (lma
), paddr (lma
+ size
));
5504 if (host_crc
== target_crc
)
5505 printf_filtered ("matched.\n");
5508 printf_filtered ("MIS-MATCHED!\n");
5512 do_cleanups (old_chain
);
5515 warning (_("One or more sections of the remote executable does not match\n\
5516 the loaded file\n"));
5517 if (args
&& !matched
)
5518 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5521 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
5522 into remote target. The number of bytes written to the remote
5523 target is returned, or -1 for error. */
5526 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
5527 const char *annex
, const gdb_byte
*writebuf
,
5528 ULONGEST offset
, LONGEST len
,
5529 struct packet_config
*packet
)
5534 struct remote_state
*rs
= get_remote_state ();
5535 int max_size
= get_memory_write_packet_size ();
5537 if (packet
->support
== PACKET_DISABLE
)
5540 /* Insert header. */
5541 i
= snprintf (rs
->buf
, max_size
,
5542 "qXfer:%s:write:%s:%s:",
5543 object_name
, annex
? annex
: "",
5544 phex_nz (offset
, sizeof offset
));
5545 max_size
-= (i
+ 1);
5547 /* Escape as much data as fits into rs->buf. */
5548 buf_len
= remote_escape_output
5549 (writebuf
, len
, (rs
->buf
+ i
), &max_size
, max_size
);
5551 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
5552 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
5553 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5556 unpack_varlen_hex (rs
->buf
, &n
);
5560 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5561 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5562 number of bytes read is returned, or 0 for EOF, or -1 for error.
5563 The number of bytes read may be less than LEN without indicating an
5564 EOF. PACKET is checked and updated to indicate whether the remote
5565 target supports this object. */
5568 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5570 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5571 struct packet_config
*packet
)
5573 static char *finished_object
;
5574 static char *finished_annex
;
5575 static ULONGEST finished_offset
;
5577 struct remote_state
*rs
= get_remote_state ();
5578 unsigned int total
= 0;
5579 LONGEST i
, n
, packet_len
;
5581 if (packet
->support
== PACKET_DISABLE
)
5584 /* Check whether we've cached an end-of-object packet that matches
5586 if (finished_object
)
5588 if (strcmp (object_name
, finished_object
) == 0
5589 && strcmp (annex
? annex
: "", finished_annex
) == 0
5590 && offset
== finished_offset
)
5593 /* Otherwise, we're now reading something different. Discard
5595 xfree (finished_object
);
5596 xfree (finished_annex
);
5597 finished_object
= NULL
;
5598 finished_annex
= NULL
;
5601 /* Request only enough to fit in a single packet. The actual data
5602 may not, since we don't know how much of it will need to be escaped;
5603 the target is free to respond with slightly less data. We subtract
5604 five to account for the response type and the protocol frame. */
5605 n
= min (get_remote_packet_size () - 5, len
);
5606 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5607 object_name
, annex
? annex
: "",
5608 phex_nz (offset
, sizeof offset
),
5609 phex_nz (n
, sizeof n
));
5610 i
= putpkt (rs
->buf
);
5615 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5616 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5619 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5620 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5622 /* 'm' means there is (or at least might be) more data after this
5623 batch. That does not make sense unless there's at least one byte
5624 of data in this reply. */
5625 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5626 error (_("Remote qXfer reply contained no data."));
5628 /* Got some data. */
5629 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5631 /* 'l' is an EOF marker, possibly including a final block of data,
5632 or possibly empty. If we have the final block of a non-empty
5633 object, record this fact to bypass a subsequent partial read. */
5634 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
5636 finished_object
= xstrdup (object_name
);
5637 finished_annex
= xstrdup (annex
? annex
: "");
5638 finished_offset
= offset
+ i
;
5645 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5646 const char *annex
, gdb_byte
*readbuf
,
5647 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5649 struct remote_state
*rs
= get_remote_state ();
5654 /* Handle memory using the standard memory routines. */
5655 if (object
== TARGET_OBJECT_MEMORY
)
5660 if (writebuf
!= NULL
)
5661 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5663 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5667 else if (xfered
== 0 && errno
== 0)
5673 /* Handle SPU memory using qxfer packets. */
5674 if (object
== TARGET_OBJECT_SPU
)
5677 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
5678 &remote_protocol_packets
5679 [PACKET_qXfer_spu_read
]);
5681 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
5682 &remote_protocol_packets
5683 [PACKET_qXfer_spu_write
]);
5686 /* Only handle flash writes. */
5687 if (writebuf
!= NULL
)
5693 case TARGET_OBJECT_FLASH
:
5694 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5698 else if (xfered
== 0 && errno
== 0)
5708 /* Map pre-existing objects onto letters. DO NOT do this for new
5709 objects!!! Instead specify new query packets. */
5712 case TARGET_OBJECT_AVR
:
5716 case TARGET_OBJECT_AUXV
:
5717 gdb_assert (annex
== NULL
);
5718 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5719 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5721 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5722 return remote_read_qxfer
5723 (ops
, "features", annex
, readbuf
, offset
, len
,
5724 &remote_protocol_packets
[PACKET_qXfer_features
]);
5726 case TARGET_OBJECT_MEMORY_MAP
:
5727 gdb_assert (annex
== NULL
);
5728 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5729 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5735 /* Note: a zero OFFSET and LEN can be used to query the minimum
5737 if (offset
== 0 && len
== 0)
5738 return (get_remote_packet_size ());
5739 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5740 large enough let the caller deal with it. */
5741 if (len
< get_remote_packet_size ())
5743 len
= get_remote_packet_size ();
5745 /* Except for querying the minimum buffer size, target must be open. */
5747 error (_("remote query is only available after target open"));
5749 gdb_assert (annex
!= NULL
);
5750 gdb_assert (readbuf
!= NULL
);
5756 /* We used one buffer char for the remote protocol q command and
5757 another for the query type. As the remote protocol encapsulation
5758 uses 4 chars plus one extra in case we are debugging
5759 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5762 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5764 /* Bad caller may have sent forbidden characters. */
5765 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5770 gdb_assert (annex
[i
] == '\0');
5772 i
= putpkt (rs
->buf
);
5776 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5777 strcpy ((char *) readbuf
, rs
->buf
);
5779 return strlen ((char *) readbuf
);
5783 remote_rcmd (char *command
,
5784 struct ui_file
*outbuf
)
5786 struct remote_state
*rs
= get_remote_state ();
5790 error (_("remote rcmd is only available after target open"));
5792 /* Send a NULL command across as an empty command. */
5793 if (command
== NULL
)
5796 /* The query prefix. */
5797 strcpy (rs
->buf
, "qRcmd,");
5798 p
= strchr (rs
->buf
, '\0');
5800 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5801 error (_("\"monitor\" command ``%s'' is too long."), command
);
5803 /* Encode the actual command. */
5804 bin2hex ((gdb_byte
*) command
, p
, 0);
5806 if (putpkt (rs
->buf
) < 0)
5807 error (_("Communication problem with target."));
5809 /* get/display the response */
5814 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5816 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5819 error (_("Target does not support this command."));
5820 if (buf
[0] == 'O' && buf
[1] != 'K')
5822 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5825 if (strcmp (buf
, "OK") == 0)
5827 if (strlen (buf
) == 3 && buf
[0] == 'E'
5828 && isdigit (buf
[1]) && isdigit (buf
[2]))
5830 error (_("Protocol error with Rcmd"));
5832 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5834 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5835 fputc_unfiltered (c
, outbuf
);
5841 static VEC(mem_region_s
) *
5842 remote_memory_map (struct target_ops
*ops
)
5844 VEC(mem_region_s
) *result
= NULL
;
5845 char *text
= target_read_stralloc (¤t_target
,
5846 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5850 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5851 result
= parse_memory_map (text
);
5852 do_cleanups (back_to
);
5859 packet_command (char *args
, int from_tty
)
5861 struct remote_state
*rs
= get_remote_state ();
5864 error (_("command can only be used with remote target"));
5867 error (_("remote-packet command requires packet text as argument"));
5869 puts_filtered ("sending: ");
5870 print_packet (args
);
5871 puts_filtered ("\n");
5874 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5875 puts_filtered ("received: ");
5876 print_packet (rs
->buf
);
5877 puts_filtered ("\n");
5881 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5883 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5885 static void threadset_test_cmd (char *cmd
, int tty
);
5887 static void threadalive_test (char *cmd
, int tty
);
5889 static void threadlist_test_cmd (char *cmd
, int tty
);
5891 int get_and_display_threadinfo (threadref
*ref
);
5893 static void threadinfo_test_cmd (char *cmd
, int tty
);
5895 static int thread_display_step (threadref
*ref
, void *context
);
5897 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5899 static void init_remote_threadtests (void);
5901 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5904 threadset_test_cmd (char *cmd
, int tty
)
5906 int sample_thread
= SAMPLE_THREAD
;
5908 printf_filtered (_("Remote threadset test\n"));
5909 set_thread (sample_thread
, 1);
5914 threadalive_test (char *cmd
, int tty
)
5916 int sample_thread
= SAMPLE_THREAD
;
5918 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5919 printf_filtered ("PASS: Thread alive test\n");
5921 printf_filtered ("FAIL: Thread alive test\n");
5924 void output_threadid (char *title
, threadref
*ref
);
5927 output_threadid (char *title
, threadref
*ref
)
5931 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
5933 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
5937 threadlist_test_cmd (char *cmd
, int tty
)
5940 threadref nextthread
;
5941 int done
, result_count
;
5942 threadref threadlist
[3];
5944 printf_filtered ("Remote Threadlist test\n");
5945 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
5946 &result_count
, &threadlist
[0]))
5947 printf_filtered ("FAIL: threadlist test\n");
5950 threadref
*scan
= threadlist
;
5951 threadref
*limit
= scan
+ result_count
;
5953 while (scan
< limit
)
5954 output_threadid (" thread ", scan
++);
5959 display_thread_info (struct gdb_ext_thread_info
*info
)
5961 output_threadid ("Threadid: ", &info
->threadid
);
5962 printf_filtered ("Name: %s\n ", info
->shortname
);
5963 printf_filtered ("State: %s\n", info
->display
);
5964 printf_filtered ("other: %s\n\n", info
->more_display
);
5968 get_and_display_threadinfo (threadref
*ref
)
5972 struct gdb_ext_thread_info threadinfo
;
5974 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
5975 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
5976 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
5977 display_thread_info (&threadinfo
);
5982 threadinfo_test_cmd (char *cmd
, int tty
)
5984 int athread
= SAMPLE_THREAD
;
5988 int_to_threadref (&thread
, athread
);
5989 printf_filtered ("Remote Threadinfo test\n");
5990 if (!get_and_display_threadinfo (&thread
))
5991 printf_filtered ("FAIL cannot get thread info\n");
5995 thread_display_step (threadref
*ref
, void *context
)
5997 /* output_threadid(" threadstep ",ref); *//* simple test */
5998 return get_and_display_threadinfo (ref
);
6002 threadlist_update_test_cmd (char *cmd
, int tty
)
6004 printf_filtered ("Remote Threadlist update test\n");
6005 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
6009 init_remote_threadtests (void)
6011 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
6012 Fetch and print the remote list of thread identifiers, one pkt only"));
6013 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
6014 _("Fetch and display info about one thread"));
6015 add_com ("tset", class_obscure
, threadset_test_cmd
,
6016 _("Test setting to a different thread"));
6017 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
6018 _("Iterate through updating all remote thread info"));
6019 add_com ("talive", class_obscure
, threadalive_test
,
6020 _(" Remote thread alive test "));
6025 /* Convert a thread ID to a string. Returns the string in a static
6029 remote_pid_to_str (ptid_t ptid
)
6031 static char buf
[32];
6033 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
6037 /* Get the address of the thread local variable in OBJFILE which is
6038 stored at OFFSET within the thread local storage for thread PTID. */
6041 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
6043 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
6045 struct remote_state
*rs
= get_remote_state ();
6047 enum packet_result result
;
6049 strcpy (p
, "qGetTLSAddr:");
6051 p
+= hexnumstr (p
, PIDGET (ptid
));
6053 p
+= hexnumstr (p
, offset
);
6055 p
+= hexnumstr (p
, lm
);
6059 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6060 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6061 if (result
== PACKET_OK
)
6065 unpack_varlen_hex (rs
->buf
, &result
);
6068 else if (result
== PACKET_UNKNOWN
)
6069 throw_error (TLS_GENERIC_ERROR
,
6070 _("Remote target doesn't support qGetTLSAddr packet"));
6072 throw_error (TLS_GENERIC_ERROR
,
6073 _("Remote target failed to process qGetTLSAddr request"));
6076 throw_error (TLS_GENERIC_ERROR
,
6077 _("TLS not supported or disabled on this target"));
6082 /* Support for inferring a target description based on the current
6083 architecture and the size of a 'g' packet. While the 'g' packet
6084 can have any size (since optional registers can be left off the
6085 end), some sizes are easily recognizable given knowledge of the
6086 approximate architecture. */
6088 struct remote_g_packet_guess
6091 const struct target_desc
*tdesc
;
6093 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6094 DEF_VEC_O(remote_g_packet_guess_s
);
6096 struct remote_g_packet_data
6098 VEC(remote_g_packet_guess_s
) *guesses
;
6101 static struct gdbarch_data
*remote_g_packet_data_handle
;
6104 remote_g_packet_data_init (struct obstack
*obstack
)
6106 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6110 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6111 const struct target_desc
*tdesc
)
6113 struct remote_g_packet_data
*data
6114 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6115 struct remote_g_packet_guess new_guess
, *guess
;
6118 gdb_assert (tdesc
!= NULL
);
6121 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6123 if (guess
->bytes
== bytes
)
6124 internal_error (__FILE__
, __LINE__
,
6125 "Duplicate g packet description added for size %d",
6128 new_guess
.bytes
= bytes
;
6129 new_guess
.tdesc
= tdesc
;
6130 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6133 static const struct target_desc
*
6134 remote_read_description (struct target_ops
*target
)
6136 struct remote_g_packet_data
*data
6137 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6139 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6141 struct remote_g_packet_guess
*guess
;
6143 int bytes
= send_g_packet ();
6146 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6148 if (guess
->bytes
== bytes
)
6149 return guess
->tdesc
;
6151 /* We discard the g packet. A minor optimization would be to
6152 hold on to it, and fill the register cache once we have selected
6153 an architecture, but it's too tricky to do safely. */
6160 init_remote_ops (void)
6162 remote_ops
.to_shortname
= "remote";
6163 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6165 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6166 Specify the serial device it is connected to\n\
6167 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6168 remote_ops
.to_open
= remote_open
;
6169 remote_ops
.to_close
= remote_close
;
6170 remote_ops
.to_detach
= remote_detach
;
6171 remote_ops
.to_disconnect
= remote_disconnect
;
6172 remote_ops
.to_resume
= remote_resume
;
6173 remote_ops
.to_wait
= remote_wait
;
6174 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6175 remote_ops
.to_store_registers
= remote_store_registers
;
6176 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6177 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6178 remote_ops
.to_files_info
= remote_files_info
;
6179 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6180 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6181 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6182 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6183 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6184 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6185 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6186 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6187 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6188 remote_ops
.to_kill
= remote_kill
;
6189 remote_ops
.to_load
= generic_load
;
6190 remote_ops
.to_mourn_inferior
= remote_mourn
;
6191 remote_ops
.to_thread_alive
= remote_thread_alive
;
6192 remote_ops
.to_find_new_threads
= remote_threads_info
;
6193 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6194 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6195 remote_ops
.to_stop
= remote_stop
;
6196 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6197 remote_ops
.to_rcmd
= remote_rcmd
;
6198 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6199 remote_ops
.to_stratum
= process_stratum
;
6200 remote_ops
.to_has_all_memory
= 1;
6201 remote_ops
.to_has_memory
= 1;
6202 remote_ops
.to_has_stack
= 1;
6203 remote_ops
.to_has_registers
= 1;
6204 remote_ops
.to_has_execution
= 1;
6205 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6206 remote_ops
.to_magic
= OPS_MAGIC
;
6207 remote_ops
.to_memory_map
= remote_memory_map
;
6208 remote_ops
.to_flash_erase
= remote_flash_erase
;
6209 remote_ops
.to_flash_done
= remote_flash_done
;
6210 remote_ops
.to_read_description
= remote_read_description
;
6213 /* Set up the extended remote vector by making a copy of the standard
6214 remote vector and adding to it. */
6217 init_extended_remote_ops (void)
6219 extended_remote_ops
= remote_ops
;
6221 extended_remote_ops
.to_shortname
= "extended-remote";
6222 extended_remote_ops
.to_longname
=
6223 "Extended remote serial target in gdb-specific protocol";
6224 extended_remote_ops
.to_doc
=
6225 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6226 Specify the serial device it is connected to (e.g. /dev/ttya).",
6227 extended_remote_ops
.to_open
= extended_remote_open
;
6228 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6229 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6233 remote_can_async_p (void)
6235 /* We're async whenever the serial device is. */
6236 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6240 remote_is_async_p (void)
6242 /* We're async whenever the serial device is. */
6243 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6246 /* Pass the SERIAL event on and up to the client. One day this code
6247 will be able to delay notifying the client of an event until the
6248 point where an entire packet has been received. */
6250 static void (*async_client_callback
) (enum inferior_event_type event_type
,
6252 static void *async_client_context
;
6253 static serial_event_ftype remote_async_serial_handler
;
6256 remote_async_serial_handler (struct serial
*scb
, void *context
)
6258 /* Don't propogate error information up to the client. Instead let
6259 the client find out about the error by querying the target. */
6260 async_client_callback (INF_REG_EVENT
, async_client_context
);
6264 remote_async (void (*callback
) (enum inferior_event_type event_type
,
6265 void *context
), void *context
)
6267 if (current_target
.to_async_mask_value
== 0)
6268 internal_error (__FILE__
, __LINE__
,
6269 _("Calling remote_async when async is masked"));
6271 if (callback
!= NULL
)
6273 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
6274 async_client_callback
= callback
;
6275 async_client_context
= context
;
6278 serial_async (remote_desc
, NULL
, NULL
);
6281 /* Target async and target extended-async.
6283 This are temporary targets, until it is all tested. Eventually
6284 async support will be incorporated int the usual 'remote'
6288 init_remote_async_ops (void)
6290 remote_async_ops
.to_shortname
= "async";
6291 remote_async_ops
.to_longname
=
6292 "Remote serial target in async version of the gdb-specific protocol";
6293 remote_async_ops
.to_doc
=
6294 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6295 Specify the serial device it is connected to (e.g. /dev/ttya).";
6296 remote_async_ops
.to_open
= remote_async_open
;
6297 remote_async_ops
.to_close
= remote_close
;
6298 remote_async_ops
.to_detach
= remote_detach
;
6299 remote_async_ops
.to_disconnect
= remote_disconnect
;
6300 remote_async_ops
.to_resume
= remote_async_resume
;
6301 remote_async_ops
.to_wait
= remote_async_wait
;
6302 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
6303 remote_async_ops
.to_store_registers
= remote_store_registers
;
6304 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6305 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6306 remote_async_ops
.to_files_info
= remote_files_info
;
6307 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6308 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6309 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6310 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6311 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6312 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6313 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6314 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6315 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6316 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
6317 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
6318 remote_async_ops
.to_kill
= remote_async_kill
;
6319 remote_async_ops
.to_load
= generic_load
;
6320 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
6321 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
6322 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
6323 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
6324 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6325 remote_async_ops
.to_stop
= remote_stop
;
6326 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
6327 remote_async_ops
.to_rcmd
= remote_rcmd
;
6328 remote_async_ops
.to_stratum
= process_stratum
;
6329 remote_async_ops
.to_has_all_memory
= 1;
6330 remote_async_ops
.to_has_memory
= 1;
6331 remote_async_ops
.to_has_stack
= 1;
6332 remote_async_ops
.to_has_registers
= 1;
6333 remote_async_ops
.to_has_execution
= 1;
6334 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6335 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
6336 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
6337 remote_async_ops
.to_async
= remote_async
;
6338 remote_async_ops
.to_async_mask_value
= 1;
6339 remote_async_ops
.to_magic
= OPS_MAGIC
;
6340 remote_async_ops
.to_memory_map
= remote_memory_map
;
6341 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
6342 remote_async_ops
.to_flash_done
= remote_flash_done
;
6343 remote_ops
.to_read_description
= remote_read_description
;
6346 /* Set up the async extended remote vector by making a copy of the standard
6347 remote vector and adding to it. */
6350 init_extended_async_remote_ops (void)
6352 extended_async_remote_ops
= remote_async_ops
;
6354 extended_async_remote_ops
.to_shortname
= "extended-async";
6355 extended_async_remote_ops
.to_longname
=
6356 "Extended remote serial target in async gdb-specific protocol";
6357 extended_async_remote_ops
.to_doc
=
6358 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6359 Specify the serial device it is connected to (e.g. /dev/ttya).",
6360 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
6361 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
6362 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6366 set_remote_cmd (char *args
, int from_tty
)
6368 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
6372 show_remote_cmd (char *args
, int from_tty
)
6374 /* We can't just use cmd_show_list here, because we want to skip
6375 the redundant "show remote Z-packet" and the legacy aliases. */
6376 struct cleanup
*showlist_chain
;
6377 struct cmd_list_element
*list
= remote_show_cmdlist
;
6379 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
6380 for (; list
!= NULL
; list
= list
->next
)
6381 if (strcmp (list
->name
, "Z-packet") == 0)
6383 else if (list
->type
== not_set_cmd
)
6384 /* Alias commands are exactly like the original, except they
6385 don't have the normal type. */
6389 struct cleanup
*option_chain
6390 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
6391 ui_out_field_string (uiout
, "name", list
->name
);
6392 ui_out_text (uiout
, ": ");
6393 if (list
->type
== show_cmd
)
6394 do_setshow_command ((char *) NULL
, from_tty
, list
);
6396 cmd_func (list
, NULL
, from_tty
);
6397 /* Close the tuple. */
6398 do_cleanups (option_chain
);
6401 /* Close the tuple. */
6402 do_cleanups (showlist_chain
);
6406 build_remote_gdbarch_data (void)
6408 remote_address_size
= TARGET_ADDR_BIT
;
6411 /* Function to be called whenever a new objfile (shlib) is detected. */
6413 remote_new_objfile (struct objfile
*objfile
)
6415 if (remote_desc
!= 0) /* Have a remote connection. */
6416 remote_check_symbols (objfile
);
6420 _initialize_remote (void)
6422 struct remote_state
*rs
;
6424 /* architecture specific data */
6425 remote_gdbarch_data_handle
=
6426 gdbarch_data_register_post_init (init_remote_state
);
6427 remote_g_packet_data_handle
=
6428 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
6430 /* Old tacky stuff. NOTE: This comes after the remote protocol so
6431 that the remote protocol has been initialized. */
6432 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size
);
6433 deprecated_register_gdbarch_swap (NULL
, 0, build_remote_gdbarch_data
);
6435 /* Initialize the per-target state. At the moment there is only one
6436 of these, not one per target. Only one target is active at a
6437 time. The default buffer size is unimportant; it will be expanded
6438 whenever a larger buffer is needed. */
6439 rs
= get_remote_state_raw ();
6441 rs
->buf
= xmalloc (rs
->buf_size
);
6444 add_target (&remote_ops
);
6446 init_extended_remote_ops ();
6447 add_target (&extended_remote_ops
);
6449 init_remote_async_ops ();
6450 add_target (&remote_async_ops
);
6452 init_extended_async_remote_ops ();
6453 add_target (&extended_async_remote_ops
);
6455 /* Hook into new objfile notification. */
6456 observer_attach_new_objfile (remote_new_objfile
);
6459 init_remote_threadtests ();
6462 /* set/show remote ... */
6464 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
6465 Remote protocol specific variables\n\
6466 Configure various remote-protocol specific variables such as\n\
6467 the packets being used"),
6468 &remote_set_cmdlist
, "set remote ",
6469 0 /* allow-unknown */, &setlist
);
6470 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
6471 Remote protocol specific variables\n\
6472 Configure various remote-protocol specific variables such as\n\
6473 the packets being used"),
6474 &remote_show_cmdlist
, "show remote ",
6475 0 /* allow-unknown */, &showlist
);
6477 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
6478 Compare section data on target to the exec file.\n\
6479 Argument is a single section name (default: all loaded sections)."),
6482 add_cmd ("packet", class_maintenance
, packet_command
, _("\
6483 Send an arbitrary packet to a remote target.\n\
6484 maintenance packet TEXT\n\
6485 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6486 this command sends the string TEXT to the inferior, and displays the\n\
6487 response packet. GDB supplies the initial `$' character, and the\n\
6488 terminating `#' character and checksum."),
6491 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
6492 Set whether to send break if interrupted."), _("\
6493 Show whether to send break if interrupted."), _("\
6494 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6495 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6496 &setlist
, &showlist
);
6498 /* Install commands for configuring memory read/write packets. */
6500 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
6501 Set the maximum number of bytes per memory write packet (deprecated)."),
6503 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
6504 Show the maximum number of bytes per memory write packet (deprecated)."),
6506 add_cmd ("memory-write-packet-size", no_class
,
6507 set_memory_write_packet_size
, _("\
6508 Set the maximum number of bytes per memory-write packet.\n\
6509 Specify the number of bytes in a packet or 0 (zero) for the\n\
6510 default packet size. The actual limit is further reduced\n\
6511 dependent on the target. Specify ``fixed'' to disable the\n\
6512 further restriction and ``limit'' to enable that restriction."),
6513 &remote_set_cmdlist
);
6514 add_cmd ("memory-read-packet-size", no_class
,
6515 set_memory_read_packet_size
, _("\
6516 Set the maximum number of bytes per memory-read packet.\n\
6517 Specify the number of bytes in a packet or 0 (zero) for the\n\
6518 default packet size. The actual limit is further reduced\n\
6519 dependent on the target. Specify ``fixed'' to disable the\n\
6520 further restriction and ``limit'' to enable that restriction."),
6521 &remote_set_cmdlist
);
6522 add_cmd ("memory-write-packet-size", no_class
,
6523 show_memory_write_packet_size
,
6524 _("Show the maximum number of bytes per memory-write packet."),
6525 &remote_show_cmdlist
);
6526 add_cmd ("memory-read-packet-size", no_class
,
6527 show_memory_read_packet_size
,
6528 _("Show the maximum number of bytes per memory-read packet."),
6529 &remote_show_cmdlist
);
6531 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6532 &remote_hw_watchpoint_limit
, _("\
6533 Set the maximum number of target hardware watchpoints."), _("\
6534 Show the maximum number of target hardware watchpoints."), _("\
6535 Specify a negative limit for unlimited."),
6536 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6537 &remote_set_cmdlist
, &remote_show_cmdlist
);
6538 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6539 &remote_hw_breakpoint_limit
, _("\
6540 Set the maximum number of target hardware breakpoints."), _("\
6541 Show the maximum number of target hardware breakpoints."), _("\
6542 Specify a negative limit for unlimited."),
6543 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6544 &remote_set_cmdlist
, &remote_show_cmdlist
);
6546 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6547 &remote_address_size
, _("\
6548 Set the maximum size of the address (in bits) in a memory packet."), _("\
6549 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6551 NULL
, /* FIXME: i18n: */
6552 &setlist
, &showlist
);
6554 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6555 "X", "binary-download", 1);
6557 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6558 "vCont", "verbose-resume", 0);
6560 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
6561 "QPassSignals", "pass-signals", 0);
6563 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6564 "qSymbol", "symbol-lookup", 0);
6566 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6567 "P", "set-register", 1);
6569 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6570 "p", "fetch-register", 1);
6572 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6573 "Z0", "software-breakpoint", 0);
6575 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6576 "Z1", "hardware-breakpoint", 0);
6578 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6579 "Z2", "write-watchpoint", 0);
6581 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6582 "Z3", "read-watchpoint", 0);
6584 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6585 "Z4", "access-watchpoint", 0);
6587 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6588 "qXfer:auxv:read", "read-aux-vector", 0);
6590 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
6591 "qXfer:features:read", "target-features", 0);
6593 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
6594 "qXfer:memory-map:read", "memory-map", 0);
6596 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
6597 "qXfer:spu:read", "read-spu-object", 0);
6599 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
6600 "qXfer:spu:write", "write-spu-object", 0);
6602 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6603 "qGetTLSAddr", "get-thread-local-storage-address",
6606 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6607 "qSupported", "supported-packets", 0);
6609 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6610 Z sub-packet has its own set and show commands, but users may
6611 have sets to this variable in their .gdbinit files (or in their
6613 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6614 &remote_Z_packet_detect
, _("\
6615 Set use of remote protocol `Z' packets"), _("\
6616 Show use of remote protocol `Z' packets "), _("\
6617 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6619 set_remote_protocol_Z_packet_cmd
,
6620 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6621 &remote_set_cmdlist
, &remote_show_cmdlist
);
6623 /* Eventually initialize fileio. See fileio.c */
6624 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);