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
,
917 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
920 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
921 struct cmd_list_element
*c
)
923 struct packet_config
*packet
;
925 for (packet
= remote_protocol_packets
;
926 packet
< &remote_protocol_packets
[PACKET_MAX
];
929 if (&packet
->detect
== c
->var
)
931 update_packet_config (packet
);
935 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
940 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
941 struct cmd_list_element
*c
,
944 struct packet_config
*packet
;
946 for (packet
= remote_protocol_packets
;
947 packet
< &remote_protocol_packets
[PACKET_MAX
];
950 if (&packet
->detect
== c
->var
)
952 show_packet_config_cmd (packet
);
956 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
960 /* Should we try one of the 'Z' requests? */
964 Z_PACKET_SOFTWARE_BP
,
965 Z_PACKET_HARDWARE_BP
,
972 /* For compatibility with older distributions. Provide a ``set remote
973 Z-packet ...'' command that updates all the Z packet types. */
975 static enum auto_boolean remote_Z_packet_detect
;
978 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
979 struct cmd_list_element
*c
)
982 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
984 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
985 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
990 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
991 struct cmd_list_element
*c
,
995 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
997 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1001 /* Should we try the 'ThreadInfo' query packet?
1003 This variable (NOT available to the user: auto-detect only!)
1004 determines whether GDB will use the new, simpler "ThreadInfo"
1005 query or the older, more complex syntax for thread queries.
1006 This is an auto-detect variable (set to true at each connect,
1007 and set to false when the target fails to recognize it). */
1009 static int use_threadinfo_query
;
1010 static int use_threadextra_query
;
1012 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1013 static struct async_signal_handler
*sigint_remote_twice_token
;
1014 static struct async_signal_handler
*sigint_remote_token
;
1016 /* These are pointers to hook functions that may be set in order to
1017 modify resume/wait behavior for a particular architecture. */
1019 void (*deprecated_target_resume_hook
) (void);
1020 void (*deprecated_target_wait_loop_hook
) (void);
1024 /* These are the threads which we last sent to the remote system.
1025 -1 for all or -2 for not sent yet. */
1026 static int general_thread
;
1027 static int continue_thread
;
1029 /* Call this function as a result of
1030 1) A halt indication (T packet) containing a thread id
1031 2) A direct query of currthread
1032 3) Successful execution of set thread
1036 record_currthread (int currthread
)
1038 general_thread
= currthread
;
1040 /* If this is a new thread, add it to GDB's thread list.
1041 If we leave it up to WFI to do this, bad things will happen. */
1042 if (!in_thread_list (pid_to_ptid (currthread
)))
1044 add_thread (pid_to_ptid (currthread
));
1045 ui_out_text (uiout
, "[New ");
1046 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
1047 ui_out_text (uiout
, "]\n");
1051 static char *last_pass_packet
;
1053 /* If 'QPassSignals' is supported, tell the remote stub what signals
1054 it can simply pass through to the inferior without reporting. */
1057 remote_pass_signals (void)
1059 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1061 char *pass_packet
, *p
;
1062 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1065 gdb_assert (numsigs
< 256);
1066 for (i
= 0; i
< numsigs
; i
++)
1068 if (signal_stop_state (i
) == 0
1069 && signal_print_state (i
) == 0
1070 && signal_pass_state (i
) == 1)
1073 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1074 strcpy (pass_packet
, "QPassSignals:");
1075 p
= pass_packet
+ strlen (pass_packet
);
1076 for (i
= 0; i
< numsigs
; i
++)
1078 if (signal_stop_state (i
) == 0
1079 && signal_print_state (i
) == 0
1080 && signal_pass_state (i
) == 1)
1083 *p
++ = tohex (i
>> 4);
1084 *p
++ = tohex (i
& 15);
1093 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1095 struct remote_state
*rs
= get_remote_state ();
1096 char *buf
= rs
->buf
;
1098 putpkt (pass_packet
);
1099 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1100 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1101 if (last_pass_packet
)
1102 xfree (last_pass_packet
);
1103 last_pass_packet
= pass_packet
;
1106 xfree (pass_packet
);
1110 #define MAGIC_NULL_PID 42000
1113 set_thread (int th
, int gen
)
1115 struct remote_state
*rs
= get_remote_state ();
1116 char *buf
= rs
->buf
;
1117 int state
= gen
? general_thread
: continue_thread
;
1123 buf
[1] = gen
? 'g' : 'c';
1124 if (th
== MAGIC_NULL_PID
)
1130 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
1132 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
1134 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1136 general_thread
= th
;
1138 continue_thread
= th
;
1141 /* Return nonzero if the thread TH is still alive on the remote system. */
1144 remote_thread_alive (ptid_t ptid
)
1146 struct remote_state
*rs
= get_remote_state ();
1147 int tid
= PIDGET (ptid
);
1150 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1152 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1154 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1155 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1158 /* About these extended threadlist and threadinfo packets. They are
1159 variable length packets but, the fields within them are often fixed
1160 length. They are redundent enough to send over UDP as is the
1161 remote protocol in general. There is a matching unit test module
1164 #define OPAQUETHREADBYTES 8
1166 /* a 64 bit opaque identifier */
1167 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1169 /* WARNING: This threadref data structure comes from the remote O.S.,
1170 libstub protocol encoding, and remote.c. it is not particularly
1173 /* Right now, the internal structure is int. We want it to be bigger.
1177 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1179 /* gdb_ext_thread_info is an internal GDB data structure which is
1180 equivalent to the reply of the remote threadinfo packet. */
1182 struct gdb_ext_thread_info
1184 threadref threadid
; /* External form of thread reference. */
1185 int active
; /* Has state interesting to GDB?
1187 char display
[256]; /* Brief state display, name,
1188 blocked/suspended. */
1189 char shortname
[32]; /* To be used to name threads. */
1190 char more_display
[256]; /* Long info, statistics, queue depth,
1194 /* The volume of remote transfers can be limited by submitting
1195 a mask containing bits specifying the desired information.
1196 Use a union of these values as the 'selection' parameter to
1197 get_thread_info. FIXME: Make these TAG names more thread specific.
1200 #define TAG_THREADID 1
1201 #define TAG_EXISTS 2
1202 #define TAG_DISPLAY 4
1203 #define TAG_THREADNAME 8
1204 #define TAG_MOREDISPLAY 16
1206 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1208 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1210 static char *unpack_nibble (char *buf
, int *val
);
1212 static char *pack_nibble (char *buf
, int nibble
);
1214 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1216 static char *unpack_byte (char *buf
, int *value
);
1218 static char *pack_int (char *buf
, int value
);
1220 static char *unpack_int (char *buf
, int *value
);
1222 static char *unpack_string (char *src
, char *dest
, int length
);
1224 static char *pack_threadid (char *pkt
, threadref
*id
);
1226 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1228 void int_to_threadref (threadref
*id
, int value
);
1230 static int threadref_to_int (threadref
*ref
);
1232 static void copy_threadref (threadref
*dest
, threadref
*src
);
1234 static int threadmatch (threadref
*dest
, threadref
*src
);
1236 static char *pack_threadinfo_request (char *pkt
, int mode
,
1239 static int remote_unpack_thread_info_response (char *pkt
,
1240 threadref
*expectedref
,
1241 struct gdb_ext_thread_info
1245 static int remote_get_threadinfo (threadref
*threadid
,
1246 int fieldset
, /*TAG mask */
1247 struct gdb_ext_thread_info
*info
);
1249 static char *pack_threadlist_request (char *pkt
, int startflag
,
1251 threadref
*nextthread
);
1253 static int parse_threadlist_response (char *pkt
,
1255 threadref
*original_echo
,
1256 threadref
*resultlist
,
1259 static int remote_get_threadlist (int startflag
,
1260 threadref
*nextthread
,
1264 threadref
*threadlist
);
1266 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1268 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1269 void *context
, int looplimit
);
1271 static int remote_newthread_step (threadref
*ref
, void *context
);
1273 /* Encode 64 bits in 16 chars of hex. */
1275 static const char hexchars
[] = "0123456789abcdef";
1278 ishex (int ch
, int *val
)
1280 if ((ch
>= 'a') && (ch
<= 'f'))
1282 *val
= ch
- 'a' + 10;
1285 if ((ch
>= 'A') && (ch
<= 'F'))
1287 *val
= ch
- 'A' + 10;
1290 if ((ch
>= '0') && (ch
<= '9'))
1301 if (ch
>= 'a' && ch
<= 'f')
1302 return ch
- 'a' + 10;
1303 if (ch
>= '0' && ch
<= '9')
1305 if (ch
>= 'A' && ch
<= 'F')
1306 return ch
- 'A' + 10;
1311 stub_unpack_int (char *buff
, int fieldlength
)
1318 nibble
= stubhex (*buff
++);
1322 retval
= retval
<< 4;
1328 unpack_varlen_hex (char *buff
, /* packet to parse */
1332 ULONGEST retval
= 0;
1334 while (ishex (*buff
, &nibble
))
1337 retval
= retval
<< 4;
1338 retval
|= nibble
& 0x0f;
1345 unpack_nibble (char *buf
, int *val
)
1347 ishex (*buf
++, val
);
1352 pack_nibble (char *buf
, int nibble
)
1354 *buf
++ = hexchars
[(nibble
& 0x0f)];
1359 pack_hex_byte (char *pkt
, int byte
)
1361 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1362 *pkt
++ = hexchars
[(byte
& 0xf)];
1367 unpack_byte (char *buf
, int *value
)
1369 *value
= stub_unpack_int (buf
, 2);
1374 pack_int (char *buf
, int value
)
1376 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1377 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1378 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1379 buf
= pack_hex_byte (buf
, (value
& 0xff));
1384 unpack_int (char *buf
, int *value
)
1386 *value
= stub_unpack_int (buf
, 8);
1390 #if 0 /* Currently unused, uncomment when needed. */
1391 static char *pack_string (char *pkt
, char *string
);
1394 pack_string (char *pkt
, char *string
)
1399 len
= strlen (string
);
1401 len
= 200; /* Bigger than most GDB packets, junk??? */
1402 pkt
= pack_hex_byte (pkt
, len
);
1406 if ((ch
== '\0') || (ch
== '#'))
1407 ch
= '*'; /* Protect encapsulation. */
1412 #endif /* 0 (unused) */
1415 unpack_string (char *src
, char *dest
, int length
)
1424 pack_threadid (char *pkt
, threadref
*id
)
1427 unsigned char *altid
;
1429 altid
= (unsigned char *) id
;
1430 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1432 pkt
= pack_hex_byte (pkt
, *altid
++);
1438 unpack_threadid (char *inbuf
, threadref
*id
)
1441 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1444 altref
= (char *) id
;
1446 while (inbuf
< limit
)
1448 x
= stubhex (*inbuf
++);
1449 y
= stubhex (*inbuf
++);
1450 *altref
++ = (x
<< 4) | y
;
1455 /* Externally, threadrefs are 64 bits but internally, they are still
1456 ints. This is due to a mismatch of specifications. We would like
1457 to use 64bit thread references internally. This is an adapter
1461 int_to_threadref (threadref
*id
, int value
)
1463 unsigned char *scan
;
1465 scan
= (unsigned char *) id
;
1471 *scan
++ = (value
>> 24) & 0xff;
1472 *scan
++ = (value
>> 16) & 0xff;
1473 *scan
++ = (value
>> 8) & 0xff;
1474 *scan
++ = (value
& 0xff);
1478 threadref_to_int (threadref
*ref
)
1481 unsigned char *scan
;
1487 value
= (value
<< 8) | ((*scan
++) & 0xff);
1492 copy_threadref (threadref
*dest
, threadref
*src
)
1495 unsigned char *csrc
, *cdest
;
1497 csrc
= (unsigned char *) src
;
1498 cdest
= (unsigned char *) dest
;
1505 threadmatch (threadref
*dest
, threadref
*src
)
1507 /* Things are broken right now, so just assume we got a match. */
1509 unsigned char *srcp
, *destp
;
1511 srcp
= (char *) src
;
1512 destp
= (char *) dest
;
1516 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1523 threadid:1, # always request threadid
1530 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1533 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1535 *pkt
++ = 'q'; /* Info Query */
1536 *pkt
++ = 'P'; /* process or thread info */
1537 pkt
= pack_int (pkt
, mode
); /* mode */
1538 pkt
= pack_threadid (pkt
, id
); /* threadid */
1539 *pkt
= '\0'; /* terminate */
1543 /* These values tag the fields in a thread info response packet. */
1544 /* Tagging the fields allows us to request specific fields and to
1545 add more fields as time goes by. */
1547 #define TAG_THREADID 1 /* Echo the thread identifier. */
1548 #define TAG_EXISTS 2 /* Is this process defined enough to
1549 fetch registers and its stack? */
1550 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1551 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1552 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1556 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1557 struct gdb_ext_thread_info
*info
)
1559 struct remote_state
*rs
= get_remote_state ();
1563 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1566 /* info->threadid = 0; FIXME: implement zero_threadref. */
1568 info
->display
[0] = '\0';
1569 info
->shortname
[0] = '\0';
1570 info
->more_display
[0] = '\0';
1572 /* Assume the characters indicating the packet type have been
1574 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1575 pkt
= unpack_threadid (pkt
, &ref
);
1578 warning (_("Incomplete response to threadinfo request."));
1579 if (!threadmatch (&ref
, expectedref
))
1580 { /* This is an answer to a different request. */
1581 warning (_("ERROR RMT Thread info mismatch."));
1584 copy_threadref (&info
->threadid
, &ref
);
1586 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1588 /* Packets are terminated with nulls. */
1589 while ((pkt
< limit
) && mask
&& *pkt
)
1591 pkt
= unpack_int (pkt
, &tag
); /* tag */
1592 pkt
= unpack_byte (pkt
, &length
); /* length */
1593 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1595 warning (_("ERROR RMT: threadinfo tag mismatch."));
1599 if (tag
== TAG_THREADID
)
1603 warning (_("ERROR RMT: length of threadid is not 16."));
1607 pkt
= unpack_threadid (pkt
, &ref
);
1608 mask
= mask
& ~TAG_THREADID
;
1611 if (tag
== TAG_EXISTS
)
1613 info
->active
= stub_unpack_int (pkt
, length
);
1615 mask
= mask
& ~(TAG_EXISTS
);
1618 warning (_("ERROR RMT: 'exists' length too long."));
1624 if (tag
== TAG_THREADNAME
)
1626 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1627 mask
= mask
& ~TAG_THREADNAME
;
1630 if (tag
== TAG_DISPLAY
)
1632 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1633 mask
= mask
& ~TAG_DISPLAY
;
1636 if (tag
== TAG_MOREDISPLAY
)
1638 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1639 mask
= mask
& ~TAG_MOREDISPLAY
;
1642 warning (_("ERROR RMT: unknown thread info tag."));
1643 break; /* Not a tag we know about. */
1649 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1650 struct gdb_ext_thread_info
*info
)
1652 struct remote_state
*rs
= get_remote_state ();
1655 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1657 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1658 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1663 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1666 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1667 threadref
*nextthread
)
1669 *pkt
++ = 'q'; /* info query packet */
1670 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1671 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1672 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1673 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1678 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1681 parse_threadlist_response (char *pkt
, int result_limit
,
1682 threadref
*original_echo
, threadref
*resultlist
,
1685 struct remote_state
*rs
= get_remote_state ();
1687 int count
, resultcount
, done
;
1690 /* Assume the 'q' and 'M chars have been stripped. */
1691 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1692 /* done parse past here */
1693 pkt
= unpack_byte (pkt
, &count
); /* count field */
1694 pkt
= unpack_nibble (pkt
, &done
);
1695 /* The first threadid is the argument threadid. */
1696 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1697 while ((count
-- > 0) && (pkt
< limit
))
1699 pkt
= unpack_threadid (pkt
, resultlist
++);
1700 if (resultcount
++ >= result_limit
)
1709 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1710 int *done
, int *result_count
, threadref
*threadlist
)
1712 struct remote_state
*rs
= get_remote_state ();
1713 static threadref echo_nextthread
;
1716 /* Trancate result limit to be smaller than the packet size. */
1717 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1718 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1720 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1722 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1725 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1728 if (!threadmatch (&echo_nextthread
, nextthread
))
1730 /* FIXME: This is a good reason to drop the packet. */
1731 /* Possably, there is a duplicate response. */
1733 retransmit immediatly - race conditions
1734 retransmit after timeout - yes
1736 wait for packet, then exit
1738 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1739 return 0; /* I choose simply exiting. */
1741 if (*result_count
<= 0)
1745 warning (_("RMT ERROR : failed to get remote thread list."));
1748 return result
; /* break; */
1750 if (*result_count
> result_limit
)
1753 warning (_("RMT ERROR: threadlist response longer than requested."));
1759 /* This is the interface between remote and threads, remotes upper
1762 /* remote_find_new_threads retrieves the thread list and for each
1763 thread in the list, looks up the thread in GDB's internal list,
1764 ading the thread if it does not already exist. This involves
1765 getting partial thread lists from the remote target so, polling the
1766 quit_flag is required. */
1769 /* About this many threadisds fit in a packet. */
1771 #define MAXTHREADLISTRESULTS 32
1774 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1777 int done
, i
, result_count
;
1781 static threadref nextthread
;
1782 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1787 if (loopcount
++ > looplimit
)
1790 warning (_("Remote fetch threadlist -infinite loop-."));
1793 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1794 &done
, &result_count
, resultthreadlist
))
1799 /* Clear for later iterations. */
1801 /* Setup to resume next batch of thread references, set nextthread. */
1802 if (result_count
>= 1)
1803 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1805 while (result_count
--)
1806 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1813 remote_newthread_step (threadref
*ref
, void *context
)
1817 ptid
= pid_to_ptid (threadref_to_int (ref
));
1819 if (!in_thread_list (ptid
))
1821 return 1; /* continue iterator */
1824 #define CRAZY_MAX_THREADS 1000
1827 remote_current_thread (ptid_t oldpid
)
1829 struct remote_state
*rs
= get_remote_state ();
1832 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1833 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1834 /* Use strtoul here, so we'll correctly parse values whose highest
1835 bit is set. The protocol carries them as a simple series of
1836 hex digits; in the absence of a sign, strtol will see such
1837 values as positive numbers out of range for signed 'long', and
1838 return LONG_MAX to indicate an overflow. */
1839 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1844 /* Find new threads for info threads command.
1845 * Original version, using John Metzler's thread protocol.
1849 remote_find_new_threads (void)
1851 remote_threadlist_iterator (remote_newthread_step
, 0,
1853 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1854 inferior_ptid
= remote_current_thread (inferior_ptid
);
1858 * Find all threads for info threads command.
1859 * Uses new thread protocol contributed by Cisco.
1860 * Falls back and attempts to use the older method (above)
1861 * if the target doesn't respond to the new method.
1865 remote_threads_info (void)
1867 struct remote_state
*rs
= get_remote_state ();
1871 if (remote_desc
== 0) /* paranoia */
1872 error (_("Command can only be used when connected to the remote target."));
1874 if (use_threadinfo_query
)
1876 putpkt ("qfThreadInfo");
1877 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1879 if (bufp
[0] != '\0') /* q packet recognized */
1881 while (*bufp
++ == 'm') /* reply contains one or more TID */
1885 /* Use strtoul here, so we'll correctly parse values
1886 whose highest bit is set. The protocol carries
1887 them as a simple series of hex digits; in the
1888 absence of a sign, strtol will see such values as
1889 positive numbers out of range for signed 'long',
1890 and return LONG_MAX to indicate an overflow. */
1891 tid
= strtoul (bufp
, &bufp
, 16);
1892 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1893 add_thread (pid_to_ptid (tid
));
1895 while (*bufp
++ == ','); /* comma-separated list */
1896 putpkt ("qsThreadInfo");
1897 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1904 /* Else fall back to old method based on jmetzler protocol. */
1905 use_threadinfo_query
= 0;
1906 remote_find_new_threads ();
1911 * Collect a descriptive string about the given thread.
1912 * The target may say anything it wants to about the thread
1913 * (typically info about its blocked / runnable state, name, etc.).
1914 * This string will appear in the info threads display.
1916 * Optional: targets are not required to implement this function.
1920 remote_threads_extra_info (struct thread_info
*tp
)
1922 struct remote_state
*rs
= get_remote_state ();
1926 struct gdb_ext_thread_info threadinfo
;
1927 static char display_buf
[100]; /* arbitrary... */
1928 int n
= 0; /* position in display_buf */
1930 if (remote_desc
== 0) /* paranoia */
1931 internal_error (__FILE__
, __LINE__
,
1932 _("remote_threads_extra_info"));
1934 if (use_threadextra_query
)
1936 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1939 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1940 if (rs
->buf
[0] != 0)
1942 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1943 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1944 display_buf
[result
] = '\0';
1949 /* If the above query fails, fall back to the old method. */
1950 use_threadextra_query
= 0;
1951 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1952 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1953 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1954 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1955 if (threadinfo
.active
)
1957 if (*threadinfo
.shortname
)
1958 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1959 " Name: %s,", threadinfo
.shortname
);
1960 if (*threadinfo
.display
)
1961 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1962 " State: %s,", threadinfo
.display
);
1963 if (*threadinfo
.more_display
)
1964 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1965 " Priority: %s", threadinfo
.more_display
);
1969 /* For purely cosmetic reasons, clear up trailing commas. */
1970 if (',' == display_buf
[n
-1])
1971 display_buf
[n
-1] = ' ';
1979 /* Restart the remote side; this is an extended protocol operation. */
1982 extended_remote_restart (void)
1984 struct remote_state
*rs
= get_remote_state ();
1986 /* Send the restart command; for reasons I don't understand the
1987 remote side really expects a number after the "R". */
1988 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1991 remote_fileio_reset ();
1993 /* Now query for status so this looks just like we restarted
1994 gdbserver from scratch. */
1996 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1999 /* Clean up connection to a remote debugger. */
2002 remote_close (int quitting
)
2005 serial_close (remote_desc
);
2009 /* Query the remote side for the text, data and bss offsets. */
2014 struct remote_state
*rs
= get_remote_state ();
2018 CORE_ADDR text_addr
, data_addr
, bss_addr
;
2019 struct section_offsets
*offs
;
2021 putpkt ("qOffsets");
2022 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2025 if (buf
[0] == '\000')
2026 return; /* Return silently. Stub doesn't support
2030 warning (_("Remote failure reply: %s"), buf
);
2034 /* Pick up each field in turn. This used to be done with scanf, but
2035 scanf will make trouble if CORE_ADDR size doesn't match
2036 conversion directives correctly. The following code will work
2037 with any size of CORE_ADDR. */
2038 text_addr
= data_addr
= bss_addr
= 0;
2042 if (strncmp (ptr
, "Text=", 5) == 0)
2045 /* Don't use strtol, could lose on big values. */
2046 while (*ptr
&& *ptr
!= ';')
2047 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2052 if (!lose
&& strncmp (ptr
, ";Data=", 6) == 0)
2055 while (*ptr
&& *ptr
!= ';')
2056 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2061 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2064 while (*ptr
&& *ptr
!= ';')
2065 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2071 error (_("Malformed response to offset query, %s"), buf
);
2073 if (symfile_objfile
== NULL
)
2076 offs
= ((struct section_offsets
*)
2077 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2078 memcpy (offs
, symfile_objfile
->section_offsets
,
2079 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2081 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2083 /* This is a temporary kludge to force data and bss to use the same offsets
2084 because that's what nlmconv does now. The real solution requires changes
2085 to the stub and remote.c that I don't have time to do right now. */
2087 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2088 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2090 objfile_relocate (symfile_objfile
, offs
);
2093 /* Stub for catch_exception. */
2096 remote_start_remote (struct ui_out
*uiout
, void *from_tty_p
)
2098 int from_tty
= * (int *) from_tty_p
;
2100 immediate_quit
++; /* Allow user to interrupt it. */
2102 /* Ack any packet which the remote side has already sent. */
2103 serial_write (remote_desc
, "+", 1);
2105 /* Let the stub know that we want it to return the thread. */
2108 inferior_ptid
= remote_current_thread (inferior_ptid
);
2110 get_offsets (); /* Get text, data & bss offsets. */
2112 putpkt ("?"); /* Initiate a query from remote machine. */
2115 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
2118 /* Open a connection to a remote debugger.
2119 NAME is the filename used for communication. */
2122 remote_open (char *name
, int from_tty
)
2124 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2127 /* Just like remote_open, but with asynchronous support. */
2129 remote_async_open (char *name
, int from_tty
)
2131 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2134 /* Open a connection to a remote debugger using the extended
2135 remote gdb protocol. NAME is the filename used for communication. */
2138 extended_remote_open (char *name
, int from_tty
)
2140 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2144 /* Just like extended_remote_open, but with asynchronous support. */
2146 extended_remote_async_open (char *name
, int from_tty
)
2148 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2149 1 /*extended_p */, 1 /* async_p */);
2152 /* Generic code for opening a connection to a remote target. */
2155 init_all_packet_configs (void)
2158 for (i
= 0; i
< PACKET_MAX
; i
++)
2159 update_packet_config (&remote_protocol_packets
[i
]);
2162 /* Symbol look-up. */
2165 remote_check_symbols (struct objfile
*objfile
)
2167 struct remote_state
*rs
= get_remote_state ();
2168 char *msg
, *reply
, *tmp
;
2169 struct minimal_symbol
*sym
;
2172 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2175 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2176 because we need both at the same time. */
2177 msg
= alloca (get_remote_packet_size ());
2179 /* Invite target to request symbol lookups. */
2181 putpkt ("qSymbol::");
2182 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2183 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2186 while (strncmp (reply
, "qSymbol:", 8) == 0)
2189 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2191 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2193 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2195 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2196 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2199 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2204 static struct serial
*
2205 remote_serial_open (char *name
)
2207 static int udp_warning
= 0;
2209 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2210 of in ser-tcp.c, because it is the remote protocol assuming that the
2211 serial connection is reliable and not the serial connection promising
2213 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2216 The remote protocol may be unreliable over UDP.\n\
2217 Some events may be lost, rendering further debugging impossible."));
2221 return serial_open (name
);
2224 /* This type describes each known response to the qSupported
2226 struct protocol_feature
2228 /* The name of this protocol feature. */
2231 /* The default for this protocol feature. */
2232 enum packet_support default_support
;
2234 /* The function to call when this feature is reported, or after
2235 qSupported processing if the feature is not supported.
2236 The first argument points to this structure. The second
2237 argument indicates whether the packet requested support be
2238 enabled, disabled, or probed (or the default, if this function
2239 is being called at the end of processing and this feature was
2240 not reported). The third argument may be NULL; if not NULL, it
2241 is a NUL-terminated string taken from the packet following
2242 this feature's name and an equals sign. */
2243 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2246 /* The corresponding packet for this feature. Only used if
2247 FUNC is remote_supported_packet. */
2252 remote_supported_packet (const struct protocol_feature
*feature
,
2253 enum packet_support support
,
2254 const char *argument
)
2258 warning (_("Remote qSupported response supplied an unexpected value for"
2259 " \"%s\"."), feature
->name
);
2263 if (remote_protocol_packets
[feature
->packet
].support
2264 == PACKET_SUPPORT_UNKNOWN
)
2265 remote_protocol_packets
[feature
->packet
].support
= support
;
2269 remote_packet_size (const struct protocol_feature
*feature
,
2270 enum packet_support support
, const char *value
)
2272 struct remote_state
*rs
= get_remote_state ();
2277 if (support
!= PACKET_ENABLE
)
2280 if (value
== NULL
|| *value
== '\0')
2282 warning (_("Remote target reported \"%s\" without a size."),
2288 packet_size
= strtol (value
, &value_end
, 16);
2289 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2291 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2292 feature
->name
, value
);
2296 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2298 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2299 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2300 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2303 /* Record the new maximum packet size. */
2304 rs
->explicit_packet_size
= packet_size
;
2307 static struct protocol_feature remote_protocol_features
[] = {
2308 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2309 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2310 PACKET_qXfer_auxv
},
2311 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2312 PACKET_qXfer_features
},
2313 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2314 PACKET_qXfer_memory_map
},
2315 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2316 PACKET_QPassSignals
},
2320 remote_query_supported (void)
2322 struct remote_state
*rs
= get_remote_state ();
2325 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2327 /* The packet support flags are handled differently for this packet
2328 than for most others. We treat an error, a disabled packet, and
2329 an empty response identically: any features which must be reported
2330 to be used will be automatically disabled. An empty buffer
2331 accomplishes this, since that is also the representation for a list
2332 containing no features. */
2335 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2337 putpkt ("qSupported");
2338 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2340 /* If an error occured, warn, but do not return - just reset the
2341 buffer to empty and go on to disable features. */
2342 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2345 warning (_("Remote failure reply: %s"), rs
->buf
);
2350 memset (seen
, 0, sizeof (seen
));
2355 enum packet_support is_supported
;
2356 char *p
, *end
, *name_end
, *value
;
2358 /* First separate out this item from the rest of the packet. If
2359 there's another item after this, we overwrite the separator
2360 (terminated strings are much easier to work with). */
2362 end
= strchr (p
, ';');
2365 end
= p
+ strlen (p
);
2375 warning (_("empty item in \"qSupported\" response"));
2380 name_end
= strchr (p
, '=');
2383 /* This is a name=value entry. */
2384 is_supported
= PACKET_ENABLE
;
2385 value
= name_end
+ 1;
2394 is_supported
= PACKET_ENABLE
;
2398 is_supported
= PACKET_DISABLE
;
2402 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2406 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2412 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2413 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2415 const struct protocol_feature
*feature
;
2418 feature
= &remote_protocol_features
[i
];
2419 feature
->func (feature
, is_supported
, value
);
2424 /* If we increased the packet size, make sure to increase the global
2425 buffer size also. We delay this until after parsing the entire
2426 qSupported packet, because this is the same buffer we were
2428 if (rs
->buf_size
< rs
->explicit_packet_size
)
2430 rs
->buf_size
= rs
->explicit_packet_size
;
2431 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2434 /* Handle the defaults for unmentioned features. */
2435 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2438 const struct protocol_feature
*feature
;
2440 feature
= &remote_protocol_features
[i
];
2441 feature
->func (feature
, feature
->default_support
, NULL
);
2447 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2448 int extended_p
, int async_p
)
2450 struct remote_state
*rs
= get_remote_state ();
2452 error (_("To open a remote debug connection, you need to specify what\n"
2453 "serial device is attached to the remote system\n"
2454 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2456 /* See FIXME above. */
2458 wait_forever_enabled_p
= 1;
2460 target_preopen (from_tty
);
2462 unpush_target (target
);
2464 /* Make sure we send the passed signals list the next time we resume. */
2465 xfree (last_pass_packet
);
2466 last_pass_packet
= NULL
;
2468 remote_fileio_reset ();
2469 reopen_exec_file ();
2472 remote_desc
= remote_serial_open (name
);
2474 perror_with_name (name
);
2476 if (baud_rate
!= -1)
2478 if (serial_setbaudrate (remote_desc
, baud_rate
))
2480 /* The requested speed could not be set. Error out to
2481 top level after closing remote_desc. Take care to
2482 set remote_desc to NULL to avoid closing remote_desc
2484 serial_close (remote_desc
);
2486 perror_with_name (name
);
2490 serial_raw (remote_desc
);
2492 /* If there is something sitting in the buffer we might take it as a
2493 response to a command, which would be bad. */
2494 serial_flush_input (remote_desc
);
2498 puts_filtered ("Remote debugging using ");
2499 puts_filtered (name
);
2500 puts_filtered ("\n");
2502 push_target (target
); /* Switch to using remote target now. */
2504 /* Reset the target state; these things will be queried either by
2505 remote_query_supported or as they are needed. */
2506 init_all_packet_configs ();
2507 rs
->explicit_packet_size
= 0;
2509 general_thread
= -2;
2510 continue_thread
= -2;
2512 /* Probe for ability to use "ThreadInfo" query, as required. */
2513 use_threadinfo_query
= 1;
2514 use_threadextra_query
= 1;
2516 /* The first packet we send to the target is the optional "supported
2517 packets" request. If the target can answer this, it will tell us
2518 which later probes to skip. */
2519 remote_query_supported ();
2521 /* Next, if the target can specify a description, read it. We do
2522 this before anything involving memory or registers. */
2523 target_find_description ();
2525 /* Without this, some commands which require an active target (such
2526 as kill) won't work. This variable serves (at least) double duty
2527 as both the pid of the target process (if it has such), and as a
2528 flag indicating that a target is active. These functions should
2529 be split out into seperate variables, especially since GDB will
2530 someday have a notion of debugging several processes. */
2532 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2536 /* With this target we start out by owning the terminal. */
2537 remote_async_terminal_ours_p
= 1;
2539 /* FIXME: cagney/1999-09-23: During the initial connection it is
2540 assumed that the target is already ready and able to respond to
2541 requests. Unfortunately remote_start_remote() eventually calls
2542 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2543 around this. Eventually a mechanism that allows
2544 wait_for_inferior() to expect/get timeouts will be
2546 wait_forever_enabled_p
= 0;
2549 /* First delete any symbols previously loaded from shared libraries. */
2550 no_shared_libraries (NULL
, 0);
2552 /* Start the remote connection. If error() or QUIT, discard this
2553 target (we'd otherwise be in an inconsistent state) and then
2554 propogate the error on up the exception chain. This ensures that
2555 the caller doesn't stumble along blindly assuming that the
2556 function succeeded. The CLI doesn't have this problem but other
2557 UI's, such as MI do.
2559 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2560 this function should return an error indication letting the
2561 caller restore the previous state. Unfortunately the command
2562 ``target remote'' is directly wired to this function making that
2563 impossible. On a positive note, the CLI side of this problem has
2564 been fixed - the function set_cmd_context() makes it possible for
2565 all the ``target ....'' commands to share a common callback
2566 function. See cli-dump.c. */
2568 struct gdb_exception ex
2569 = catch_exception (uiout
, remote_start_remote
, &from_tty
,
2575 wait_forever_enabled_p
= 1;
2576 throw_exception (ex
);
2581 wait_forever_enabled_p
= 1;
2585 /* Tell the remote that we are using the extended protocol. */
2587 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2590 if (exec_bfd
) /* No use without an exec file. */
2591 remote_check_symbols (symfile_objfile
);
2594 /* This takes a program previously attached to and detaches it. After
2595 this is done, GDB can be used to debug some other program. We
2596 better not have left any breakpoints in the target program or it'll
2597 die when it hits one. */
2600 remote_detach (char *args
, int from_tty
)
2602 struct remote_state
*rs
= get_remote_state ();
2605 error (_("Argument given to \"detach\" when remotely debugging."));
2607 /* Tell the remote target to detach. */
2608 strcpy (rs
->buf
, "D");
2610 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2612 if (rs
->buf
[0] == 'E')
2613 error (_("Can't detach process."));
2615 /* Unregister the file descriptor from the event loop. */
2616 if (target_is_async_p ())
2617 serial_async (remote_desc
, NULL
, 0);
2619 target_mourn_inferior ();
2621 puts_filtered ("Ending remote debugging.\n");
2624 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2627 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2630 error (_("Argument given to \"detach\" when remotely debugging."));
2632 /* Unregister the file descriptor from the event loop. */
2633 if (target_is_async_p ())
2634 serial_async (remote_desc
, NULL
, 0);
2636 target_mourn_inferior ();
2638 puts_filtered ("Ending remote debugging.\n");
2641 /* Convert hex digit A to a number. */
2646 if (a
>= '0' && a
<= '9')
2648 else if (a
>= 'a' && a
<= 'f')
2649 return a
- 'a' + 10;
2650 else if (a
>= 'A' && a
<= 'F')
2651 return a
- 'A' + 10;
2653 error (_("Reply contains invalid hex digit %d"), a
);
2657 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2661 for (i
= 0; i
< count
; i
++)
2663 if (hex
[0] == 0 || hex
[1] == 0)
2665 /* Hex string is short, or of uneven length.
2666 Return the count that has been converted so far. */
2669 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2675 /* Convert number NIB to a hex digit. */
2683 return 'a' + nib
- 10;
2687 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2690 /* May use a length, or a nul-terminated string as input. */
2692 count
= strlen ((char *) bin
);
2694 for (i
= 0; i
< count
; i
++)
2696 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2697 *hex
++ = tohex (*bin
++ & 0xf);
2703 /* Check for the availability of vCont. This function should also check
2707 remote_vcont_probe (struct remote_state
*rs
)
2711 strcpy (rs
->buf
, "vCont?");
2713 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2716 /* Make sure that the features we assume are supported. */
2717 if (strncmp (buf
, "vCont", 5) == 0)
2720 int support_s
, support_S
, support_c
, support_C
;
2726 while (p
&& *p
== ';')
2729 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2731 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2733 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2735 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2738 p
= strchr (p
, ';');
2741 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2742 BUF will make packet_ok disable the packet. */
2743 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2747 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2750 /* Resume the remote inferior by using a "vCont" packet. The thread
2751 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2752 resumed thread should be single-stepped and/or signalled. If PTID's
2753 PID is -1, then all threads are resumed; the thread to be stepped and/or
2754 signalled is given in the global INFERIOR_PTID. This function returns
2755 non-zero iff it resumes the inferior.
2757 This function issues a strict subset of all possible vCont commands at the
2761 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2763 struct remote_state
*rs
= get_remote_state ();
2764 int pid
= PIDGET (ptid
);
2765 char *buf
= NULL
, *outbuf
;
2766 struct cleanup
*old_cleanup
;
2768 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2769 remote_vcont_probe (rs
);
2771 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2774 /* If we could generate a wider range of packets, we'd have to worry
2775 about overflowing BUF. Should there be a generic
2776 "multi-part-packet" packet? */
2778 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2780 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2781 don't have any PID numbers the inferior will understand. Make sure
2782 to only send forms that do not specify a PID. */
2783 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2784 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2786 outbuf
= xstrprintf ("vCont;s");
2787 else if (siggnal
!= TARGET_SIGNAL_0
)
2788 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2790 outbuf
= xstrprintf ("vCont;c");
2794 /* Resume all threads, with preference for INFERIOR_PTID. */
2795 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2796 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2797 PIDGET (inferior_ptid
));
2799 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2800 else if (siggnal
!= TARGET_SIGNAL_0
)
2801 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2802 PIDGET (inferior_ptid
));
2804 outbuf
= xstrprintf ("vCont;c");
2808 /* Scheduler locking; resume only PTID. */
2809 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2810 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2812 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2813 else if (siggnal
!= TARGET_SIGNAL_0
)
2814 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2816 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2819 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2820 old_cleanup
= make_cleanup (xfree
, outbuf
);
2824 do_cleanups (old_cleanup
);
2829 /* Tell the remote machine to resume. */
2831 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2833 static int last_sent_step
;
2836 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2838 struct remote_state
*rs
= get_remote_state ();
2840 int pid
= PIDGET (ptid
);
2842 last_sent_signal
= siggnal
;
2843 last_sent_step
= step
;
2845 /* A hook for when we need to do something at the last moment before
2847 if (deprecated_target_resume_hook
)
2848 (*deprecated_target_resume_hook
) ();
2850 /* Update the inferior on signals to silently pass, if they've changed. */
2851 remote_pass_signals ();
2853 /* The vCont packet doesn't need to specify threads via Hc. */
2854 if (remote_vcont_resume (ptid
, step
, siggnal
))
2857 /* All other supported resume packets do use Hc, so call set_thread. */
2859 set_thread (0, 0); /* Run any thread. */
2861 set_thread (pid
, 0); /* Run this thread. */
2864 if (siggnal
!= TARGET_SIGNAL_0
)
2866 buf
[0] = step
? 'S' : 'C';
2867 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2868 buf
[2] = tohex (((int) siggnal
) & 0xf);
2872 strcpy (buf
, step
? "s" : "c");
2877 /* Same as remote_resume, but with async support. */
2879 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2881 remote_resume (ptid
, step
, siggnal
);
2883 /* We are about to start executing the inferior, let's register it
2884 with the event loop. NOTE: this is the one place where all the
2885 execution commands end up. We could alternatively do this in each
2886 of the execution commands in infcmd.c. */
2887 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2888 into infcmd.c in order to allow inferior function calls to work
2889 NOT asynchronously. */
2890 if (target_can_async_p ())
2891 target_async (inferior_event_handler
, 0);
2892 /* Tell the world that the target is now executing. */
2893 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2894 this? Instead, should the client of target just assume (for
2895 async targets) that the target is going to start executing? Is
2896 this information already found in the continuation block? */
2897 if (target_is_async_p ())
2898 target_executing
= 1;
2902 /* Set up the signal handler for SIGINT, while the target is
2903 executing, ovewriting the 'regular' SIGINT signal handler. */
2905 initialize_sigint_signal_handler (void)
2907 sigint_remote_token
=
2908 create_async_signal_handler (async_remote_interrupt
, NULL
);
2909 signal (SIGINT
, handle_remote_sigint
);
2912 /* Signal handler for SIGINT, while the target is executing. */
2914 handle_remote_sigint (int sig
)
2916 signal (sig
, handle_remote_sigint_twice
);
2917 sigint_remote_twice_token
=
2918 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2919 mark_async_signal_handler_wrapper (sigint_remote_token
);
2922 /* Signal handler for SIGINT, installed after SIGINT has already been
2923 sent once. It will take effect the second time that the user sends
2926 handle_remote_sigint_twice (int sig
)
2928 signal (sig
, handle_sigint
);
2929 sigint_remote_twice_token
=
2930 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
2931 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
2934 /* Perform the real interruption of the target execution, in response
2937 async_remote_interrupt (gdb_client_data arg
)
2940 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2945 /* Perform interrupt, if the first attempt did not succeed. Just give
2946 up on the target alltogether. */
2948 async_remote_interrupt_twice (gdb_client_data arg
)
2951 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
2952 /* Do something only if the target was not killed by the previous
2954 if (target_executing
)
2957 signal (SIGINT
, handle_remote_sigint
);
2961 /* Reinstall the usual SIGINT handlers, after the target has
2964 cleanup_sigint_signal_handler (void *dummy
)
2966 signal (SIGINT
, handle_sigint
);
2967 if (sigint_remote_twice_token
)
2968 delete_async_signal_handler (&sigint_remote_twice_token
);
2969 if (sigint_remote_token
)
2970 delete_async_signal_handler (&sigint_remote_token
);
2973 /* Send ^C to target to halt it. Target will respond, and send us a
2975 static void (*ofunc
) (int);
2977 /* The command line interface's stop routine. This function is installed
2978 as a signal handler for SIGINT. The first time a user requests a
2979 stop, we call remote_stop to send a break or ^C. If there is no
2980 response from the target (it didn't stop when the user requested it),
2981 we ask the user if he'd like to detach from the target. */
2983 remote_interrupt (int signo
)
2985 /* If this doesn't work, try more severe steps. */
2986 signal (signo
, remote_interrupt_twice
);
2989 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2994 /* The user typed ^C twice. */
2997 remote_interrupt_twice (int signo
)
2999 signal (signo
, ofunc
);
3001 signal (signo
, remote_interrupt
);
3004 /* This is the generic stop called via the target vector. When a target
3005 interrupt is requested, either by the command line or the GUI, we
3006 will eventually end up here. */
3010 /* Send a break or a ^C, depending on user preference. */
3012 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
3015 serial_send_break (remote_desc
);
3017 serial_write (remote_desc
, "\003", 1);
3020 /* Ask the user what to do when an interrupt is received. */
3023 interrupt_query (void)
3025 target_terminal_ours ();
3027 if (query ("Interrupted while waiting for the program.\n\
3028 Give up (and stop debugging it)? "))
3030 target_mourn_inferior ();
3031 deprecated_throw_reason (RETURN_QUIT
);
3034 target_terminal_inferior ();
3037 /* Enable/disable target terminal ownership. Most targets can use
3038 terminal groups to control terminal ownership. Remote targets are
3039 different in that explicit transfer of ownership to/from GDB/target
3043 remote_async_terminal_inferior (void)
3045 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3046 sync_execution here. This function should only be called when
3047 GDB is resuming the inferior in the forground. A background
3048 resume (``run&'') should leave GDB in control of the terminal and
3049 consequently should not call this code. */
3050 if (!sync_execution
)
3052 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3053 calls target_terminal_*() idenpotent. The event-loop GDB talking
3054 to an asynchronous target with a synchronous command calls this
3055 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3056 stops trying to transfer the terminal to the target when it
3057 shouldn't this guard can go away. */
3058 if (!remote_async_terminal_ours_p
)
3060 delete_file_handler (input_fd
);
3061 remote_async_terminal_ours_p
= 0;
3062 initialize_sigint_signal_handler ();
3063 /* NOTE: At this point we could also register our selves as the
3064 recipient of all input. Any characters typed could then be
3065 passed on down to the target. */
3069 remote_async_terminal_ours (void)
3071 /* See FIXME in remote_async_terminal_inferior. */
3072 if (!sync_execution
)
3074 /* See FIXME in remote_async_terminal_inferior. */
3075 if (remote_async_terminal_ours_p
)
3077 cleanup_sigint_signal_handler (NULL
);
3078 add_file_handler (input_fd
, stdin_event_handler
, 0);
3079 remote_async_terminal_ours_p
= 1;
3082 /* If nonzero, ignore the next kill. */
3087 remote_console_output (char *msg
)
3091 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3094 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3097 fputs_unfiltered (tb
, gdb_stdtarg
);
3099 gdb_flush (gdb_stdtarg
);
3102 /* Wait until the remote machine stops, then return,
3103 storing status in STATUS just as `wait' would.
3104 Returns "pid", which in the case of a multi-threaded
3105 remote OS, is the thread-id. */
3108 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3110 struct remote_state
*rs
= get_remote_state ();
3111 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3112 ULONGEST thread_num
= -1;
3115 status
->kind
= TARGET_WAITKIND_EXITED
;
3116 status
->value
.integer
= 0;
3122 ofunc
= signal (SIGINT
, remote_interrupt
);
3123 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3124 signal (SIGINT
, ofunc
);
3128 /* This is a hook for when we need to do something (perhaps the
3129 collection of trace data) every time the target stops. */
3130 if (deprecated_target_wait_loop_hook
)
3131 (*deprecated_target_wait_loop_hook
) ();
3133 remote_stopped_by_watchpoint_p
= 0;
3137 case 'E': /* Error of some sort. */
3138 warning (_("Remote failure reply: %s"), buf
);
3140 case 'F': /* File-I/O request. */
3141 remote_fileio_request (buf
);
3143 case 'T': /* Status with PC, SP, FP, ... */
3145 gdb_byte regs
[MAX_REGISTER_SIZE
];
3147 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3148 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3150 n... = register number
3151 r... = register contents
3153 p
= &buf
[3]; /* after Txx */
3162 /* If the packet contains a register number save it in
3163 pnum and set p1 to point to the character following
3164 it. Otherwise p1 points to p. */
3166 /* If this packet is an awatch packet, don't parse the
3167 'a' as a register number. */
3169 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3171 /* Read the ``P'' register number. */
3172 pnum
= strtol (p
, &p_temp
, 16);
3178 if (p1
== p
) /* No register number present here. */
3180 p1
= strchr (p
, ':');
3182 error (_("Malformed packet(a) (missing colon): %s\n\
3185 if (strncmp (p
, "thread", p1
- p
) == 0)
3187 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3188 record_currthread (thread_num
);
3191 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3192 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3193 || (strncmp (p
, "awatch", p1
- p
) == 0))
3195 remote_stopped_by_watchpoint_p
= 1;
3196 p
= unpack_varlen_hex (++p1
, &addr
);
3197 remote_watch_data_address
= (CORE_ADDR
)addr
;
3201 /* Silently skip unknown optional info. */
3202 p_temp
= strchr (p1
+ 1, ';');
3209 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3213 error (_("Malformed packet(b) (missing colon): %s\n\
3218 error (_("Remote sent bad register number %s: %s\n\
3220 phex_nz (pnum
, 0), p
, buf
);
3222 fieldsize
= hex2bin (p
, regs
,
3223 register_size (current_gdbarch
,
3226 if (fieldsize
< register_size (current_gdbarch
,
3228 warning (_("Remote reply is too short: %s"), buf
);
3229 regcache_raw_supply (current_regcache
,
3234 error (_("Remote register badly formatted: %s\nhere: %s"),
3239 case 'S': /* Old style status, just signal only. */
3240 status
->kind
= TARGET_WAITKIND_STOPPED
;
3241 status
->value
.sig
= (enum target_signal
)
3242 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3246 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3247 record_currthread (thread_num
);
3250 case 'W': /* Target exited. */
3252 /* The remote process exited. */
3253 status
->kind
= TARGET_WAITKIND_EXITED
;
3254 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3258 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3259 status
->value
.sig
= (enum target_signal
)
3260 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3264 case 'O': /* Console output. */
3265 remote_console_output (buf
+ 1);
3268 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3270 /* Zero length reply means that we tried 'S' or 'C' and
3271 the remote system doesn't support it. */
3272 target_terminal_ours_for_output ();
3274 ("Can't send signals to this remote system. %s not sent.\n",
3275 target_signal_to_name (last_sent_signal
));
3276 last_sent_signal
= TARGET_SIGNAL_0
;
3277 target_terminal_inferior ();
3279 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3280 putpkt ((char *) buf
);
3283 /* else fallthrough */
3285 warning (_("Invalid remote reply: %s"), buf
);
3290 if (thread_num
!= -1)
3292 return pid_to_ptid (thread_num
);
3294 return inferior_ptid
;
3297 /* Async version of remote_wait. */
3299 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3301 struct remote_state
*rs
= get_remote_state ();
3302 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3303 ULONGEST thread_num
= -1;
3306 status
->kind
= TARGET_WAITKIND_EXITED
;
3307 status
->value
.integer
= 0;
3309 remote_stopped_by_watchpoint_p
= 0;
3315 if (!target_is_async_p ())
3316 ofunc
= signal (SIGINT
, remote_interrupt
);
3317 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3318 _never_ wait for ever -> test on target_is_async_p().
3319 However, before we do that we need to ensure that the caller
3320 knows how to take the target into/out of async mode. */
3321 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3322 if (!target_is_async_p ())
3323 signal (SIGINT
, ofunc
);
3327 /* This is a hook for when we need to do something (perhaps the
3328 collection of trace data) every time the target stops. */
3329 if (deprecated_target_wait_loop_hook
)
3330 (*deprecated_target_wait_loop_hook
) ();
3334 case 'E': /* Error of some sort. */
3335 warning (_("Remote failure reply: %s"), buf
);
3337 case 'F': /* File-I/O request. */
3338 remote_fileio_request (buf
);
3340 case 'T': /* Status with PC, SP, FP, ... */
3342 gdb_byte regs
[MAX_REGISTER_SIZE
];
3344 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3345 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3347 n... = register number
3348 r... = register contents
3350 p
= &buf
[3]; /* after Txx */
3359 /* If the packet contains a register number, save it
3360 in pnum and set p1 to point to the character
3361 following it. Otherwise p1 points to p. */
3363 /* If this packet is an awatch packet, don't parse the 'a'
3364 as a register number. */
3366 if (!strncmp (p
, "awatch", strlen ("awatch")) != 0)
3368 /* Read the register number. */
3369 pnum
= strtol (p
, &p_temp
, 16);
3375 if (p1
== p
) /* No register number present here. */
3377 p1
= strchr (p
, ':');
3379 error (_("Malformed packet(a) (missing colon): %s\n\
3382 if (strncmp (p
, "thread", p1
- p
) == 0)
3384 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3385 record_currthread (thread_num
);
3388 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3389 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3390 || (strncmp (p
, "awatch", p1
- p
) == 0))
3392 remote_stopped_by_watchpoint_p
= 1;
3393 p
= unpack_varlen_hex (++p1
, &addr
);
3394 remote_watch_data_address
= (CORE_ADDR
)addr
;
3398 /* Silently skip unknown optional info. */
3399 p_temp
= strchr (p1
+ 1, ';');
3407 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3410 error (_("Malformed packet(b) (missing colon): %s\n\
3415 error (_("Remote sent bad register number %ld: %s\n\
3419 fieldsize
= hex2bin (p
, regs
,
3420 register_size (current_gdbarch
,
3423 if (fieldsize
< register_size (current_gdbarch
,
3425 warning (_("Remote reply is too short: %s"), buf
);
3426 regcache_raw_supply (current_regcache
, reg
->regnum
, regs
);
3430 error (_("Remote register badly formatted: %s\nhere: %s"),
3435 case 'S': /* Old style status, just signal only. */
3436 status
->kind
= TARGET_WAITKIND_STOPPED
;
3437 status
->value
.sig
= (enum target_signal
)
3438 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3442 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3443 record_currthread (thread_num
);
3446 case 'W': /* Target exited. */
3448 /* The remote process exited. */
3449 status
->kind
= TARGET_WAITKIND_EXITED
;
3450 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3454 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3455 status
->value
.sig
= (enum target_signal
)
3456 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3460 case 'O': /* Console output. */
3461 remote_console_output (buf
+ 1);
3462 /* Return immediately to the event loop. The event loop will
3463 still be waiting on the inferior afterwards. */
3464 status
->kind
= TARGET_WAITKIND_IGNORE
;
3467 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3469 /* Zero length reply means that we tried 'S' or 'C' and
3470 the remote system doesn't support it. */
3471 target_terminal_ours_for_output ();
3473 ("Can't send signals to this remote system. %s not sent.\n",
3474 target_signal_to_name (last_sent_signal
));
3475 last_sent_signal
= TARGET_SIGNAL_0
;
3476 target_terminal_inferior ();
3478 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3479 putpkt ((char *) buf
);
3482 /* else fallthrough */
3484 warning (_("Invalid remote reply: %s"), buf
);
3489 if (thread_num
!= -1)
3491 return pid_to_ptid (thread_num
);
3493 return inferior_ptid
;
3496 /* Fetch a single register using a 'p' packet. */
3499 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
3501 struct remote_state
*rs
= get_remote_state ();
3503 char regp
[MAX_REGISTER_SIZE
];
3506 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3509 if (reg
->pnum
== -1)
3514 p
+= hexnumstr (p
, reg
->pnum
);
3516 remote_send (&rs
->buf
, &rs
->buf_size
);
3520 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3524 case PACKET_UNKNOWN
:
3527 error (_("Could not fetch register \"%s\""),
3528 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3531 /* If this register is unfetchable, tell the regcache. */
3534 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3538 /* Otherwise, parse and supply the value. */
3544 error (_("fetch_register_using_p: early buf termination"));
3546 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3549 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
3553 /* Fetch the registers included in the target's 'g' packet. */
3556 send_g_packet (void)
3558 struct remote_state
*rs
= get_remote_state ();
3563 sprintf (rs
->buf
, "g");
3564 remote_send (&rs
->buf
, &rs
->buf_size
);
3566 /* We can get out of synch in various cases. If the first character
3567 in the buffer is not a hex character, assume that has happened
3568 and try to fetch another packet to read. */
3569 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3570 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3571 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3572 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3575 fprintf_unfiltered (gdb_stdlog
,
3576 "Bad register packet; fetching a new packet\n");
3577 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3580 buf_len
= strlen (rs
->buf
);
3582 /* Sanity check the received packet. */
3583 if (buf_len
% 2 != 0)
3584 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3590 process_g_packet (struct regcache
*regcache
)
3592 struct remote_state
*rs
= get_remote_state ();
3593 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3598 buf_len
= strlen (rs
->buf
);
3600 /* Further sanity checks, with knowledge of the architecture. */
3601 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3602 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3604 /* Save the size of the packet sent to us by the target. It is used
3605 as a heuristic when determining the max size of packets that the
3606 target can safely receive. */
3607 if (rsa
->actual_register_packet_size
== 0)
3608 rsa
->actual_register_packet_size
= buf_len
;
3610 /* If this is smaller than we guessed the 'g' packet would be,
3611 update our records. A 'g' reply that doesn't include a register's
3612 value implies either that the register is not available, or that
3613 the 'p' packet must be used. */
3614 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3616 rsa
->sizeof_g_packet
= buf_len
/ 2;
3618 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3620 if (rsa
->regs
[i
].pnum
== -1)
3623 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3624 rsa
->regs
[i
].in_g_packet
= 0;
3626 rsa
->regs
[i
].in_g_packet
= 1;
3630 regs
= alloca (rsa
->sizeof_g_packet
);
3632 /* Unimplemented registers read as all bits zero. */
3633 memset (regs
, 0, rsa
->sizeof_g_packet
);
3635 /* Reply describes registers byte by byte, each byte encoded as two
3636 hex characters. Suck them all up, then supply them to the
3637 register cacheing/storage mechanism. */
3640 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3642 if (p
[0] == 0 || p
[1] == 0)
3643 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3644 internal_error (__FILE__
, __LINE__
,
3645 "unexpected end of 'g' packet reply");
3647 if (p
[0] == 'x' && p
[1] == 'x')
3648 regs
[i
] = 0; /* 'x' */
3650 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3656 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3658 struct packet_reg
*r
= &rsa
->regs
[i
];
3661 if (r
->offset
* 2 >= strlen (rs
->buf
))
3662 /* This shouldn't happen - we adjusted in_g_packet above. */
3663 internal_error (__FILE__
, __LINE__
,
3664 "unexpected end of 'g' packet reply");
3665 else if (rs
->buf
[r
->offset
* 2] == 'x')
3667 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3668 /* The register isn't available, mark it as such (at
3669 the same time setting the value to zero). */
3670 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
3673 regcache_raw_supply (regcache
, r
->regnum
,
3681 fetch_registers_using_g (struct regcache
*regcache
)
3684 process_g_packet (regcache
);
3688 remote_fetch_registers (struct regcache
*regcache
, int regnum
)
3690 struct remote_state
*rs
= get_remote_state ();
3691 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3694 set_thread (PIDGET (inferior_ptid
), 1);
3698 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3699 gdb_assert (reg
!= NULL
);
3701 /* If this register might be in the 'g' packet, try that first -
3702 we are likely to read more than one register. If this is the
3703 first 'g' packet, we might be overly optimistic about its
3704 contents, so fall back to 'p'. */
3705 if (reg
->in_g_packet
)
3707 fetch_registers_using_g (regcache
);
3708 if (reg
->in_g_packet
)
3712 if (fetch_register_using_p (regcache
, reg
))
3715 /* This register is not available. */
3716 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
3721 fetch_registers_using_g (regcache
);
3723 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3724 if (!rsa
->regs
[i
].in_g_packet
)
3725 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
3727 /* This register is not available. */
3728 regcache_raw_supply (regcache
, i
, NULL
);
3732 /* Prepare to store registers. Since we may send them all (using a
3733 'G' request), we have to read out the ones we don't want to change
3737 remote_prepare_to_store (struct regcache
*regcache
)
3739 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3741 gdb_byte buf
[MAX_REGISTER_SIZE
];
3743 /* Make sure the entire registers array is valid. */
3744 switch (remote_protocol_packets
[PACKET_P
].support
)
3746 case PACKET_DISABLE
:
3747 case PACKET_SUPPORT_UNKNOWN
:
3748 /* Make sure all the necessary registers are cached. */
3749 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3750 if (rsa
->regs
[i
].in_g_packet
)
3751 regcache_raw_read (regcache
, rsa
->regs
[i
].regnum
, buf
);
3758 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3759 packet was not recognized. */
3762 store_register_using_P (const struct regcache
*regcache
, struct packet_reg
*reg
)
3764 struct remote_state
*rs
= get_remote_state ();
3765 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3766 /* Try storing a single register. */
3767 char *buf
= rs
->buf
;
3768 gdb_byte regp
[MAX_REGISTER_SIZE
];
3771 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3774 if (reg
->pnum
== -1)
3777 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3778 p
= buf
+ strlen (buf
);
3779 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
3780 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3781 remote_send (&rs
->buf
, &rs
->buf_size
);
3783 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3788 error (_("Could not write register \"%s\""),
3789 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3790 case PACKET_UNKNOWN
:
3793 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3797 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3798 contents of the register cache buffer. FIXME: ignores errors. */
3801 store_registers_using_G (const struct regcache
*regcache
)
3803 struct remote_state
*rs
= get_remote_state ();
3804 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3808 /* Extract all the registers in the regcache copying them into a
3812 regs
= alloca (rsa
->sizeof_g_packet
);
3813 memset (regs
, 0, rsa
->sizeof_g_packet
);
3814 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3816 struct packet_reg
*r
= &rsa
->regs
[i
];
3818 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
3822 /* Command describes registers byte by byte,
3823 each byte encoded as two hex characters. */
3826 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3828 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3829 remote_send (&rs
->buf
, &rs
->buf_size
);
3832 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3833 of the register cache buffer. FIXME: ignores errors. */
3836 remote_store_registers (struct regcache
*regcache
, int regnum
)
3838 struct remote_state
*rs
= get_remote_state ();
3839 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3842 set_thread (PIDGET (inferior_ptid
), 1);
3846 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3847 gdb_assert (reg
!= NULL
);
3849 /* Always prefer to store registers using the 'P' packet if
3850 possible; we often change only a small number of registers.
3851 Sometimes we change a larger number; we'd need help from a
3852 higher layer to know to use 'G'. */
3853 if (store_register_using_P (regcache
, reg
))
3856 /* For now, don't complain if we have no way to write the
3857 register. GDB loses track of unavailable registers too
3858 easily. Some day, this may be an error. We don't have
3859 any way to read the register, either... */
3860 if (!reg
->in_g_packet
)
3863 store_registers_using_G (regcache
);
3867 store_registers_using_G (regcache
);
3869 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
3870 if (!rsa
->regs
[i
].in_g_packet
)
3871 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
3872 /* See above for why we do not issue an error here. */
3877 /* Return the number of hex digits in num. */
3880 hexnumlen (ULONGEST num
)
3884 for (i
= 0; num
!= 0; i
++)
3890 /* Set BUF to the minimum number of hex digits representing NUM. */
3893 hexnumstr (char *buf
, ULONGEST num
)
3895 int len
= hexnumlen (num
);
3896 return hexnumnstr (buf
, num
, len
);
3900 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3903 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3909 for (i
= width
- 1; i
>= 0; i
--)
3911 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3918 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3921 remote_address_masked (CORE_ADDR addr
)
3923 if (remote_address_size
> 0
3924 && remote_address_size
< (sizeof (ULONGEST
) * 8))
3926 /* Only create a mask when that mask can safely be constructed
3927 in a ULONGEST variable. */
3929 mask
= (mask
<< remote_address_size
) - 1;
3935 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
3936 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
3937 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
3938 (which may be more than *OUT_LEN due to escape characters). The
3939 total number of bytes in the output buffer will be at most
3943 remote_escape_output (const gdb_byte
*buffer
, int len
,
3944 gdb_byte
*out_buf
, int *out_len
,
3947 int input_index
, output_index
;
3950 for (input_index
= 0; input_index
< len
; input_index
++)
3952 gdb_byte b
= buffer
[input_index
];
3954 if (b
== '$' || b
== '#' || b
== '}')
3956 /* These must be escaped. */
3957 if (output_index
+ 2 > out_maxlen
)
3959 out_buf
[output_index
++] = '}';
3960 out_buf
[output_index
++] = b
^ 0x20;
3964 if (output_index
+ 1 > out_maxlen
)
3966 out_buf
[output_index
++] = b
;
3970 *out_len
= input_index
;
3971 return output_index
;
3974 /* Convert BUFFER, escaped data LEN bytes long, into binary data
3975 in OUT_BUF. Return the number of bytes written to OUT_BUF.
3976 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
3978 This function reverses remote_escape_output. It allows more
3979 escaped characters than that function does, in particular because
3980 '*' must be escaped to avoid the run-length encoding processing
3981 in reading packets. */
3984 remote_unescape_input (const gdb_byte
*buffer
, int len
,
3985 gdb_byte
*out_buf
, int out_maxlen
)
3987 int input_index
, output_index
;
3992 for (input_index
= 0; input_index
< len
; input_index
++)
3994 gdb_byte b
= buffer
[input_index
];
3996 if (output_index
+ 1 > out_maxlen
)
3998 warning (_("Received too much data from remote target;"
3999 " ignoring overflow."));
4000 return output_index
;
4005 out_buf
[output_index
++] = b
^ 0x20;
4011 out_buf
[output_index
++] = b
;
4015 error (_("Unmatched escape character in target response."));
4017 return output_index
;
4020 /* Determine whether the remote target supports binary downloading.
4021 This is accomplished by sending a no-op memory write of zero length
4022 to the target at the specified address. It does not suffice to send
4023 the whole packet, since many stubs strip the eighth bit and
4024 subsequently compute a wrong checksum, which causes real havoc with
4027 NOTE: This can still lose if the serial line is not eight-bit
4028 clean. In cases like this, the user should clear "remote
4032 check_binary_download (CORE_ADDR addr
)
4034 struct remote_state
*rs
= get_remote_state ();
4036 switch (remote_protocol_packets
[PACKET_X
].support
)
4038 case PACKET_DISABLE
:
4042 case PACKET_SUPPORT_UNKNOWN
:
4048 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4050 p
+= hexnumstr (p
, (ULONGEST
) 0);
4054 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4055 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4057 if (rs
->buf
[0] == '\0')
4060 fprintf_unfiltered (gdb_stdlog
,
4061 "binary downloading NOT suppported by target\n");
4062 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4067 fprintf_unfiltered (gdb_stdlog
,
4068 "binary downloading suppported by target\n");
4069 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4076 /* Write memory data directly to the remote machine.
4077 This does not inform the data cache; the data cache uses this.
4078 HEADER is the starting part of the packet.
4079 MEMADDR is the address in the remote memory space.
4080 MYADDR is the address of the buffer in our space.
4081 LEN is the number of bytes.
4082 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4083 should send data as binary ('X'), or hex-encoded ('M').
4085 The function creates packet of the form
4086 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4088 where encoding of <DATA> is termined by PACKET_FORMAT.
4090 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4093 Returns the number of bytes transferred, or 0 (setting errno) for
4094 error. Only transfer a single packet. */
4097 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4098 const gdb_byte
*myaddr
, int len
,
4099 char packet_format
, int use_length
)
4101 struct remote_state
*rs
= get_remote_state ();
4111 if (packet_format
!= 'X' && packet_format
!= 'M')
4112 internal_error (__FILE__
, __LINE__
,
4113 "remote_write_bytes_aux: bad packet format");
4118 payload_size
= get_memory_write_packet_size ();
4120 /* The packet buffer will be large enough for the payload;
4121 get_memory_packet_size ensures this. */
4124 /* Compute the size of the actual payload by subtracting out the
4125 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4127 payload_size
-= strlen ("$,:#NN");
4129 /* The comma won't be used. */
4131 header_length
= strlen (header
);
4132 payload_size
-= header_length
;
4133 payload_size
-= hexnumlen (memaddr
);
4135 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4137 strcat (rs
->buf
, header
);
4138 p
= rs
->buf
+ strlen (header
);
4140 /* Compute a best guess of the number of bytes actually transfered. */
4141 if (packet_format
== 'X')
4143 /* Best guess at number of bytes that will fit. */
4144 todo
= min (len
, payload_size
);
4146 payload_size
-= hexnumlen (todo
);
4147 todo
= min (todo
, payload_size
);
4151 /* Num bytes that will fit. */
4152 todo
= min (len
, payload_size
/ 2);
4154 payload_size
-= hexnumlen (todo
);
4155 todo
= min (todo
, payload_size
/ 2);
4159 internal_error (__FILE__
, __LINE__
,
4160 _("minumum packet size too small to write data"));
4162 /* If we already need another packet, then try to align the end
4163 of this packet to a useful boundary. */
4164 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4165 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4167 /* Append "<memaddr>". */
4168 memaddr
= remote_address_masked (memaddr
);
4169 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4176 /* Append <len>. Retain the location/size of <len>. It may need to
4177 be adjusted once the packet body has been created. */
4179 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4187 /* Append the packet body. */
4188 if (packet_format
== 'X')
4190 /* Binary mode. Send target system values byte by byte, in
4191 increasing byte addresses. Only escape certain critical
4193 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4196 /* If not all TODO bytes fit, then we'll need another packet. Make
4197 a second try to keep the end of the packet aligned. Don't do
4198 this if the packet is tiny. */
4199 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4203 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4205 if (new_nr_bytes
!= nr_bytes
)
4206 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4211 p
+= payload_length
;
4212 if (use_length
&& nr_bytes
< todo
)
4214 /* Escape chars have filled up the buffer prematurely,
4215 and we have actually sent fewer bytes than planned.
4216 Fix-up the length field of the packet. Use the same
4217 number of characters as before. */
4218 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4219 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4224 /* Normal mode: Send target system values byte by byte, in
4225 increasing byte addresses. Each byte is encoded as a two hex
4227 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4231 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4232 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4234 if (rs
->buf
[0] == 'E')
4236 /* There is no correspondance between what the remote protocol
4237 uses for errors and errno codes. We would like a cleaner way
4238 of representing errors (big enough to include errno codes,
4239 bfd_error codes, and others). But for now just return EIO. */
4244 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4245 fewer bytes than we'd planned. */
4249 /* Write memory data directly to the remote machine.
4250 This does not inform the data cache; the data cache uses this.
4251 MEMADDR is the address in the remote memory space.
4252 MYADDR is the address of the buffer in our space.
4253 LEN is the number of bytes.
4255 Returns number of bytes transferred, or 0 (setting errno) for
4256 error. Only transfer a single packet. */
4259 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4261 char *packet_format
= 0;
4263 /* Check whether the target supports binary download. */
4264 check_binary_download (memaddr
);
4266 switch (remote_protocol_packets
[PACKET_X
].support
)
4269 packet_format
= "X";
4271 case PACKET_DISABLE
:
4272 packet_format
= "M";
4274 case PACKET_SUPPORT_UNKNOWN
:
4275 internal_error (__FILE__
, __LINE__
,
4276 _("remote_write_bytes: bad internal state"));
4278 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4281 return remote_write_bytes_aux (packet_format
,
4282 memaddr
, myaddr
, len
, packet_format
[0], 1);
4285 /* Read memory data directly from the remote machine.
4286 This does not use the data cache; the data cache uses this.
4287 MEMADDR is the address in the remote memory space.
4288 MYADDR is the address of the buffer in our space.
4289 LEN is the number of bytes.
4291 Returns number of bytes transferred, or 0 for error. */
4293 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4294 remote targets) shouldn't attempt to read the entire buffer.
4295 Instead it should read a single packet worth of data and then
4296 return the byte size of that packet to the caller. The caller (its
4297 caller and its callers caller ;-) already contains code for
4298 handling partial reads. */
4301 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4303 struct remote_state
*rs
= get_remote_state ();
4304 int max_buf_size
; /* Max size of packet output buffer. */
4310 max_buf_size
= get_memory_read_packet_size ();
4311 /* The packet buffer will be large enough for the payload;
4312 get_memory_packet_size ensures this. */
4321 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4323 /* construct "m"<memaddr>","<len>" */
4324 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4325 memaddr
= remote_address_masked (memaddr
);
4328 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4330 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4334 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4336 if (rs
->buf
[0] == 'E'
4337 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4338 && rs
->buf
[3] == '\0')
4340 /* There is no correspondance between what the remote
4341 protocol uses for errors and errno codes. We would like
4342 a cleaner way of representing errors (big enough to
4343 include errno codes, bfd_error codes, and others). But
4344 for now just return EIO. */
4349 /* Reply describes memory byte by byte,
4350 each byte encoded as two hex characters. */
4353 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4355 /* Reply is short. This means that we were able to read
4356 only part of what we wanted to. */
4357 return i
+ (origlen
- len
);
4366 /* Read or write LEN bytes from inferior memory at MEMADDR,
4367 transferring to or from debugger address BUFFER. Write to inferior
4368 if SHOULD_WRITE is nonzero. Returns length of data written or
4369 read; 0 for error. TARGET is unused. */
4372 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4373 int should_write
, struct mem_attrib
*attrib
,
4374 struct target_ops
*target
)
4379 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4381 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4386 /* Sends a packet with content determined by the printf format string
4387 FORMAT and the remaining arguments, then gets the reply. Returns
4388 whether the packet was a success, a failure, or unknown. */
4391 remote_send_printf (const char *format
, ...)
4393 struct remote_state
*rs
= get_remote_state ();
4394 int max_size
= get_remote_packet_size ();
4397 va_start (ap
, format
);
4400 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4401 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4403 if (putpkt (rs
->buf
) < 0)
4404 error (_("Communication problem with target."));
4407 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4409 return packet_check_result (rs
->buf
);
4413 restore_remote_timeout (void *p
)
4415 int value
= *(int *)p
;
4416 remote_timeout
= value
;
4419 /* Flash writing can take quite some time. We'll set
4420 effectively infinite timeout for flash operations.
4421 In future, we'll need to decide on a better approach. */
4422 static const int remote_flash_timeout
= 1000;
4425 remote_flash_erase (struct target_ops
*ops
,
4426 ULONGEST address
, LONGEST length
)
4428 int saved_remote_timeout
= remote_timeout
;
4429 enum packet_result ret
;
4431 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4432 &saved_remote_timeout
);
4433 remote_timeout
= remote_flash_timeout
;
4435 ret
= remote_send_printf ("vFlashErase:%s,%s",
4440 case PACKET_UNKNOWN
:
4441 error (_("Remote target does not support flash erase"));
4443 error (_("Error erasing flash with vFlashErase packet"));
4448 do_cleanups (back_to
);
4452 remote_flash_write (struct target_ops
*ops
,
4453 ULONGEST address
, LONGEST length
,
4454 const gdb_byte
*data
)
4456 int saved_remote_timeout
= remote_timeout
;
4458 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4459 &saved_remote_timeout
);
4461 remote_timeout
= remote_flash_timeout
;
4462 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4463 do_cleanups (back_to
);
4469 remote_flash_done (struct target_ops
*ops
)
4471 int saved_remote_timeout
= remote_timeout
;
4473 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4474 &saved_remote_timeout
);
4476 remote_timeout
= remote_flash_timeout
;
4477 ret
= remote_send_printf ("vFlashDone");
4478 do_cleanups (back_to
);
4482 case PACKET_UNKNOWN
:
4483 error (_("Remote target does not support vFlashDone"));
4485 error (_("Error finishing flash operation"));
4492 remote_files_info (struct target_ops
*ignore
)
4494 puts_filtered ("Debugging a target over a serial line.\n");
4497 /* Stuff for dealing with the packets which are part of this protocol.
4498 See comment at top of file for details. */
4500 /* Read a single character from the remote end. */
4503 readchar (int timeout
)
4507 ch
= serial_readchar (remote_desc
, timeout
);
4512 switch ((enum serial_rc
) ch
)
4515 target_mourn_inferior ();
4516 error (_("Remote connection closed"));
4519 perror_with_name (_("Remote communication error"));
4521 case SERIAL_TIMEOUT
:
4527 /* Send the command in *BUF to the remote machine, and read the reply
4528 into *BUF. Report an error if we get an error reply. Resize
4529 *BUF using xrealloc if necessary to hold the result, and update
4533 remote_send (char **buf
,
4537 getpkt (buf
, sizeof_buf
, 0);
4539 if ((*buf
)[0] == 'E')
4540 error (_("Remote failure reply: %s"), *buf
);
4543 /* Display a null-terminated packet on stdout, for debugging, using C
4547 print_packet (char *buf
)
4549 puts_filtered ("\"");
4550 fputstr_filtered (buf
, '"', gdb_stdout
);
4551 puts_filtered ("\"");
4557 return putpkt_binary (buf
, strlen (buf
));
4560 /* Send a packet to the remote machine, with error checking. The data
4561 of the packet is in BUF. The string in BUF can be at most
4562 get_remote_packet_size () - 5 to account for the $, # and checksum,
4563 and for a possible /0 if we are debugging (remote_debug) and want
4564 to print the sent packet as a string. */
4567 putpkt_binary (char *buf
, int cnt
)
4570 unsigned char csum
= 0;
4571 char *buf2
= alloca (cnt
+ 6);
4577 /* Copy the packet into buffer BUF2, encapsulating it
4578 and giving it a checksum. */
4583 for (i
= 0; i
< cnt
; i
++)
4589 *p
++ = tohex ((csum
>> 4) & 0xf);
4590 *p
++ = tohex (csum
& 0xf);
4592 /* Send it over and over until we get a positive ack. */
4596 int started_error_output
= 0;
4601 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4602 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4603 fprintf_unfiltered (gdb_stdlog
, "...");
4604 gdb_flush (gdb_stdlog
);
4606 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4607 perror_with_name (_("putpkt: write failed"));
4609 /* Read until either a timeout occurs (-2) or '+' is read. */
4612 ch
= readchar (remote_timeout
);
4620 case SERIAL_TIMEOUT
:
4622 if (started_error_output
)
4624 putchar_unfiltered ('\n');
4625 started_error_output
= 0;
4634 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4638 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4639 case SERIAL_TIMEOUT
:
4643 break; /* Retransmit buffer. */
4647 fprintf_unfiltered (gdb_stdlog
,
4648 "Packet instead of Ack, ignoring it\n");
4649 /* It's probably an old response sent because an ACK
4650 was lost. Gobble up the packet and ack it so it
4651 doesn't get retransmitted when we resend this
4654 serial_write (remote_desc
, "+", 1);
4655 continue; /* Now, go look for +. */
4660 if (!started_error_output
)
4662 started_error_output
= 1;
4663 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4665 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4669 break; /* Here to retransmit. */
4673 /* This is wrong. If doing a long backtrace, the user should be
4674 able to get out next time we call QUIT, without anything as
4675 violent as interrupt_query. If we want to provide a way out of
4676 here without getting to the next QUIT, it should be based on
4677 hitting ^C twice as in remote_wait. */
4687 /* Come here after finding the start of a frame when we expected an
4688 ack. Do our best to discard the rest of this packet. */
4697 c
= readchar (remote_timeout
);
4700 case SERIAL_TIMEOUT
:
4701 /* Nothing we can do. */
4704 /* Discard the two bytes of checksum and stop. */
4705 c
= readchar (remote_timeout
);
4707 c
= readchar (remote_timeout
);
4710 case '*': /* Run length encoding. */
4711 /* Discard the repeat count. */
4712 c
= readchar (remote_timeout
);
4717 /* A regular character. */
4723 /* Come here after finding the start of the frame. Collect the rest
4724 into *BUF, verifying the checksum, length, and handling run-length
4725 compression. NUL terminate the buffer. If there is not enough room,
4726 expand *BUF using xrealloc.
4728 Returns -1 on error, number of characters in buffer (ignoring the
4729 trailing NULL) on success. (could be extended to return one of the
4730 SERIAL status indications). */
4733 read_frame (char **buf_p
,
4746 c
= readchar (remote_timeout
);
4749 case SERIAL_TIMEOUT
:
4751 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4755 fputs_filtered ("Saw new packet start in middle of old one\n",
4757 return -1; /* Start a new packet, count retries. */
4760 unsigned char pktcsum
;
4766 check_0
= readchar (remote_timeout
);
4768 check_1
= readchar (remote_timeout
);
4770 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4773 fputs_filtered ("Timeout in checksum, retrying\n",
4777 else if (check_0
< 0 || check_1
< 0)
4780 fputs_filtered ("Communication error in checksum\n",
4785 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4786 if (csum
== pktcsum
)
4791 fprintf_filtered (gdb_stdlog
,
4792 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4794 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4795 fputs_filtered ("\n", gdb_stdlog
);
4797 /* Number of characters in buffer ignoring trailing
4801 case '*': /* Run length encoding. */
4806 c
= readchar (remote_timeout
);
4808 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4810 /* The character before ``*'' is repeated. */
4812 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4814 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4816 /* Make some more room in the buffer. */
4817 *sizeof_buf
+= repeat
;
4818 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4822 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4828 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4832 if (bc
>= *sizeof_buf
- 1)
4834 /* Make some more room in the buffer. */
4836 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4847 /* Read a packet from the remote machine, with error checking, and
4848 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4849 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4850 rather than timing out; this is used (in synchronous mode) to wait
4851 for a target that is is executing user code to stop. */
4852 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4853 don't have to change all the calls to getpkt to deal with the
4854 return value, because at the moment I don't know what the right
4855 thing to do it for those. */
4863 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4867 /* Read a packet from the remote machine, with error checking, and
4868 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4869 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4870 rather than timing out; this is used (in synchronous mode) to wait
4871 for a target that is is executing user code to stop. If FOREVER ==
4872 0, this function is allowed to time out gracefully and return an
4873 indication of this to the caller. Otherwise return the number
4876 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4883 strcpy (*buf
, "timeout");
4887 timeout
= watchdog
> 0 ? watchdog
: -1;
4891 timeout
= remote_timeout
;
4895 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4897 /* This can loop forever if the remote side sends us characters
4898 continuously, but if it pauses, we'll get a zero from
4899 readchar because of timeout. Then we'll count that as a
4902 /* Note that we will only wait forever prior to the start of a
4903 packet. After that, we expect characters to arrive at a
4904 brisk pace. They should show up within remote_timeout
4909 c
= readchar (timeout
);
4911 if (c
== SERIAL_TIMEOUT
)
4913 if (forever
) /* Watchdog went off? Kill the target. */
4916 target_mourn_inferior ();
4917 error (_("Watchdog has expired. Target detached."));
4920 fputs_filtered ("Timed out.\n", gdb_stdlog
);
4926 /* We've found the start of a packet, now collect the data. */
4928 val
= read_frame (buf
, sizeof_buf
);
4934 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
4935 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
4936 fprintf_unfiltered (gdb_stdlog
, "\n");
4938 serial_write (remote_desc
, "+", 1);
4942 /* Try the whole thing again. */
4944 serial_write (remote_desc
, "-", 1);
4947 /* We have tried hard enough, and just can't receive the packet.
4950 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
4951 serial_write (remote_desc
, "+", 1);
4958 /* For some mysterious reason, wait_for_inferior calls kill instead of
4959 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4963 target_mourn_inferior ();
4967 /* Use catch_errors so the user can quit from gdb even when we aren't on
4968 speaking terms with the remote system. */
4969 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4971 /* Don't wait for it to die. I'm not really sure it matters whether
4972 we do or not. For the existing stubs, kill is a noop. */
4973 target_mourn_inferior ();
4976 /* Async version of remote_kill. */
4978 remote_async_kill (void)
4980 /* Unregister the file descriptor from the event loop. */
4981 if (target_is_async_p ())
4982 serial_async (remote_desc
, NULL
, 0);
4984 /* For some mysterious reason, wait_for_inferior calls kill instead of
4985 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4989 target_mourn_inferior ();
4993 /* Use catch_errors so the user can quit from gdb even when we
4994 aren't on speaking terms with the remote system. */
4995 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4997 /* Don't wait for it to die. I'm not really sure it matters whether
4998 we do or not. For the existing stubs, kill is a noop. */
4999 target_mourn_inferior ();
5005 remote_mourn_1 (&remote_ops
);
5009 remote_async_mourn (void)
5011 remote_mourn_1 (&remote_async_ops
);
5015 extended_remote_mourn (void)
5017 /* We do _not_ want to mourn the target like this; this will
5018 remove the extended remote target from the target stack,
5019 and the next time the user says "run" it'll fail.
5021 FIXME: What is the right thing to do here? */
5023 remote_mourn_1 (&extended_remote_ops
);
5027 /* Worker function for remote_mourn. */
5029 remote_mourn_1 (struct target_ops
*target
)
5031 unpush_target (target
);
5032 generic_mourn_inferior ();
5035 /* In the extended protocol we want to be able to do things like
5036 "run" and have them basically work as expected. So we need
5037 a special create_inferior function.
5039 FIXME: One day add support for changing the exec file
5040 we're debugging, arguments and an environment. */
5043 extended_remote_create_inferior (char *exec_file
, char *args
,
5044 char **env
, int from_tty
)
5046 /* Rip out the breakpoints; we'll reinsert them after restarting
5047 the remote server. */
5048 remove_breakpoints ();
5050 /* Now restart the remote server. */
5051 extended_remote_restart ();
5053 /* NOTE: We don't need to recheck for a target description here; but
5054 if we gain the ability to switch the remote executable we may
5055 need to, if for instance we are running a process which requested
5056 different emulated hardware from the operating system. A
5057 concrete example of this is ARM GNU/Linux, where some binaries
5058 will have a legacy FPA coprocessor emulated and others may have
5059 access to a hardware VFP unit. */
5061 /* Now put the breakpoints back in. This way we're safe if the
5062 restart function works via a unix fork on the remote side. */
5063 insert_breakpoints ();
5065 /* Clean up from the last time we were running. */
5066 clear_proceed_status ();
5069 /* Async version of extended_remote_create_inferior. */
5071 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5072 char **env
, int from_tty
)
5074 /* Rip out the breakpoints; we'll reinsert them after restarting
5075 the remote server. */
5076 remove_breakpoints ();
5078 /* If running asynchronously, register the target file descriptor
5079 with the event loop. */
5080 if (target_can_async_p ())
5081 target_async (inferior_event_handler
, 0);
5083 /* Now restart the remote server. */
5084 extended_remote_restart ();
5086 /* NOTE: We don't need to recheck for a target description here; but
5087 if we gain the ability to switch the remote executable we may
5088 need to, if for instance we are running a process which requested
5089 different emulated hardware from the operating system. A
5090 concrete example of this is ARM GNU/Linux, where some binaries
5091 will have a legacy FPA coprocessor emulated and others may have
5092 access to a hardware VFP unit. */
5094 /* Now put the breakpoints back in. This way we're safe if the
5095 restart function works via a unix fork on the remote side. */
5096 insert_breakpoints ();
5098 /* Clean up from the last time we were running. */
5099 clear_proceed_status ();
5103 /* Insert a breakpoint. On targets that have software breakpoint
5104 support, we ask the remote target to do the work; on targets
5105 which don't, we insert a traditional memory breakpoint. */
5108 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5110 CORE_ADDR addr
= bp_tgt
->placed_address
;
5111 struct remote_state
*rs
= get_remote_state ();
5113 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5114 If it succeeds, then set the support to PACKET_ENABLE. If it
5115 fails, and the user has explicitly requested the Z support then
5116 report an error, otherwise, mark it disabled and go on. */
5118 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5125 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5126 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5127 p
+= hexnumstr (p
, addr
);
5128 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5131 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5133 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5139 case PACKET_UNKNOWN
:
5144 return memory_insert_breakpoint (bp_tgt
);
5148 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5150 CORE_ADDR addr
= bp_tgt
->placed_address
;
5151 struct remote_state
*rs
= get_remote_state ();
5154 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5162 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5163 p
+= hexnumstr (p
, addr
);
5164 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5167 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5169 return (rs
->buf
[0] == 'E');
5172 return memory_remove_breakpoint (bp_tgt
);
5176 watchpoint_to_Z_packet (int type
)
5181 return Z_PACKET_WRITE_WP
;
5184 return Z_PACKET_READ_WP
;
5187 return Z_PACKET_ACCESS_WP
;
5190 internal_error (__FILE__
, __LINE__
,
5191 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5196 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5198 struct remote_state
*rs
= get_remote_state ();
5200 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5202 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5205 sprintf (rs
->buf
, "Z%x,", packet
);
5206 p
= strchr (rs
->buf
, '\0');
5207 addr
= remote_address_masked (addr
);
5208 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5209 sprintf (p
, ",%x", len
);
5212 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5214 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5217 case PACKET_UNKNOWN
:
5222 internal_error (__FILE__
, __LINE__
,
5223 _("remote_insert_watchpoint: reached end of function"));
5228 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5230 struct remote_state
*rs
= get_remote_state ();
5232 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5234 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5237 sprintf (rs
->buf
, "z%x,", packet
);
5238 p
= strchr (rs
->buf
, '\0');
5239 addr
= remote_address_masked (addr
);
5240 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5241 sprintf (p
, ",%x", len
);
5243 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5245 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5248 case PACKET_UNKNOWN
:
5253 internal_error (__FILE__
, __LINE__
,
5254 _("remote_remove_watchpoint: reached end of function"));
5258 int remote_hw_watchpoint_limit
= -1;
5259 int remote_hw_breakpoint_limit
= -1;
5262 remote_check_watch_resources (int type
, int cnt
, int ot
)
5264 if (type
== bp_hardware_breakpoint
)
5266 if (remote_hw_breakpoint_limit
== 0)
5268 else if (remote_hw_breakpoint_limit
< 0)
5270 else if (cnt
<= remote_hw_breakpoint_limit
)
5275 if (remote_hw_watchpoint_limit
== 0)
5277 else if (remote_hw_watchpoint_limit
< 0)
5281 else if (cnt
<= remote_hw_watchpoint_limit
)
5288 remote_stopped_by_watchpoint (void)
5290 return remote_stopped_by_watchpoint_p
;
5293 extern int stepped_after_stopped_by_watchpoint
;
5296 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5299 if (remote_stopped_by_watchpoint ()
5300 || stepped_after_stopped_by_watchpoint
)
5302 *addr_p
= remote_watch_data_address
;
5311 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5314 struct remote_state
*rs
= get_remote_state ();
5317 /* The length field should be set to the size of a breakpoint
5318 instruction, even though we aren't inserting one ourselves. */
5320 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5322 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5329 addr
= remote_address_masked (bp_tgt
->placed_address
);
5330 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5331 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5334 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5336 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5339 case PACKET_UNKNOWN
:
5344 internal_error (__FILE__
, __LINE__
,
5345 _("remote_insert_hw_breakpoint: reached end of function"));
5350 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5353 struct remote_state
*rs
= get_remote_state ();
5356 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5363 addr
= remote_address_masked (bp_tgt
->placed_address
);
5364 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5365 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5368 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5370 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5373 case PACKET_UNKNOWN
:
5378 internal_error (__FILE__
, __LINE__
,
5379 _("remote_remove_hw_breakpoint: reached end of function"));
5382 /* Some targets are only capable of doing downloads, and afterwards
5383 they switch to the remote serial protocol. This function provides
5384 a clean way to get from the download target to the remote target.
5385 It's basically just a wrapper so that we don't have to expose any
5386 of the internal workings of remote.c.
5388 Prior to calling this routine, you should shutdown the current
5389 target code, else you will get the "A program is being debugged
5390 already..." message. Usually a call to pop_target() suffices. */
5393 push_remote_target (char *name
, int from_tty
)
5395 printf_filtered (_("Switching to remote protocol\n"));
5396 remote_open (name
, from_tty
);
5399 /* Table used by the crc32 function to calcuate the checksum. */
5401 static unsigned long crc32_table
[256] =
5404 static unsigned long
5405 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5407 if (!crc32_table
[1])
5409 /* Initialize the CRC table and the decoding table. */
5413 for (i
= 0; i
< 256; i
++)
5415 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5416 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5423 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5429 /* compare-sections command
5431 With no arguments, compares each loadable section in the exec bfd
5432 with the same memory range on the target, and reports mismatches.
5433 Useful for verifying the image on the target against the exec file.
5434 Depends on the target understanding the new "qCRC:" request. */
5436 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5437 target method (target verify memory) and generic version of the
5438 actual command. This will allow other high-level code (especially
5439 generic_load()) to make use of this target functionality. */
5442 compare_sections_command (char *args
, int from_tty
)
5444 struct remote_state
*rs
= get_remote_state ();
5446 unsigned long host_crc
, target_crc
;
5447 extern bfd
*exec_bfd
;
5448 struct cleanup
*old_chain
;
5451 const char *sectname
;
5458 error (_("command cannot be used without an exec file"));
5459 if (!current_target
.to_shortname
||
5460 strcmp (current_target
.to_shortname
, "remote") != 0)
5461 error (_("command can only be used with remote target"));
5463 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5465 if (!(s
->flags
& SEC_LOAD
))
5466 continue; /* skip non-loadable section */
5468 size
= bfd_get_section_size (s
);
5470 continue; /* skip zero-length section */
5472 sectname
= bfd_get_section_name (exec_bfd
, s
);
5473 if (args
&& strcmp (args
, sectname
) != 0)
5474 continue; /* not the section selected by user */
5476 matched
= 1; /* do this section */
5478 /* FIXME: assumes lma can fit into long. */
5479 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5480 (long) lma
, (long) size
);
5483 /* Be clever; compute the host_crc before waiting for target
5485 sectdata
= xmalloc (size
);
5486 old_chain
= make_cleanup (xfree
, sectdata
);
5487 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5488 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5490 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5491 if (rs
->buf
[0] == 'E')
5492 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5493 sectname
, paddr (lma
), paddr (lma
+ size
));
5494 if (rs
->buf
[0] != 'C')
5495 error (_("remote target does not support this operation"));
5497 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5498 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5500 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5501 sectname
, paddr (lma
), paddr (lma
+ size
));
5502 if (host_crc
== target_crc
)
5503 printf_filtered ("matched.\n");
5506 printf_filtered ("MIS-MATCHED!\n");
5510 do_cleanups (old_chain
);
5513 warning (_("One or more sections of the remote executable does not match\n\
5514 the loaded file\n"));
5515 if (args
&& !matched
)
5516 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5519 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5520 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5521 number of bytes read is returned, or 0 for EOF, or -1 for error.
5522 The number of bytes read may be less than LEN without indicating an
5523 EOF. PACKET is checked and updated to indicate whether the remote
5524 target supports this object. */
5527 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5529 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5530 struct packet_config
*packet
)
5532 static char *finished_object
;
5533 static char *finished_annex
;
5534 static ULONGEST finished_offset
;
5536 struct remote_state
*rs
= get_remote_state ();
5537 unsigned int total
= 0;
5538 LONGEST i
, n
, packet_len
;
5540 if (packet
->support
== PACKET_DISABLE
)
5543 /* Check whether we've cached an end-of-object packet that matches
5545 if (finished_object
)
5547 if (strcmp (object_name
, finished_object
) == 0
5548 && strcmp (annex
? annex
: "", finished_annex
) == 0
5549 && offset
== finished_offset
)
5552 /* Otherwise, we're now reading something different. Discard
5554 xfree (finished_object
);
5555 xfree (finished_annex
);
5556 finished_object
= NULL
;
5557 finished_annex
= NULL
;
5560 /* Request only enough to fit in a single packet. The actual data
5561 may not, since we don't know how much of it will need to be escaped;
5562 the target is free to respond with slightly less data. We subtract
5563 five to account for the response type and the protocol frame. */
5564 n
= min (get_remote_packet_size () - 5, len
);
5565 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5566 object_name
, annex
? annex
: "",
5567 phex_nz (offset
, sizeof offset
),
5568 phex_nz (n
, sizeof n
));
5569 i
= putpkt (rs
->buf
);
5574 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5575 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5578 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5579 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5581 /* 'm' means there is (or at least might be) more data after this
5582 batch. That does not make sense unless there's at least one byte
5583 of data in this reply. */
5584 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5585 error (_("Remote qXfer reply contained no data."));
5587 /* Got some data. */
5588 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5590 /* 'l' is an EOF marker, possibly including a final block of data,
5591 or possibly empty. Record it to bypass the next read, if one is
5593 if (rs
->buf
[0] == 'l')
5595 finished_object
= xstrdup (object_name
);
5596 finished_annex
= xstrdup (annex
? annex
: "");
5597 finished_offset
= offset
+ i
;
5604 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5605 const char *annex
, gdb_byte
*readbuf
,
5606 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5608 struct remote_state
*rs
= get_remote_state ();
5613 /* Handle memory using the standard memory routines. */
5614 if (object
== TARGET_OBJECT_MEMORY
)
5619 if (writebuf
!= NULL
)
5620 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5622 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5626 else if (xfered
== 0 && errno
== 0)
5632 /* Only handle flash writes. */
5633 if (writebuf
!= NULL
)
5639 case TARGET_OBJECT_FLASH
:
5640 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5644 else if (xfered
== 0 && errno
== 0)
5654 /* Map pre-existing objects onto letters. DO NOT do this for new
5655 objects!!! Instead specify new query packets. */
5658 case TARGET_OBJECT_AVR
:
5662 case TARGET_OBJECT_AUXV
:
5663 gdb_assert (annex
== NULL
);
5664 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5665 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5667 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5668 return remote_read_qxfer
5669 (ops
, "features", annex
, readbuf
, offset
, len
,
5670 &remote_protocol_packets
[PACKET_qXfer_features
]);
5672 case TARGET_OBJECT_MEMORY_MAP
:
5673 gdb_assert (annex
== NULL
);
5674 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5675 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5681 /* Note: a zero OFFSET and LEN can be used to query the minimum
5683 if (offset
== 0 && len
== 0)
5684 return (get_remote_packet_size ());
5685 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5686 large enough let the caller deal with it. */
5687 if (len
< get_remote_packet_size ())
5689 len
= get_remote_packet_size ();
5691 /* Except for querying the minimum buffer size, target must be open. */
5693 error (_("remote query is only available after target open"));
5695 gdb_assert (annex
!= NULL
);
5696 gdb_assert (readbuf
!= NULL
);
5702 /* We used one buffer char for the remote protocol q command and
5703 another for the query type. As the remote protocol encapsulation
5704 uses 4 chars plus one extra in case we are debugging
5705 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5708 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5710 /* Bad caller may have sent forbidden characters. */
5711 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5716 gdb_assert (annex
[i
] == '\0');
5718 i
= putpkt (rs
->buf
);
5722 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5723 strcpy ((char *) readbuf
, rs
->buf
);
5725 return strlen ((char *) readbuf
);
5729 remote_rcmd (char *command
,
5730 struct ui_file
*outbuf
)
5732 struct remote_state
*rs
= get_remote_state ();
5736 error (_("remote rcmd is only available after target open"));
5738 /* Send a NULL command across as an empty command. */
5739 if (command
== NULL
)
5742 /* The query prefix. */
5743 strcpy (rs
->buf
, "qRcmd,");
5744 p
= strchr (rs
->buf
, '\0');
5746 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5747 error (_("\"monitor\" command ``%s'' is too long."), command
);
5749 /* Encode the actual command. */
5750 bin2hex ((gdb_byte
*) command
, p
, 0);
5752 if (putpkt (rs
->buf
) < 0)
5753 error (_("Communication problem with target."));
5755 /* get/display the response */
5760 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5762 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5765 error (_("Target does not support this command."));
5766 if (buf
[0] == 'O' && buf
[1] != 'K')
5768 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5771 if (strcmp (buf
, "OK") == 0)
5773 if (strlen (buf
) == 3 && buf
[0] == 'E'
5774 && isdigit (buf
[1]) && isdigit (buf
[2]))
5776 error (_("Protocol error with Rcmd"));
5778 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5780 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5781 fputc_unfiltered (c
, outbuf
);
5787 static VEC(mem_region_s
) *
5788 remote_memory_map (struct target_ops
*ops
)
5790 VEC(mem_region_s
) *result
= NULL
;
5791 char *text
= target_read_stralloc (¤t_target
,
5792 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5796 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5797 result
= parse_memory_map (text
);
5798 do_cleanups (back_to
);
5805 packet_command (char *args
, int from_tty
)
5807 struct remote_state
*rs
= get_remote_state ();
5810 error (_("command can only be used with remote target"));
5813 error (_("remote-packet command requires packet text as argument"));
5815 puts_filtered ("sending: ");
5816 print_packet (args
);
5817 puts_filtered ("\n");
5820 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5821 puts_filtered ("received: ");
5822 print_packet (rs
->buf
);
5823 puts_filtered ("\n");
5827 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5829 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5831 static void threadset_test_cmd (char *cmd
, int tty
);
5833 static void threadalive_test (char *cmd
, int tty
);
5835 static void threadlist_test_cmd (char *cmd
, int tty
);
5837 int get_and_display_threadinfo (threadref
*ref
);
5839 static void threadinfo_test_cmd (char *cmd
, int tty
);
5841 static int thread_display_step (threadref
*ref
, void *context
);
5843 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5845 static void init_remote_threadtests (void);
5847 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5850 threadset_test_cmd (char *cmd
, int tty
)
5852 int sample_thread
= SAMPLE_THREAD
;
5854 printf_filtered (_("Remote threadset test\n"));
5855 set_thread (sample_thread
, 1);
5860 threadalive_test (char *cmd
, int tty
)
5862 int sample_thread
= SAMPLE_THREAD
;
5864 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5865 printf_filtered ("PASS: Thread alive test\n");
5867 printf_filtered ("FAIL: Thread alive test\n");
5870 void output_threadid (char *title
, threadref
*ref
);
5873 output_threadid (char *title
, threadref
*ref
)
5877 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
5879 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
5883 threadlist_test_cmd (char *cmd
, int tty
)
5886 threadref nextthread
;
5887 int done
, result_count
;
5888 threadref threadlist
[3];
5890 printf_filtered ("Remote Threadlist test\n");
5891 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
5892 &result_count
, &threadlist
[0]))
5893 printf_filtered ("FAIL: threadlist test\n");
5896 threadref
*scan
= threadlist
;
5897 threadref
*limit
= scan
+ result_count
;
5899 while (scan
< limit
)
5900 output_threadid (" thread ", scan
++);
5905 display_thread_info (struct gdb_ext_thread_info
*info
)
5907 output_threadid ("Threadid: ", &info
->threadid
);
5908 printf_filtered ("Name: %s\n ", info
->shortname
);
5909 printf_filtered ("State: %s\n", info
->display
);
5910 printf_filtered ("other: %s\n\n", info
->more_display
);
5914 get_and_display_threadinfo (threadref
*ref
)
5918 struct gdb_ext_thread_info threadinfo
;
5920 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
5921 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
5922 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
5923 display_thread_info (&threadinfo
);
5928 threadinfo_test_cmd (char *cmd
, int tty
)
5930 int athread
= SAMPLE_THREAD
;
5934 int_to_threadref (&thread
, athread
);
5935 printf_filtered ("Remote Threadinfo test\n");
5936 if (!get_and_display_threadinfo (&thread
))
5937 printf_filtered ("FAIL cannot get thread info\n");
5941 thread_display_step (threadref
*ref
, void *context
)
5943 /* output_threadid(" threadstep ",ref); *//* simple test */
5944 return get_and_display_threadinfo (ref
);
5948 threadlist_update_test_cmd (char *cmd
, int tty
)
5950 printf_filtered ("Remote Threadlist update test\n");
5951 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
5955 init_remote_threadtests (void)
5957 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
5958 Fetch and print the remote list of thread identifiers, one pkt only"));
5959 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
5960 _("Fetch and display info about one thread"));
5961 add_com ("tset", class_obscure
, threadset_test_cmd
,
5962 _("Test setting to a different thread"));
5963 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
5964 _("Iterate through updating all remote thread info"));
5965 add_com ("talive", class_obscure
, threadalive_test
,
5966 _(" Remote thread alive test "));
5971 /* Convert a thread ID to a string. Returns the string in a static
5975 remote_pid_to_str (ptid_t ptid
)
5977 static char buf
[32];
5979 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
5983 /* Get the address of the thread local variable in OBJFILE which is
5984 stored at OFFSET within the thread local storage for thread PTID. */
5987 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
5989 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
5991 struct remote_state
*rs
= get_remote_state ();
5993 enum packet_result result
;
5995 strcpy (p
, "qGetTLSAddr:");
5997 p
+= hexnumstr (p
, PIDGET (ptid
));
5999 p
+= hexnumstr (p
, offset
);
6001 p
+= hexnumstr (p
, lm
);
6005 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6006 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6007 if (result
== PACKET_OK
)
6011 unpack_varlen_hex (rs
->buf
, &result
);
6014 else if (result
== PACKET_UNKNOWN
)
6015 throw_error (TLS_GENERIC_ERROR
,
6016 _("Remote target doesn't support qGetTLSAddr packet"));
6018 throw_error (TLS_GENERIC_ERROR
,
6019 _("Remote target failed to process qGetTLSAddr request"));
6022 throw_error (TLS_GENERIC_ERROR
,
6023 _("TLS not supported or disabled on this target"));
6028 /* Support for inferring a target description based on the current
6029 architecture and the size of a 'g' packet. While the 'g' packet
6030 can have any size (since optional registers can be left off the
6031 end), some sizes are easily recognizable given knowledge of the
6032 approximate architecture. */
6034 struct remote_g_packet_guess
6037 const struct target_desc
*tdesc
;
6039 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6040 DEF_VEC_O(remote_g_packet_guess_s
);
6042 struct remote_g_packet_data
6044 VEC(remote_g_packet_guess_s
) *guesses
;
6047 static struct gdbarch_data
*remote_g_packet_data_handle
;
6050 remote_g_packet_data_init (struct obstack
*obstack
)
6052 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6056 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6057 const struct target_desc
*tdesc
)
6059 struct remote_g_packet_data
*data
6060 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6061 struct remote_g_packet_guess new_guess
, *guess
;
6064 gdb_assert (tdesc
!= NULL
);
6067 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6069 if (guess
->bytes
== bytes
)
6070 internal_error (__FILE__
, __LINE__
,
6071 "Duplicate g packet description added for size %d",
6074 new_guess
.bytes
= bytes
;
6075 new_guess
.tdesc
= tdesc
;
6076 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6079 static const struct target_desc
*
6080 remote_read_description (struct target_ops
*target
)
6082 struct remote_g_packet_data
*data
6083 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6085 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6087 struct remote_g_packet_guess
*guess
;
6089 int bytes
= send_g_packet ();
6092 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6094 if (guess
->bytes
== bytes
)
6095 return guess
->tdesc
;
6097 /* We discard the g packet. A minor optimization would be to
6098 hold on to it, and fill the register cache once we have selected
6099 an architecture, but it's too tricky to do safely. */
6106 init_remote_ops (void)
6108 remote_ops
.to_shortname
= "remote";
6109 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6111 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6112 Specify the serial device it is connected to\n\
6113 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6114 remote_ops
.to_open
= remote_open
;
6115 remote_ops
.to_close
= remote_close
;
6116 remote_ops
.to_detach
= remote_detach
;
6117 remote_ops
.to_disconnect
= remote_disconnect
;
6118 remote_ops
.to_resume
= remote_resume
;
6119 remote_ops
.to_wait
= remote_wait
;
6120 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6121 remote_ops
.to_store_registers
= remote_store_registers
;
6122 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6123 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6124 remote_ops
.to_files_info
= remote_files_info
;
6125 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6126 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6127 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6128 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6129 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6130 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6131 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6132 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6133 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6134 remote_ops
.to_kill
= remote_kill
;
6135 remote_ops
.to_load
= generic_load
;
6136 remote_ops
.to_mourn_inferior
= remote_mourn
;
6137 remote_ops
.to_thread_alive
= remote_thread_alive
;
6138 remote_ops
.to_find_new_threads
= remote_threads_info
;
6139 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6140 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6141 remote_ops
.to_stop
= remote_stop
;
6142 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6143 remote_ops
.to_rcmd
= remote_rcmd
;
6144 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6145 remote_ops
.to_stratum
= process_stratum
;
6146 remote_ops
.to_has_all_memory
= 1;
6147 remote_ops
.to_has_memory
= 1;
6148 remote_ops
.to_has_stack
= 1;
6149 remote_ops
.to_has_registers
= 1;
6150 remote_ops
.to_has_execution
= 1;
6151 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6152 remote_ops
.to_magic
= OPS_MAGIC
;
6153 remote_ops
.to_memory_map
= remote_memory_map
;
6154 remote_ops
.to_flash_erase
= remote_flash_erase
;
6155 remote_ops
.to_flash_done
= remote_flash_done
;
6156 remote_ops
.to_read_description
= remote_read_description
;
6159 /* Set up the extended remote vector by making a copy of the standard
6160 remote vector and adding to it. */
6163 init_extended_remote_ops (void)
6165 extended_remote_ops
= remote_ops
;
6167 extended_remote_ops
.to_shortname
= "extended-remote";
6168 extended_remote_ops
.to_longname
=
6169 "Extended remote serial target in gdb-specific protocol";
6170 extended_remote_ops
.to_doc
=
6171 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6172 Specify the serial device it is connected to (e.g. /dev/ttya).",
6173 extended_remote_ops
.to_open
= extended_remote_open
;
6174 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6175 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6179 remote_can_async_p (void)
6181 /* We're async whenever the serial device is. */
6182 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6186 remote_is_async_p (void)
6188 /* We're async whenever the serial device is. */
6189 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6192 /* Pass the SERIAL event on and up to the client. One day this code
6193 will be able to delay notifying the client of an event until the
6194 point where an entire packet has been received. */
6196 static void (*async_client_callback
) (enum inferior_event_type event_type
,
6198 static void *async_client_context
;
6199 static serial_event_ftype remote_async_serial_handler
;
6202 remote_async_serial_handler (struct serial
*scb
, void *context
)
6204 /* Don't propogate error information up to the client. Instead let
6205 the client find out about the error by querying the target. */
6206 async_client_callback (INF_REG_EVENT
, async_client_context
);
6210 remote_async (void (*callback
) (enum inferior_event_type event_type
,
6211 void *context
), void *context
)
6213 if (current_target
.to_async_mask_value
== 0)
6214 internal_error (__FILE__
, __LINE__
,
6215 _("Calling remote_async when async is masked"));
6217 if (callback
!= NULL
)
6219 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
6220 async_client_callback
= callback
;
6221 async_client_context
= context
;
6224 serial_async (remote_desc
, NULL
, NULL
);
6227 /* Target async and target extended-async.
6229 This are temporary targets, until it is all tested. Eventually
6230 async support will be incorporated int the usual 'remote'
6234 init_remote_async_ops (void)
6236 remote_async_ops
.to_shortname
= "async";
6237 remote_async_ops
.to_longname
=
6238 "Remote serial target in async version of the gdb-specific protocol";
6239 remote_async_ops
.to_doc
=
6240 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6241 Specify the serial device it is connected to (e.g. /dev/ttya).";
6242 remote_async_ops
.to_open
= remote_async_open
;
6243 remote_async_ops
.to_close
= remote_close
;
6244 remote_async_ops
.to_detach
= remote_detach
;
6245 remote_async_ops
.to_disconnect
= remote_disconnect
;
6246 remote_async_ops
.to_resume
= remote_async_resume
;
6247 remote_async_ops
.to_wait
= remote_async_wait
;
6248 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
6249 remote_async_ops
.to_store_registers
= remote_store_registers
;
6250 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6251 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6252 remote_async_ops
.to_files_info
= remote_files_info
;
6253 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6254 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6255 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6256 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6257 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6258 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6259 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6260 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6261 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6262 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
6263 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
6264 remote_async_ops
.to_kill
= remote_async_kill
;
6265 remote_async_ops
.to_load
= generic_load
;
6266 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
6267 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
6268 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
6269 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
6270 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6271 remote_async_ops
.to_stop
= remote_stop
;
6272 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
6273 remote_async_ops
.to_rcmd
= remote_rcmd
;
6274 remote_async_ops
.to_stratum
= process_stratum
;
6275 remote_async_ops
.to_has_all_memory
= 1;
6276 remote_async_ops
.to_has_memory
= 1;
6277 remote_async_ops
.to_has_stack
= 1;
6278 remote_async_ops
.to_has_registers
= 1;
6279 remote_async_ops
.to_has_execution
= 1;
6280 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6281 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
6282 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
6283 remote_async_ops
.to_async
= remote_async
;
6284 remote_async_ops
.to_async_mask_value
= 1;
6285 remote_async_ops
.to_magic
= OPS_MAGIC
;
6286 remote_async_ops
.to_memory_map
= remote_memory_map
;
6287 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
6288 remote_async_ops
.to_flash_done
= remote_flash_done
;
6289 remote_ops
.to_read_description
= remote_read_description
;
6292 /* Set up the async extended remote vector by making a copy of the standard
6293 remote vector and adding to it. */
6296 init_extended_async_remote_ops (void)
6298 extended_async_remote_ops
= remote_async_ops
;
6300 extended_async_remote_ops
.to_shortname
= "extended-async";
6301 extended_async_remote_ops
.to_longname
=
6302 "Extended remote serial target in async gdb-specific protocol";
6303 extended_async_remote_ops
.to_doc
=
6304 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6305 Specify the serial device it is connected to (e.g. /dev/ttya).",
6306 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
6307 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
6308 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6312 set_remote_cmd (char *args
, int from_tty
)
6314 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
6318 show_remote_cmd (char *args
, int from_tty
)
6320 /* We can't just use cmd_show_list here, because we want to skip
6321 the redundant "show remote Z-packet" and the legacy aliases. */
6322 struct cleanup
*showlist_chain
;
6323 struct cmd_list_element
*list
= remote_show_cmdlist
;
6325 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
6326 for (; list
!= NULL
; list
= list
->next
)
6327 if (strcmp (list
->name
, "Z-packet") == 0)
6329 else if (list
->type
== not_set_cmd
)
6330 /* Alias commands are exactly like the original, except they
6331 don't have the normal type. */
6335 struct cleanup
*option_chain
6336 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
6337 ui_out_field_string (uiout
, "name", list
->name
);
6338 ui_out_text (uiout
, ": ");
6339 if (list
->type
== show_cmd
)
6340 do_setshow_command ((char *) NULL
, from_tty
, list
);
6342 cmd_func (list
, NULL
, from_tty
);
6343 /* Close the tuple. */
6344 do_cleanups (option_chain
);
6347 /* Close the tuple. */
6348 do_cleanups (showlist_chain
);
6352 build_remote_gdbarch_data (void)
6354 remote_address_size
= TARGET_ADDR_BIT
;
6357 /* Function to be called whenever a new objfile (shlib) is detected. */
6359 remote_new_objfile (struct objfile
*objfile
)
6361 if (remote_desc
!= 0) /* Have a remote connection. */
6362 remote_check_symbols (objfile
);
6366 _initialize_remote (void)
6368 struct remote_state
*rs
;
6370 /* architecture specific data */
6371 remote_gdbarch_data_handle
=
6372 gdbarch_data_register_post_init (init_remote_state
);
6373 remote_g_packet_data_handle
=
6374 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
6376 /* Old tacky stuff. NOTE: This comes after the remote protocol so
6377 that the remote protocol has been initialized. */
6378 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size
);
6379 deprecated_register_gdbarch_swap (NULL
, 0, build_remote_gdbarch_data
);
6381 /* Initialize the per-target state. At the moment there is only one
6382 of these, not one per target. Only one target is active at a
6383 time. The default buffer size is unimportant; it will be expanded
6384 whenever a larger buffer is needed. */
6385 rs
= get_remote_state_raw ();
6387 rs
->buf
= xmalloc (rs
->buf_size
);
6390 add_target (&remote_ops
);
6392 init_extended_remote_ops ();
6393 add_target (&extended_remote_ops
);
6395 init_remote_async_ops ();
6396 add_target (&remote_async_ops
);
6398 init_extended_async_remote_ops ();
6399 add_target (&extended_async_remote_ops
);
6401 /* Hook into new objfile notification. */
6402 observer_attach_new_objfile (remote_new_objfile
);
6405 init_remote_threadtests ();
6408 /* set/show remote ... */
6410 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
6411 Remote protocol specific variables\n\
6412 Configure various remote-protocol specific variables such as\n\
6413 the packets being used"),
6414 &remote_set_cmdlist
, "set remote ",
6415 0 /* allow-unknown */, &setlist
);
6416 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
6417 Remote protocol specific variables\n\
6418 Configure various remote-protocol specific variables such as\n\
6419 the packets being used"),
6420 &remote_show_cmdlist
, "show remote ",
6421 0 /* allow-unknown */, &showlist
);
6423 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
6424 Compare section data on target to the exec file.\n\
6425 Argument is a single section name (default: all loaded sections)."),
6428 add_cmd ("packet", class_maintenance
, packet_command
, _("\
6429 Send an arbitrary packet to a remote target.\n\
6430 maintenance packet TEXT\n\
6431 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6432 this command sends the string TEXT to the inferior, and displays the\n\
6433 response packet. GDB supplies the initial `$' character, and the\n\
6434 terminating `#' character and checksum."),
6437 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
6438 Set whether to send break if interrupted."), _("\
6439 Show whether to send break if interrupted."), _("\
6440 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6441 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6442 &setlist
, &showlist
);
6444 /* Install commands for configuring memory read/write packets. */
6446 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
6447 Set the maximum number of bytes per memory write packet (deprecated)."),
6449 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
6450 Show the maximum number of bytes per memory write packet (deprecated)."),
6452 add_cmd ("memory-write-packet-size", no_class
,
6453 set_memory_write_packet_size
, _("\
6454 Set the maximum number of bytes per memory-write packet.\n\
6455 Specify the number of bytes in a packet or 0 (zero) for the\n\
6456 default packet size. The actual limit is further reduced\n\
6457 dependent on the target. Specify ``fixed'' to disable the\n\
6458 further restriction and ``limit'' to enable that restriction."),
6459 &remote_set_cmdlist
);
6460 add_cmd ("memory-read-packet-size", no_class
,
6461 set_memory_read_packet_size
, _("\
6462 Set the maximum number of bytes per memory-read packet.\n\
6463 Specify the number of bytes in a packet or 0 (zero) for the\n\
6464 default packet size. The actual limit is further reduced\n\
6465 dependent on the target. Specify ``fixed'' to disable the\n\
6466 further restriction and ``limit'' to enable that restriction."),
6467 &remote_set_cmdlist
);
6468 add_cmd ("memory-write-packet-size", no_class
,
6469 show_memory_write_packet_size
,
6470 _("Show the maximum number of bytes per memory-write packet."),
6471 &remote_show_cmdlist
);
6472 add_cmd ("memory-read-packet-size", no_class
,
6473 show_memory_read_packet_size
,
6474 _("Show the maximum number of bytes per memory-read packet."),
6475 &remote_show_cmdlist
);
6477 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6478 &remote_hw_watchpoint_limit
, _("\
6479 Set the maximum number of target hardware watchpoints."), _("\
6480 Show the maximum number of target hardware watchpoints."), _("\
6481 Specify a negative limit for unlimited."),
6482 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6483 &remote_set_cmdlist
, &remote_show_cmdlist
);
6484 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6485 &remote_hw_breakpoint_limit
, _("\
6486 Set the maximum number of target hardware breakpoints."), _("\
6487 Show the maximum number of target hardware breakpoints."), _("\
6488 Specify a negative limit for unlimited."),
6489 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6490 &remote_set_cmdlist
, &remote_show_cmdlist
);
6492 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6493 &remote_address_size
, _("\
6494 Set the maximum size of the address (in bits) in a memory packet."), _("\
6495 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6497 NULL
, /* FIXME: i18n: */
6498 &setlist
, &showlist
);
6500 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6501 "X", "binary-download", 1);
6503 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6504 "vCont", "verbose-resume", 0);
6506 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
6507 "QPassSignals", "pass-signals", 0);
6509 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6510 "qSymbol", "symbol-lookup", 0);
6512 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6513 "P", "set-register", 1);
6515 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6516 "p", "fetch-register", 1);
6518 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6519 "Z0", "software-breakpoint", 0);
6521 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6522 "Z1", "hardware-breakpoint", 0);
6524 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6525 "Z2", "write-watchpoint", 0);
6527 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6528 "Z3", "read-watchpoint", 0);
6530 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6531 "Z4", "access-watchpoint", 0);
6533 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6534 "qXfer:auxv:read", "read-aux-vector", 0);
6536 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
6537 "qXfer:features:read", "target-features", 0);
6539 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
6540 "qXfer:memory-map:read", "memory-map", 0);
6542 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6543 "qGetTLSAddr", "get-thread-local-storage-address",
6546 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6547 "qSupported", "supported-packets", 0);
6549 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6550 Z sub-packet has its own set and show commands, but users may
6551 have sets to this variable in their .gdbinit files (or in their
6553 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6554 &remote_Z_packet_detect
, _("\
6555 Set use of remote protocol `Z' packets"), _("\
6556 Show use of remote protocol `Z' packets "), _("\
6557 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6559 set_remote_protocol_Z_packet_cmd
,
6560 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6561 &remote_set_cmdlist
, &remote_show_cmdlist
);
6563 /* Eventually initialize fileio. See fileio.c */
6564 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);