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 (void);
94 static void remote_fetch_registers (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 (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; == REGISTER_NAME (regnum); at present. */
266 struct remote_arch_state
268 /* Description of the remote protocol registers. */
269 long sizeof_g_packet
;
271 /* Description of the remote protocol registers indexed by REGNUM
272 (making an array NUM_REGS in size). */
273 struct packet_reg
*regs
;
275 /* This is the size (in chars) of the first response to the ``g''
276 packet. It is used as a heuristic when determining the maximum
277 size of memory-read and memory-write packets. A target will
278 typically only reserve a buffer large enough to hold the ``g''
279 packet. The size does not include packet overhead (headers and
281 long actual_register_packet_size
;
283 /* This is the maximum size (in chars) of a non read/write packet.
284 It is also used as a cap on the size of read/write packets. */
285 long remote_packet_size
;
289 /* Handle for retreving the remote protocol data from gdbarch. */
290 static struct gdbarch_data
*remote_gdbarch_data_handle
;
292 static struct remote_arch_state
*
293 get_remote_arch_state (void)
295 return gdbarch_data (current_gdbarch
, remote_gdbarch_data_handle
);
298 /* Fetch the global remote target state. */
300 static struct remote_state
*
301 get_remote_state (void)
303 /* Make sure that the remote architecture state has been
304 initialized, because doing so might reallocate rs->buf. Any
305 function which calls getpkt also needs to be mindful of changes
306 to rs->buf, but this call limits the number of places which run
308 get_remote_arch_state ();
310 return get_remote_state_raw ();
314 compare_pnums (const void *lhs_
, const void *rhs_
)
316 const struct packet_reg
* const *lhs
= lhs_
;
317 const struct packet_reg
* const *rhs
= rhs_
;
319 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
321 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
328 init_remote_state (struct gdbarch
*gdbarch
)
330 int regnum
, num_remote_regs
, offset
;
331 struct remote_state
*rs
= get_remote_state_raw ();
332 struct remote_arch_state
*rsa
;
333 struct packet_reg
**remote_regs
;
335 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
337 /* Use the architecture to build a regnum<->pnum table, which will be
338 1:1 unless a feature set specifies otherwise. */
339 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
, NUM_REGS
, struct packet_reg
);
340 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
342 struct packet_reg
*r
= &rsa
->regs
[regnum
];
343 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
347 /* Define the g/G packet format as the contents of each register
348 with a remote protocol number, in order of ascending protocol
351 remote_regs
= alloca (NUM_REGS
* sizeof (struct packet_reg
*));
352 for (num_remote_regs
= 0, regnum
= 0; regnum
< NUM_REGS
; regnum
++)
353 if (rsa
->regs
[regnum
].pnum
!= -1)
354 remote_regs
[num_remote_regs
++] = &rsa
->regs
[regnum
];
356 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
359 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
361 remote_regs
[regnum
]->in_g_packet
= 1;
362 remote_regs
[regnum
]->offset
= offset
;
363 offset
+= register_size (current_gdbarch
, remote_regs
[regnum
]->regnum
);
366 /* Record the maximum possible size of the g packet - it may turn out
368 rsa
->sizeof_g_packet
= offset
;
370 /* Default maximum number of characters in a packet body. Many
371 remote stubs have a hardwired buffer size of 400 bytes
372 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
373 as the maximum packet-size to ensure that the packet and an extra
374 NUL character can always fit in the buffer. This stops GDB
375 trashing stubs that try to squeeze an extra NUL into what is
376 already a full buffer (As of 1999-12-04 that was most stubs). */
377 rsa
->remote_packet_size
= 400 - 1;
379 /* This one is filled in when a ``g'' packet is received. */
380 rsa
->actual_register_packet_size
= 0;
382 /* Should rsa->sizeof_g_packet needs more space than the
383 default, adjust the size accordingly. Remember that each byte is
384 encoded as two characters. 32 is the overhead for the packet
385 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
386 (``$NN:G...#NN'') is a better guess, the below has been padded a
388 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
389 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
391 /* Make sure that the packet buffer is plenty big enough for
392 this architecture. */
393 if (rs
->buf_size
< rsa
->remote_packet_size
)
395 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
396 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
402 /* Return the current allowed size of a remote packet. This is
403 inferred from the current architecture, and should be used to
404 limit the length of outgoing packets. */
406 get_remote_packet_size (void)
408 struct remote_state
*rs
= get_remote_state ();
409 struct remote_arch_state
*rsa
= get_remote_arch_state ();
411 if (rs
->explicit_packet_size
)
412 return rs
->explicit_packet_size
;
414 return rsa
->remote_packet_size
;
417 static struct packet_reg
*
418 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
420 if (regnum
< 0 && regnum
>= NUM_REGS
)
424 struct packet_reg
*r
= &rsa
->regs
[regnum
];
425 gdb_assert (r
->regnum
== regnum
);
430 static struct packet_reg
*
431 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
434 for (i
= 0; i
< NUM_REGS
; i
++)
436 struct packet_reg
*r
= &rsa
->regs
[i
];
443 /* FIXME: graces/2002-08-08: These variables should eventually be
444 bound to an instance of the target object (as in gdbarch-tdep()),
445 when such a thing exists. */
447 /* This is set to the data address of the access causing the target
448 to stop for a watchpoint. */
449 static CORE_ADDR remote_watch_data_address
;
451 /* This is non-zero if target stopped for a watchpoint. */
452 static int remote_stopped_by_watchpoint_p
;
454 static struct target_ops remote_ops
;
456 static struct target_ops extended_remote_ops
;
458 /* Temporary target ops. Just like the remote_ops and
459 extended_remote_ops, but with asynchronous support. */
460 static struct target_ops remote_async_ops
;
462 static struct target_ops extended_async_remote_ops
;
464 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
465 ``forever'' still use the normal timeout mechanism. This is
466 currently used by the ASYNC code to guarentee that target reads
467 during the initial connect always time-out. Once getpkt has been
468 modified to return a timeout indication and, in turn
469 remote_wait()/wait_for_inferior() have gained a timeout parameter
471 static int wait_forever_enabled_p
= 1;
474 /* This variable chooses whether to send a ^C or a break when the user
475 requests program interruption. Although ^C is usually what remote
476 systems expect, and that is the default here, sometimes a break is
477 preferable instead. */
479 static int remote_break
;
481 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
482 remote_open knows that we don't have a file open when the program
484 static struct serial
*remote_desc
= NULL
;
486 /* This variable sets the number of bits in an address that are to be
487 sent in a memory ("M" or "m") packet. Normally, after stripping
488 leading zeros, the entire address would be sent. This variable
489 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
490 initial implementation of remote.c restricted the address sent in
491 memory packets to ``host::sizeof long'' bytes - (typically 32
492 bits). Consequently, for 64 bit targets, the upper 32 bits of an
493 address was never sent. Since fixing this bug may cause a break in
494 some remote targets this variable is principly provided to
495 facilitate backward compatibility. */
497 static int remote_address_size
;
499 /* Tempoary to track who currently owns the terminal. See
500 target_async_terminal_* for more details. */
502 static int remote_async_terminal_ours_p
;
505 /* User configurable variables for the number of characters in a
506 memory read/write packet. MIN (rsa->remote_packet_size,
507 rsa->sizeof_g_packet) is the default. Some targets need smaller
508 values (fifo overruns, et.al.) and some users need larger values
509 (speed up transfers). The variables ``preferred_*'' (the user
510 request), ``current_*'' (what was actually set) and ``forced_*''
511 (Positive - a soft limit, negative - a hard limit). */
513 struct memory_packet_config
520 /* Compute the current size of a read/write packet. Since this makes
521 use of ``actual_register_packet_size'' the computation is dynamic. */
524 get_memory_packet_size (struct memory_packet_config
*config
)
526 struct remote_state
*rs
= get_remote_state ();
527 struct remote_arch_state
*rsa
= get_remote_arch_state ();
529 /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
530 law?) that some hosts don't cope very well with large alloca()
531 calls. Eventually the alloca() code will be replaced by calls to
532 xmalloc() and make_cleanups() allowing this restriction to either
533 be lifted or removed. */
534 #ifndef MAX_REMOTE_PACKET_SIZE
535 #define MAX_REMOTE_PACKET_SIZE 16384
537 /* NOTE: 20 ensures we can write at least one byte. */
538 #ifndef MIN_REMOTE_PACKET_SIZE
539 #define MIN_REMOTE_PACKET_SIZE 20
544 if (config
->size
<= 0)
545 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
547 what_they_get
= config
->size
;
551 what_they_get
= get_remote_packet_size ();
552 /* Limit the packet to the size specified by the user. */
554 && what_they_get
> config
->size
)
555 what_they_get
= config
->size
;
557 /* Limit it to the size of the targets ``g'' response unless we have
558 permission from the stub to use a larger packet size. */
559 if (rs
->explicit_packet_size
== 0
560 && rsa
->actual_register_packet_size
> 0
561 && what_they_get
> rsa
->actual_register_packet_size
)
562 what_they_get
= rsa
->actual_register_packet_size
;
564 if (what_they_get
> MAX_REMOTE_PACKET_SIZE
)
565 what_they_get
= MAX_REMOTE_PACKET_SIZE
;
566 if (what_they_get
< MIN_REMOTE_PACKET_SIZE
)
567 what_they_get
= MIN_REMOTE_PACKET_SIZE
;
569 /* Make sure there is room in the global buffer for this packet
570 (including its trailing NUL byte). */
571 if (rs
->buf_size
< what_they_get
+ 1)
573 rs
->buf_size
= 2 * what_they_get
;
574 rs
->buf
= xrealloc (rs
->buf
, 2 * what_they_get
);
577 return what_they_get
;
580 /* Update the size of a read/write packet. If they user wants
581 something really big then do a sanity check. */
584 set_memory_packet_size (char *args
, struct memory_packet_config
*config
)
586 int fixed_p
= config
->fixed_p
;
587 long size
= config
->size
;
589 error (_("Argument required (integer, `fixed' or `limited')."));
590 else if (strcmp (args
, "hard") == 0
591 || strcmp (args
, "fixed") == 0)
593 else if (strcmp (args
, "soft") == 0
594 || strcmp (args
, "limit") == 0)
599 size
= strtoul (args
, &end
, 0);
601 error (_("Invalid %s (bad syntax)."), config
->name
);
603 /* Instead of explicitly capping the size of a packet to
604 MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
605 instead allowed to set the size to something arbitrarily
607 if (size
> MAX_REMOTE_PACKET_SIZE
)
608 error (_("Invalid %s (too large)."), config
->name
);
612 if (fixed_p
&& !config
->fixed_p
)
614 if (! query (_("The target may not be able to correctly handle a %s\n"
615 "of %ld bytes. Change the packet size? "),
617 error (_("Packet size not changed."));
619 /* Update the config. */
620 config
->fixed_p
= fixed_p
;
625 show_memory_packet_size (struct memory_packet_config
*config
)
627 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
629 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
630 get_memory_packet_size (config
));
632 printf_filtered (_("Packets are limited to %ld bytes.\n"),
633 get_memory_packet_size (config
));
636 static struct memory_packet_config memory_write_packet_config
=
638 "memory-write-packet-size",
642 set_memory_write_packet_size (char *args
, int from_tty
)
644 set_memory_packet_size (args
, &memory_write_packet_config
);
648 show_memory_write_packet_size (char *args
, int from_tty
)
650 show_memory_packet_size (&memory_write_packet_config
);
654 get_memory_write_packet_size (void)
656 return get_memory_packet_size (&memory_write_packet_config
);
659 static struct memory_packet_config memory_read_packet_config
=
661 "memory-read-packet-size",
665 set_memory_read_packet_size (char *args
, int from_tty
)
667 set_memory_packet_size (args
, &memory_read_packet_config
);
671 show_memory_read_packet_size (char *args
, int from_tty
)
673 show_memory_packet_size (&memory_read_packet_config
);
677 get_memory_read_packet_size (void)
679 long size
= get_memory_packet_size (&memory_read_packet_config
);
680 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
681 extra buffer size argument before the memory read size can be
682 increased beyond this. */
683 if (size
> get_remote_packet_size ())
684 size
= get_remote_packet_size ();
689 /* Generic configuration support for packets the stub optionally
690 supports. Allows the user to specify the use of the packet as well
691 as allowing GDB to auto-detect support in the remote stub. */
695 PACKET_SUPPORT_UNKNOWN
= 0,
704 enum auto_boolean detect
;
705 enum packet_support support
;
708 /* Analyze a packet's return value and update the packet config
719 update_packet_config (struct packet_config
*config
)
721 switch (config
->detect
)
723 case AUTO_BOOLEAN_TRUE
:
724 config
->support
= PACKET_ENABLE
;
726 case AUTO_BOOLEAN_FALSE
:
727 config
->support
= PACKET_DISABLE
;
729 case AUTO_BOOLEAN_AUTO
:
730 config
->support
= PACKET_SUPPORT_UNKNOWN
;
736 show_packet_config_cmd (struct packet_config
*config
)
738 char *support
= "internal-error";
739 switch (config
->support
)
745 support
= "disabled";
747 case PACKET_SUPPORT_UNKNOWN
:
751 switch (config
->detect
)
753 case AUTO_BOOLEAN_AUTO
:
754 printf_filtered (_("Support for the `%s' packet is auto-detected, currently %s.\n"),
755 config
->name
, support
);
757 case AUTO_BOOLEAN_TRUE
:
758 case AUTO_BOOLEAN_FALSE
:
759 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
760 config
->name
, support
);
766 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
767 const char *title
, int legacy
)
774 config
->title
= title
;
775 config
->detect
= AUTO_BOOLEAN_AUTO
;
776 config
->support
= PACKET_SUPPORT_UNKNOWN
;
777 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
779 show_doc
= xstrprintf ("Show current use of remote protocol `%s' (%s) packet",
781 /* set/show TITLE-packet {auto,on,off} */
782 cmd_name
= xstrprintf ("%s-packet", title
);
783 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
784 &config
->detect
, set_doc
, show_doc
, NULL
, /* help_doc */
785 set_remote_protocol_packet_cmd
,
786 show_remote_protocol_packet_cmd
,
787 &remote_set_cmdlist
, &remote_show_cmdlist
);
788 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
792 legacy_name
= xstrprintf ("%s-packet", name
);
793 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
794 &remote_set_cmdlist
);
795 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
796 &remote_show_cmdlist
);
800 static enum packet_result
801 packet_check_result (const char *buf
)
805 /* The stub recognized the packet request. Check that the
806 operation succeeded. */
808 && isxdigit (buf
[1]) && isxdigit (buf
[2])
810 /* "Enn" - definitly an error. */
813 /* Always treat "E." as an error. This will be used for
814 more verbose error messages, such as E.memtypes. */
815 if (buf
[0] == 'E' && buf
[1] == '.')
818 /* The packet may or may not be OK. Just assume it is. */
822 /* The stub does not support the packet. */
823 return PACKET_UNKNOWN
;
826 static enum packet_result
827 packet_ok (const char *buf
, struct packet_config
*config
)
829 enum packet_result result
;
831 result
= packet_check_result (buf
);
836 /* The stub recognized the packet request. */
837 switch (config
->support
)
839 case PACKET_SUPPORT_UNKNOWN
:
841 fprintf_unfiltered (gdb_stdlog
,
842 "Packet %s (%s) is supported\n",
843 config
->name
, config
->title
);
844 config
->support
= PACKET_ENABLE
;
847 internal_error (__FILE__
, __LINE__
,
848 _("packet_ok: attempt to use a disabled packet"));
855 /* The stub does not support the packet. */
856 switch (config
->support
)
859 if (config
->detect
== AUTO_BOOLEAN_AUTO
)
860 /* If the stub previously indicated that the packet was
861 supported then there is a protocol error.. */
862 error (_("Protocol error: %s (%s) conflicting enabled responses."),
863 config
->name
, config
->title
);
865 /* The user set it wrong. */
866 error (_("Enabled packet %s (%s) not recognized by stub"),
867 config
->name
, config
->title
);
869 case PACKET_SUPPORT_UNKNOWN
:
871 fprintf_unfiltered (gdb_stdlog
,
872 "Packet %s (%s) is NOT supported\n",
873 config
->name
, config
->title
);
874 config
->support
= PACKET_DISABLE
;
897 PACKET_qXfer_features
,
898 PACKET_qXfer_memory_map
,
905 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
908 set_remote_protocol_packet_cmd (char *args
, int from_tty
,
909 struct cmd_list_element
*c
)
911 struct packet_config
*packet
;
913 for (packet
= remote_protocol_packets
;
914 packet
< &remote_protocol_packets
[PACKET_MAX
];
917 if (&packet
->detect
== c
->var
)
919 update_packet_config (packet
);
923 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
928 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
929 struct cmd_list_element
*c
,
932 struct packet_config
*packet
;
934 for (packet
= remote_protocol_packets
;
935 packet
< &remote_protocol_packets
[PACKET_MAX
];
938 if (&packet
->detect
== c
->var
)
940 show_packet_config_cmd (packet
);
944 internal_error (__FILE__
, __LINE__
, "Could not find config for %s",
948 /* Should we try one of the 'Z' requests? */
952 Z_PACKET_SOFTWARE_BP
,
953 Z_PACKET_HARDWARE_BP
,
960 /* For compatibility with older distributions. Provide a ``set remote
961 Z-packet ...'' command that updates all the Z packet types. */
963 static enum auto_boolean remote_Z_packet_detect
;
966 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
967 struct cmd_list_element
*c
)
970 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
972 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
973 update_packet_config (&remote_protocol_packets
[PACKET_Z0
+ i
]);
978 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
979 struct cmd_list_element
*c
,
983 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
985 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
989 /* Should we try the 'ThreadInfo' query packet?
991 This variable (NOT available to the user: auto-detect only!)
992 determines whether GDB will use the new, simpler "ThreadInfo"
993 query or the older, more complex syntax for thread queries.
994 This is an auto-detect variable (set to true at each connect,
995 and set to false when the target fails to recognize it). */
997 static int use_threadinfo_query
;
998 static int use_threadextra_query
;
1000 /* Tokens for use by the asynchronous signal handlers for SIGINT. */
1001 static struct async_signal_handler
*sigint_remote_twice_token
;
1002 static struct async_signal_handler
*sigint_remote_token
;
1004 /* These are pointers to hook functions that may be set in order to
1005 modify resume/wait behavior for a particular architecture. */
1007 void (*deprecated_target_resume_hook
) (void);
1008 void (*deprecated_target_wait_loop_hook
) (void);
1012 /* These are the threads which we last sent to the remote system.
1013 -1 for all or -2 for not sent yet. */
1014 static int general_thread
;
1015 static int continue_thread
;
1017 /* Call this function as a result of
1018 1) A halt indication (T packet) containing a thread id
1019 2) A direct query of currthread
1020 3) Successful execution of set thread
1024 record_currthread (int currthread
)
1026 general_thread
= currthread
;
1028 /* If this is a new thread, add it to GDB's thread list.
1029 If we leave it up to WFI to do this, bad things will happen. */
1030 if (!in_thread_list (pid_to_ptid (currthread
)))
1032 add_thread (pid_to_ptid (currthread
));
1033 ui_out_text (uiout
, "[New ");
1034 ui_out_text (uiout
, target_pid_to_str (pid_to_ptid (currthread
)));
1035 ui_out_text (uiout
, "]\n");
1039 static char *last_pass_packet
;
1041 /* If 'QPassSignals' is supported, tell the remote stub what signals
1042 it can simply pass through to the inferior without reporting. */
1045 remote_pass_signals (void)
1047 if (remote_protocol_packets
[PACKET_QPassSignals
].support
!= PACKET_DISABLE
)
1049 char *pass_packet
, *p
;
1050 int numsigs
= (int) TARGET_SIGNAL_LAST
;
1053 gdb_assert (numsigs
< 256);
1054 for (i
= 0; i
< numsigs
; i
++)
1056 if (signal_stop_state (i
) == 0
1057 && signal_print_state (i
) == 0
1058 && signal_pass_state (i
) == 1)
1061 pass_packet
= xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
1062 strcpy (pass_packet
, "QPassSignals:");
1063 p
= pass_packet
+ strlen (pass_packet
);
1064 for (i
= 0; i
< numsigs
; i
++)
1066 if (signal_stop_state (i
) == 0
1067 && signal_print_state (i
) == 0
1068 && signal_pass_state (i
) == 1)
1071 *p
++ = tohex (i
>> 4);
1072 *p
++ = tohex (i
& 15);
1081 if (!last_pass_packet
|| strcmp (last_pass_packet
, pass_packet
))
1083 struct remote_state
*rs
= get_remote_state ();
1084 char *buf
= rs
->buf
;
1086 putpkt (pass_packet
);
1087 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1088 packet_ok (buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
1089 if (last_pass_packet
)
1090 xfree (last_pass_packet
);
1091 last_pass_packet
= pass_packet
;
1094 xfree (pass_packet
);
1098 #define MAGIC_NULL_PID 42000
1101 set_thread (int th
, int gen
)
1103 struct remote_state
*rs
= get_remote_state ();
1104 char *buf
= rs
->buf
;
1105 int state
= gen
? general_thread
: continue_thread
;
1111 buf
[1] = gen
? 'g' : 'c';
1112 if (th
== MAGIC_NULL_PID
)
1118 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "-%x", -th
);
1120 xsnprintf (&buf
[2], get_remote_packet_size () - 2, "%x", th
);
1122 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1124 general_thread
= th
;
1126 continue_thread
= th
;
1129 /* Return nonzero if the thread TH is still alive on the remote system. */
1132 remote_thread_alive (ptid_t ptid
)
1134 struct remote_state
*rs
= get_remote_state ();
1135 int tid
= PIDGET (ptid
);
1138 xsnprintf (rs
->buf
, get_remote_packet_size (), "T-%08x", -tid
);
1140 xsnprintf (rs
->buf
, get_remote_packet_size (), "T%08x", tid
);
1142 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1143 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
1146 /* About these extended threadlist and threadinfo packets. They are
1147 variable length packets but, the fields within them are often fixed
1148 length. They are redundent enough to send over UDP as is the
1149 remote protocol in general. There is a matching unit test module
1152 #define OPAQUETHREADBYTES 8
1154 /* a 64 bit opaque identifier */
1155 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
1157 /* WARNING: This threadref data structure comes from the remote O.S.,
1158 libstub protocol encoding, and remote.c. it is not particularly
1161 /* Right now, the internal structure is int. We want it to be bigger.
1165 typedef int gdb_threadref
; /* Internal GDB thread reference. */
1167 /* gdb_ext_thread_info is an internal GDB data structure which is
1168 equivalent to the reply of the remote threadinfo packet. */
1170 struct gdb_ext_thread_info
1172 threadref threadid
; /* External form of thread reference. */
1173 int active
; /* Has state interesting to GDB?
1175 char display
[256]; /* Brief state display, name,
1176 blocked/suspended. */
1177 char shortname
[32]; /* To be used to name threads. */
1178 char more_display
[256]; /* Long info, statistics, queue depth,
1182 /* The volume of remote transfers can be limited by submitting
1183 a mask containing bits specifying the desired information.
1184 Use a union of these values as the 'selection' parameter to
1185 get_thread_info. FIXME: Make these TAG names more thread specific.
1188 #define TAG_THREADID 1
1189 #define TAG_EXISTS 2
1190 #define TAG_DISPLAY 4
1191 #define TAG_THREADNAME 8
1192 #define TAG_MOREDISPLAY 16
1194 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1196 char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
1198 static char *unpack_nibble (char *buf
, int *val
);
1200 static char *pack_nibble (char *buf
, int nibble
);
1202 static char *pack_hex_byte (char *pkt
, int /* unsigned char */ byte
);
1204 static char *unpack_byte (char *buf
, int *value
);
1206 static char *pack_int (char *buf
, int value
);
1208 static char *unpack_int (char *buf
, int *value
);
1210 static char *unpack_string (char *src
, char *dest
, int length
);
1212 static char *pack_threadid (char *pkt
, threadref
*id
);
1214 static char *unpack_threadid (char *inbuf
, threadref
*id
);
1216 void int_to_threadref (threadref
*id
, int value
);
1218 static int threadref_to_int (threadref
*ref
);
1220 static void copy_threadref (threadref
*dest
, threadref
*src
);
1222 static int threadmatch (threadref
*dest
, threadref
*src
);
1224 static char *pack_threadinfo_request (char *pkt
, int mode
,
1227 static int remote_unpack_thread_info_response (char *pkt
,
1228 threadref
*expectedref
,
1229 struct gdb_ext_thread_info
1233 static int remote_get_threadinfo (threadref
*threadid
,
1234 int fieldset
, /*TAG mask */
1235 struct gdb_ext_thread_info
*info
);
1237 static char *pack_threadlist_request (char *pkt
, int startflag
,
1239 threadref
*nextthread
);
1241 static int parse_threadlist_response (char *pkt
,
1243 threadref
*original_echo
,
1244 threadref
*resultlist
,
1247 static int remote_get_threadlist (int startflag
,
1248 threadref
*nextthread
,
1252 threadref
*threadlist
);
1254 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
1256 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
1257 void *context
, int looplimit
);
1259 static int remote_newthread_step (threadref
*ref
, void *context
);
1261 /* Encode 64 bits in 16 chars of hex. */
1263 static const char hexchars
[] = "0123456789abcdef";
1266 ishex (int ch
, int *val
)
1268 if ((ch
>= 'a') && (ch
<= 'f'))
1270 *val
= ch
- 'a' + 10;
1273 if ((ch
>= 'A') && (ch
<= 'F'))
1275 *val
= ch
- 'A' + 10;
1278 if ((ch
>= '0') && (ch
<= '9'))
1289 if (ch
>= 'a' && ch
<= 'f')
1290 return ch
- 'a' + 10;
1291 if (ch
>= '0' && ch
<= '9')
1293 if (ch
>= 'A' && ch
<= 'F')
1294 return ch
- 'A' + 10;
1299 stub_unpack_int (char *buff
, int fieldlength
)
1306 nibble
= stubhex (*buff
++);
1310 retval
= retval
<< 4;
1316 unpack_varlen_hex (char *buff
, /* packet to parse */
1320 ULONGEST retval
= 0;
1322 while (ishex (*buff
, &nibble
))
1325 retval
= retval
<< 4;
1326 retval
|= nibble
& 0x0f;
1333 unpack_nibble (char *buf
, int *val
)
1335 ishex (*buf
++, val
);
1340 pack_nibble (char *buf
, int nibble
)
1342 *buf
++ = hexchars
[(nibble
& 0x0f)];
1347 pack_hex_byte (char *pkt
, int byte
)
1349 *pkt
++ = hexchars
[(byte
>> 4) & 0xf];
1350 *pkt
++ = hexchars
[(byte
& 0xf)];
1355 unpack_byte (char *buf
, int *value
)
1357 *value
= stub_unpack_int (buf
, 2);
1362 pack_int (char *buf
, int value
)
1364 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
1365 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
1366 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
1367 buf
= pack_hex_byte (buf
, (value
& 0xff));
1372 unpack_int (char *buf
, int *value
)
1374 *value
= stub_unpack_int (buf
, 8);
1378 #if 0 /* Currently unused, uncomment when needed. */
1379 static char *pack_string (char *pkt
, char *string
);
1382 pack_string (char *pkt
, char *string
)
1387 len
= strlen (string
);
1389 len
= 200; /* Bigger than most GDB packets, junk??? */
1390 pkt
= pack_hex_byte (pkt
, len
);
1394 if ((ch
== '\0') || (ch
== '#'))
1395 ch
= '*'; /* Protect encapsulation. */
1400 #endif /* 0 (unused) */
1403 unpack_string (char *src
, char *dest
, int length
)
1412 pack_threadid (char *pkt
, threadref
*id
)
1415 unsigned char *altid
;
1417 altid
= (unsigned char *) id
;
1418 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
1420 pkt
= pack_hex_byte (pkt
, *altid
++);
1426 unpack_threadid (char *inbuf
, threadref
*id
)
1429 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
1432 altref
= (char *) id
;
1434 while (inbuf
< limit
)
1436 x
= stubhex (*inbuf
++);
1437 y
= stubhex (*inbuf
++);
1438 *altref
++ = (x
<< 4) | y
;
1443 /* Externally, threadrefs are 64 bits but internally, they are still
1444 ints. This is due to a mismatch of specifications. We would like
1445 to use 64bit thread references internally. This is an adapter
1449 int_to_threadref (threadref
*id
, int value
)
1451 unsigned char *scan
;
1453 scan
= (unsigned char *) id
;
1459 *scan
++ = (value
>> 24) & 0xff;
1460 *scan
++ = (value
>> 16) & 0xff;
1461 *scan
++ = (value
>> 8) & 0xff;
1462 *scan
++ = (value
& 0xff);
1466 threadref_to_int (threadref
*ref
)
1469 unsigned char *scan
;
1475 value
= (value
<< 8) | ((*scan
++) & 0xff);
1480 copy_threadref (threadref
*dest
, threadref
*src
)
1483 unsigned char *csrc
, *cdest
;
1485 csrc
= (unsigned char *) src
;
1486 cdest
= (unsigned char *) dest
;
1493 threadmatch (threadref
*dest
, threadref
*src
)
1495 /* Things are broken right now, so just assume we got a match. */
1497 unsigned char *srcp
, *destp
;
1499 srcp
= (char *) src
;
1500 destp
= (char *) dest
;
1504 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
1511 threadid:1, # always request threadid
1518 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
1521 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
1523 *pkt
++ = 'q'; /* Info Query */
1524 *pkt
++ = 'P'; /* process or thread info */
1525 pkt
= pack_int (pkt
, mode
); /* mode */
1526 pkt
= pack_threadid (pkt
, id
); /* threadid */
1527 *pkt
= '\0'; /* terminate */
1531 /* These values tag the fields in a thread info response packet. */
1532 /* Tagging the fields allows us to request specific fields and to
1533 add more fields as time goes by. */
1535 #define TAG_THREADID 1 /* Echo the thread identifier. */
1536 #define TAG_EXISTS 2 /* Is this process defined enough to
1537 fetch registers and its stack? */
1538 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
1539 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
1540 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
1544 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
1545 struct gdb_ext_thread_info
*info
)
1547 struct remote_state
*rs
= get_remote_state ();
1551 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
1554 /* info->threadid = 0; FIXME: implement zero_threadref. */
1556 info
->display
[0] = '\0';
1557 info
->shortname
[0] = '\0';
1558 info
->more_display
[0] = '\0';
1560 /* Assume the characters indicating the packet type have been
1562 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
1563 pkt
= unpack_threadid (pkt
, &ref
);
1566 warning (_("Incomplete response to threadinfo request."));
1567 if (!threadmatch (&ref
, expectedref
))
1568 { /* This is an answer to a different request. */
1569 warning (_("ERROR RMT Thread info mismatch."));
1572 copy_threadref (&info
->threadid
, &ref
);
1574 /* Loop on tagged fields , try to bail if somthing goes wrong. */
1576 /* Packets are terminated with nulls. */
1577 while ((pkt
< limit
) && mask
&& *pkt
)
1579 pkt
= unpack_int (pkt
, &tag
); /* tag */
1580 pkt
= unpack_byte (pkt
, &length
); /* length */
1581 if (!(tag
& mask
)) /* Tags out of synch with mask. */
1583 warning (_("ERROR RMT: threadinfo tag mismatch."));
1587 if (tag
== TAG_THREADID
)
1591 warning (_("ERROR RMT: length of threadid is not 16."));
1595 pkt
= unpack_threadid (pkt
, &ref
);
1596 mask
= mask
& ~TAG_THREADID
;
1599 if (tag
== TAG_EXISTS
)
1601 info
->active
= stub_unpack_int (pkt
, length
);
1603 mask
= mask
& ~(TAG_EXISTS
);
1606 warning (_("ERROR RMT: 'exists' length too long."));
1612 if (tag
== TAG_THREADNAME
)
1614 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
1615 mask
= mask
& ~TAG_THREADNAME
;
1618 if (tag
== TAG_DISPLAY
)
1620 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
1621 mask
= mask
& ~TAG_DISPLAY
;
1624 if (tag
== TAG_MOREDISPLAY
)
1626 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
1627 mask
= mask
& ~TAG_MOREDISPLAY
;
1630 warning (_("ERROR RMT: unknown thread info tag."));
1631 break; /* Not a tag we know about. */
1637 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
1638 struct gdb_ext_thread_info
*info
)
1640 struct remote_state
*rs
= get_remote_state ();
1643 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
1645 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1646 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
1651 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
1654 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
1655 threadref
*nextthread
)
1657 *pkt
++ = 'q'; /* info query packet */
1658 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
1659 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
1660 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
1661 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
1666 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1669 parse_threadlist_response (char *pkt
, int result_limit
,
1670 threadref
*original_echo
, threadref
*resultlist
,
1673 struct remote_state
*rs
= get_remote_state ();
1675 int count
, resultcount
, done
;
1678 /* Assume the 'q' and 'M chars have been stripped. */
1679 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
1680 /* done parse past here */
1681 pkt
= unpack_byte (pkt
, &count
); /* count field */
1682 pkt
= unpack_nibble (pkt
, &done
);
1683 /* The first threadid is the argument threadid. */
1684 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
1685 while ((count
-- > 0) && (pkt
< limit
))
1687 pkt
= unpack_threadid (pkt
, resultlist
++);
1688 if (resultcount
++ >= result_limit
)
1697 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
1698 int *done
, int *result_count
, threadref
*threadlist
)
1700 struct remote_state
*rs
= get_remote_state ();
1701 static threadref echo_nextthread
;
1704 /* Trancate result limit to be smaller than the packet size. */
1705 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10) >= get_remote_packet_size ())
1706 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
1708 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
1710 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1713 parse_threadlist_response (rs
->buf
+ 2, result_limit
, &echo_nextthread
,
1716 if (!threadmatch (&echo_nextthread
, nextthread
))
1718 /* FIXME: This is a good reason to drop the packet. */
1719 /* Possably, there is a duplicate response. */
1721 retransmit immediatly - race conditions
1722 retransmit after timeout - yes
1724 wait for packet, then exit
1726 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
1727 return 0; /* I choose simply exiting. */
1729 if (*result_count
<= 0)
1733 warning (_("RMT ERROR : failed to get remote thread list."));
1736 return result
; /* break; */
1738 if (*result_count
> result_limit
)
1741 warning (_("RMT ERROR: threadlist response longer than requested."));
1747 /* This is the interface between remote and threads, remotes upper
1750 /* remote_find_new_threads retrieves the thread list and for each
1751 thread in the list, looks up the thread in GDB's internal list,
1752 ading the thread if it does not already exist. This involves
1753 getting partial thread lists from the remote target so, polling the
1754 quit_flag is required. */
1757 /* About this many threadisds fit in a packet. */
1759 #define MAXTHREADLISTRESULTS 32
1762 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
1765 int done
, i
, result_count
;
1769 static threadref nextthread
;
1770 static threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
1775 if (loopcount
++ > looplimit
)
1778 warning (_("Remote fetch threadlist -infinite loop-."));
1781 if (!remote_get_threadlist (startflag
, &nextthread
, MAXTHREADLISTRESULTS
,
1782 &done
, &result_count
, resultthreadlist
))
1787 /* Clear for later iterations. */
1789 /* Setup to resume next batch of thread references, set nextthread. */
1790 if (result_count
>= 1)
1791 copy_threadref (&nextthread
, &resultthreadlist
[result_count
- 1]);
1793 while (result_count
--)
1794 if (!(result
= (*stepfunction
) (&resultthreadlist
[i
++], context
)))
1801 remote_newthread_step (threadref
*ref
, void *context
)
1805 ptid
= pid_to_ptid (threadref_to_int (ref
));
1807 if (!in_thread_list (ptid
))
1809 return 1; /* continue iterator */
1812 #define CRAZY_MAX_THREADS 1000
1815 remote_current_thread (ptid_t oldpid
)
1817 struct remote_state
*rs
= get_remote_state ();
1820 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1821 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
1822 /* Use strtoul here, so we'll correctly parse values whose highest
1823 bit is set. The protocol carries them as a simple series of
1824 hex digits; in the absence of a sign, strtol will see such
1825 values as positive numbers out of range for signed 'long', and
1826 return LONG_MAX to indicate an overflow. */
1827 return pid_to_ptid (strtoul (&rs
->buf
[2], NULL
, 16));
1832 /* Find new threads for info threads command.
1833 * Original version, using John Metzler's thread protocol.
1837 remote_find_new_threads (void)
1839 remote_threadlist_iterator (remote_newthread_step
, 0,
1841 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
) /* ack ack ack */
1842 inferior_ptid
= remote_current_thread (inferior_ptid
);
1846 * Find all threads for info threads command.
1847 * Uses new thread protocol contributed by Cisco.
1848 * Falls back and attempts to use the older method (above)
1849 * if the target doesn't respond to the new method.
1853 remote_threads_info (void)
1855 struct remote_state
*rs
= get_remote_state ();
1859 if (remote_desc
== 0) /* paranoia */
1860 error (_("Command can only be used when connected to the remote target."));
1862 if (use_threadinfo_query
)
1864 putpkt ("qfThreadInfo");
1865 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1867 if (bufp
[0] != '\0') /* q packet recognized */
1869 while (*bufp
++ == 'm') /* reply contains one or more TID */
1873 /* Use strtoul here, so we'll correctly parse values
1874 whose highest bit is set. The protocol carries
1875 them as a simple series of hex digits; in the
1876 absence of a sign, strtol will see such values as
1877 positive numbers out of range for signed 'long',
1878 and return LONG_MAX to indicate an overflow. */
1879 tid
= strtoul (bufp
, &bufp
, 16);
1880 if (tid
!= 0 && !in_thread_list (pid_to_ptid (tid
)))
1881 add_thread (pid_to_ptid (tid
));
1883 while (*bufp
++ == ','); /* comma-separated list */
1884 putpkt ("qsThreadInfo");
1885 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1892 /* Else fall back to old method based on jmetzler protocol. */
1893 use_threadinfo_query
= 0;
1894 remote_find_new_threads ();
1899 * Collect a descriptive string about the given thread.
1900 * The target may say anything it wants to about the thread
1901 * (typically info about its blocked / runnable state, name, etc.).
1902 * This string will appear in the info threads display.
1904 * Optional: targets are not required to implement this function.
1908 remote_threads_extra_info (struct thread_info
*tp
)
1910 struct remote_state
*rs
= get_remote_state ();
1914 struct gdb_ext_thread_info threadinfo
;
1915 static char display_buf
[100]; /* arbitrary... */
1916 int n
= 0; /* position in display_buf */
1918 if (remote_desc
== 0) /* paranoia */
1919 internal_error (__FILE__
, __LINE__
,
1920 _("remote_threads_extra_info"));
1922 if (use_threadextra_query
)
1924 xsnprintf (rs
->buf
, get_remote_packet_size (), "qThreadExtraInfo,%x",
1927 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1928 if (rs
->buf
[0] != 0)
1930 n
= min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
1931 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
1932 display_buf
[result
] = '\0';
1937 /* If the above query fails, fall back to the old method. */
1938 use_threadextra_query
= 0;
1939 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
1940 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
1941 int_to_threadref (&id
, PIDGET (tp
->ptid
));
1942 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
1943 if (threadinfo
.active
)
1945 if (*threadinfo
.shortname
)
1946 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
1947 " Name: %s,", threadinfo
.shortname
);
1948 if (*threadinfo
.display
)
1949 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1950 " State: %s,", threadinfo
.display
);
1951 if (*threadinfo
.more_display
)
1952 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
1953 " Priority: %s", threadinfo
.more_display
);
1957 /* For purely cosmetic reasons, clear up trailing commas. */
1958 if (',' == display_buf
[n
-1])
1959 display_buf
[n
-1] = ' ';
1967 /* Restart the remote side; this is an extended protocol operation. */
1970 extended_remote_restart (void)
1972 struct remote_state
*rs
= get_remote_state ();
1974 /* Send the restart command; for reasons I don't understand the
1975 remote side really expects a number after the "R". */
1976 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
1979 remote_fileio_reset ();
1981 /* Now query for status so this looks just like we restarted
1982 gdbserver from scratch. */
1984 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1987 /* Clean up connection to a remote debugger. */
1990 remote_close (int quitting
)
1993 serial_close (remote_desc
);
1997 /* Query the remote side for the text, data and bss offsets. */
2002 struct remote_state
*rs
= get_remote_state ();
2006 CORE_ADDR text_addr
, data_addr
, bss_addr
;
2007 struct section_offsets
*offs
;
2009 putpkt ("qOffsets");
2010 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2013 if (buf
[0] == '\000')
2014 return; /* Return silently. Stub doesn't support
2018 warning (_("Remote failure reply: %s"), buf
);
2022 /* Pick up each field in turn. This used to be done with scanf, but
2023 scanf will make trouble if CORE_ADDR size doesn't match
2024 conversion directives correctly. The following code will work
2025 with any size of CORE_ADDR. */
2026 text_addr
= data_addr
= bss_addr
= 0;
2030 if (strncmp (ptr
, "Text=", 5) == 0)
2033 /* Don't use strtol, could lose on big values. */
2034 while (*ptr
&& *ptr
!= ';')
2035 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
2040 if (!lose
&& strncmp (ptr
, ";Data=", 6) == 0)
2043 while (*ptr
&& *ptr
!= ';')
2044 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
2049 if (!lose
&& strncmp (ptr
, ";Bss=", 5) == 0)
2052 while (*ptr
&& *ptr
!= ';')
2053 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
2059 error (_("Malformed response to offset query, %s"), buf
);
2061 if (symfile_objfile
== NULL
)
2064 offs
= ((struct section_offsets
*)
2065 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
2066 memcpy (offs
, symfile_objfile
->section_offsets
,
2067 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
2069 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
2071 /* This is a temporary kludge to force data and bss to use the same offsets
2072 because that's what nlmconv does now. The real solution requires changes
2073 to the stub and remote.c that I don't have time to do right now. */
2075 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
2076 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
2078 objfile_relocate (symfile_objfile
, offs
);
2081 /* Stub for catch_exception. */
2084 remote_start_remote (struct ui_out
*uiout
, void *from_tty_p
)
2086 int from_tty
= * (int *) from_tty_p
;
2088 immediate_quit
++; /* Allow user to interrupt it. */
2090 /* Ack any packet which the remote side has already sent. */
2091 serial_write (remote_desc
, "+", 1);
2093 /* Let the stub know that we want it to return the thread. */
2096 inferior_ptid
= remote_current_thread (inferior_ptid
);
2098 get_offsets (); /* Get text, data & bss offsets. */
2100 putpkt ("?"); /* Initiate a query from remote machine. */
2103 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
2106 /* Open a connection to a remote debugger.
2107 NAME is the filename used for communication. */
2110 remote_open (char *name
, int from_tty
)
2112 remote_open_1 (name
, from_tty
, &remote_ops
, 0, 0);
2115 /* Just like remote_open, but with asynchronous support. */
2117 remote_async_open (char *name
, int from_tty
)
2119 remote_open_1 (name
, from_tty
, &remote_async_ops
, 0, 1);
2122 /* Open a connection to a remote debugger using the extended
2123 remote gdb protocol. NAME is the filename used for communication. */
2126 extended_remote_open (char *name
, int from_tty
)
2128 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */,
2132 /* Just like extended_remote_open, but with asynchronous support. */
2134 extended_remote_async_open (char *name
, int from_tty
)
2136 remote_open_1 (name
, from_tty
, &extended_async_remote_ops
,
2137 1 /*extended_p */, 1 /* async_p */);
2140 /* Generic code for opening a connection to a remote target. */
2143 init_all_packet_configs (void)
2146 for (i
= 0; i
< PACKET_MAX
; i
++)
2147 update_packet_config (&remote_protocol_packets
[i
]);
2150 /* Symbol look-up. */
2153 remote_check_symbols (struct objfile
*objfile
)
2155 struct remote_state
*rs
= get_remote_state ();
2156 char *msg
, *reply
, *tmp
;
2157 struct minimal_symbol
*sym
;
2160 if (remote_protocol_packets
[PACKET_qSymbol
].support
== PACKET_DISABLE
)
2163 /* Allocate a message buffer. We can't reuse the input buffer in RS,
2164 because we need both at the same time. */
2165 msg
= alloca (get_remote_packet_size ());
2167 /* Invite target to request symbol lookups. */
2169 putpkt ("qSymbol::");
2170 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2171 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSymbol
]);
2174 while (strncmp (reply
, "qSymbol:", 8) == 0)
2177 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
2179 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
2181 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
2183 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
2184 paddr_nz (SYMBOL_VALUE_ADDRESS (sym
)),
2187 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2192 static struct serial
*
2193 remote_serial_open (char *name
)
2195 static int udp_warning
= 0;
2197 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
2198 of in ser-tcp.c, because it is the remote protocol assuming that the
2199 serial connection is reliable and not the serial connection promising
2201 if (!udp_warning
&& strncmp (name
, "udp:", 4) == 0)
2204 The remote protocol may be unreliable over UDP.\n\
2205 Some events may be lost, rendering further debugging impossible."));
2209 return serial_open (name
);
2212 /* This type describes each known response to the qSupported
2214 struct protocol_feature
2216 /* The name of this protocol feature. */
2219 /* The default for this protocol feature. */
2220 enum packet_support default_support
;
2222 /* The function to call when this feature is reported, or after
2223 qSupported processing if the feature is not supported.
2224 The first argument points to this structure. The second
2225 argument indicates whether the packet requested support be
2226 enabled, disabled, or probed (or the default, if this function
2227 is being called at the end of processing and this feature was
2228 not reported). The third argument may be NULL; if not NULL, it
2229 is a NUL-terminated string taken from the packet following
2230 this feature's name and an equals sign. */
2231 void (*func
) (const struct protocol_feature
*, enum packet_support
,
2234 /* The corresponding packet for this feature. Only used if
2235 FUNC is remote_supported_packet. */
2240 remote_supported_packet (const struct protocol_feature
*feature
,
2241 enum packet_support support
,
2242 const char *argument
)
2246 warning (_("Remote qSupported response supplied an unexpected value for"
2247 " \"%s\"."), feature
->name
);
2251 if (remote_protocol_packets
[feature
->packet
].support
2252 == PACKET_SUPPORT_UNKNOWN
)
2253 remote_protocol_packets
[feature
->packet
].support
= support
;
2257 remote_packet_size (const struct protocol_feature
*feature
,
2258 enum packet_support support
, const char *value
)
2260 struct remote_state
*rs
= get_remote_state ();
2265 if (support
!= PACKET_ENABLE
)
2268 if (value
== NULL
|| *value
== '\0')
2270 warning (_("Remote target reported \"%s\" without a size."),
2276 packet_size
= strtol (value
, &value_end
, 16);
2277 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
2279 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
2280 feature
->name
, value
);
2284 if (packet_size
> MAX_REMOTE_PACKET_SIZE
)
2286 warning (_("limiting remote suggested packet size (%d bytes) to %d"),
2287 packet_size
, MAX_REMOTE_PACKET_SIZE
);
2288 packet_size
= MAX_REMOTE_PACKET_SIZE
;
2291 /* Record the new maximum packet size. */
2292 rs
->explicit_packet_size
= packet_size
;
2295 static struct protocol_feature remote_protocol_features
[] = {
2296 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
2297 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
2298 PACKET_qXfer_auxv
},
2299 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
2300 PACKET_qXfer_features
},
2301 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
2302 PACKET_qXfer_memory_map
},
2303 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
2304 PACKET_QPassSignals
},
2308 remote_query_supported (void)
2310 struct remote_state
*rs
= get_remote_state ();
2313 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
2315 /* The packet support flags are handled differently for this packet
2316 than for most others. We treat an error, a disabled packet, and
2317 an empty response identically: any features which must be reported
2318 to be used will be automatically disabled. An empty buffer
2319 accomplishes this, since that is also the representation for a list
2320 containing no features. */
2323 if (remote_protocol_packets
[PACKET_qSupported
].support
!= PACKET_DISABLE
)
2325 putpkt ("qSupported");
2326 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2328 /* If an error occured, warn, but do not return - just reset the
2329 buffer to empty and go on to disable features. */
2330 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
2333 warning (_("Remote failure reply: %s"), rs
->buf
);
2338 memset (seen
, 0, sizeof (seen
));
2343 enum packet_support is_supported
;
2344 char *p
, *end
, *name_end
, *value
;
2346 /* First separate out this item from the rest of the packet. If
2347 there's another item after this, we overwrite the separator
2348 (terminated strings are much easier to work with). */
2350 end
= strchr (p
, ';');
2353 end
= p
+ strlen (p
);
2363 warning (_("empty item in \"qSupported\" response"));
2368 name_end
= strchr (p
, '=');
2371 /* This is a name=value entry. */
2372 is_supported
= PACKET_ENABLE
;
2373 value
= name_end
+ 1;
2382 is_supported
= PACKET_ENABLE
;
2386 is_supported
= PACKET_DISABLE
;
2390 is_supported
= PACKET_SUPPORT_UNKNOWN
;
2394 warning (_("unrecognized item \"%s\" in \"qSupported\" response"), p
);
2400 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2401 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
2403 const struct protocol_feature
*feature
;
2406 feature
= &remote_protocol_features
[i
];
2407 feature
->func (feature
, is_supported
, value
);
2412 /* If we increased the packet size, make sure to increase the global
2413 buffer size also. We delay this until after parsing the entire
2414 qSupported packet, because this is the same buffer we were
2416 if (rs
->buf_size
< rs
->explicit_packet_size
)
2418 rs
->buf_size
= rs
->explicit_packet_size
;
2419 rs
->buf
= xrealloc (rs
->buf
, rs
->buf_size
);
2422 /* Handle the defaults for unmentioned features. */
2423 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
2426 const struct protocol_feature
*feature
;
2428 feature
= &remote_protocol_features
[i
];
2429 feature
->func (feature
, feature
->default_support
, NULL
);
2435 remote_open_1 (char *name
, int from_tty
, struct target_ops
*target
,
2436 int extended_p
, int async_p
)
2438 struct remote_state
*rs
= get_remote_state ();
2440 error (_("To open a remote debug connection, you need to specify what\n"
2441 "serial device is attached to the remote system\n"
2442 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
2444 /* See FIXME above. */
2446 wait_forever_enabled_p
= 1;
2448 target_preopen (from_tty
);
2450 unpush_target (target
);
2452 /* Make sure we send the passed signals list the next time we resume. */
2453 xfree (last_pass_packet
);
2454 last_pass_packet
= NULL
;
2456 remote_fileio_reset ();
2457 reopen_exec_file ();
2460 remote_desc
= remote_serial_open (name
);
2462 perror_with_name (name
);
2464 if (baud_rate
!= -1)
2466 if (serial_setbaudrate (remote_desc
, baud_rate
))
2468 /* The requested speed could not be set. Error out to
2469 top level after closing remote_desc. Take care to
2470 set remote_desc to NULL to avoid closing remote_desc
2472 serial_close (remote_desc
);
2474 perror_with_name (name
);
2478 serial_raw (remote_desc
);
2480 /* If there is something sitting in the buffer we might take it as a
2481 response to a command, which would be bad. */
2482 serial_flush_input (remote_desc
);
2486 puts_filtered ("Remote debugging using ");
2487 puts_filtered (name
);
2488 puts_filtered ("\n");
2490 push_target (target
); /* Switch to using remote target now. */
2492 /* Reset the target state; these things will be queried either by
2493 remote_query_supported or as they are needed. */
2494 init_all_packet_configs ();
2495 rs
->explicit_packet_size
= 0;
2497 general_thread
= -2;
2498 continue_thread
= -2;
2500 /* Probe for ability to use "ThreadInfo" query, as required. */
2501 use_threadinfo_query
= 1;
2502 use_threadextra_query
= 1;
2504 /* The first packet we send to the target is the optional "supported
2505 packets" request. If the target can answer this, it will tell us
2506 which later probes to skip. */
2507 remote_query_supported ();
2509 /* Next, if the target can specify a description, read it. We do
2510 this before anything involving memory or registers. */
2511 target_find_description ();
2513 /* Without this, some commands which require an active target (such
2514 as kill) won't work. This variable serves (at least) double duty
2515 as both the pid of the target process (if it has such), and as a
2516 flag indicating that a target is active. These functions should
2517 be split out into seperate variables, especially since GDB will
2518 someday have a notion of debugging several processes. */
2520 inferior_ptid
= pid_to_ptid (MAGIC_NULL_PID
);
2524 /* With this target we start out by owning the terminal. */
2525 remote_async_terminal_ours_p
= 1;
2527 /* FIXME: cagney/1999-09-23: During the initial connection it is
2528 assumed that the target is already ready and able to respond to
2529 requests. Unfortunately remote_start_remote() eventually calls
2530 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
2531 around this. Eventually a mechanism that allows
2532 wait_for_inferior() to expect/get timeouts will be
2534 wait_forever_enabled_p
= 0;
2537 /* First delete any symbols previously loaded from shared libraries. */
2538 no_shared_libraries (NULL
, 0);
2540 /* Start the remote connection. If error() or QUIT, discard this
2541 target (we'd otherwise be in an inconsistent state) and then
2542 propogate the error on up the exception chain. This ensures that
2543 the caller doesn't stumble along blindly assuming that the
2544 function succeeded. The CLI doesn't have this problem but other
2545 UI's, such as MI do.
2547 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2548 this function should return an error indication letting the
2549 caller restore the previous state. Unfortunately the command
2550 ``target remote'' is directly wired to this function making that
2551 impossible. On a positive note, the CLI side of this problem has
2552 been fixed - the function set_cmd_context() makes it possible for
2553 all the ``target ....'' commands to share a common callback
2554 function. See cli-dump.c. */
2556 struct gdb_exception ex
2557 = catch_exception (uiout
, remote_start_remote
, &from_tty
,
2563 wait_forever_enabled_p
= 1;
2564 throw_exception (ex
);
2569 wait_forever_enabled_p
= 1;
2573 /* Tell the remote that we are using the extended protocol. */
2575 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2578 if (exec_bfd
) /* No use without an exec file. */
2579 remote_check_symbols (symfile_objfile
);
2582 /* This takes a program previously attached to and detaches it. After
2583 this is done, GDB can be used to debug some other program. We
2584 better not have left any breakpoints in the target program or it'll
2585 die when it hits one. */
2588 remote_detach (char *args
, int from_tty
)
2590 struct remote_state
*rs
= get_remote_state ();
2593 error (_("Argument given to \"detach\" when remotely debugging."));
2595 /* Tell the remote target to detach. */
2596 strcpy (rs
->buf
, "D");
2597 remote_send (&rs
->buf
, &rs
->buf_size
);
2599 /* Unregister the file descriptor from the event loop. */
2600 if (target_is_async_p ())
2601 serial_async (remote_desc
, NULL
, 0);
2603 target_mourn_inferior ();
2605 puts_filtered ("Ending remote debugging.\n");
2608 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
2611 remote_disconnect (struct target_ops
*target
, char *args
, int from_tty
)
2614 error (_("Argument given to \"detach\" when remotely debugging."));
2616 /* Unregister the file descriptor from the event loop. */
2617 if (target_is_async_p ())
2618 serial_async (remote_desc
, NULL
, 0);
2620 target_mourn_inferior ();
2622 puts_filtered ("Ending remote debugging.\n");
2625 /* Convert hex digit A to a number. */
2630 if (a
>= '0' && a
<= '9')
2632 else if (a
>= 'a' && a
<= 'f')
2633 return a
- 'a' + 10;
2634 else if (a
>= 'A' && a
<= 'F')
2635 return a
- 'A' + 10;
2637 error (_("Reply contains invalid hex digit %d"), a
);
2641 hex2bin (const char *hex
, gdb_byte
*bin
, int count
)
2645 for (i
= 0; i
< count
; i
++)
2647 if (hex
[0] == 0 || hex
[1] == 0)
2649 /* Hex string is short, or of uneven length.
2650 Return the count that has been converted so far. */
2653 *bin
++ = fromhex (hex
[0]) * 16 + fromhex (hex
[1]);
2659 /* Convert number NIB to a hex digit. */
2667 return 'a' + nib
- 10;
2671 bin2hex (const gdb_byte
*bin
, char *hex
, int count
)
2674 /* May use a length, or a nul-terminated string as input. */
2676 count
= strlen ((char *) bin
);
2678 for (i
= 0; i
< count
; i
++)
2680 *hex
++ = tohex ((*bin
>> 4) & 0xf);
2681 *hex
++ = tohex (*bin
++ & 0xf);
2687 /* Check for the availability of vCont. This function should also check
2691 remote_vcont_probe (struct remote_state
*rs
)
2695 strcpy (rs
->buf
, "vCont?");
2697 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2700 /* Make sure that the features we assume are supported. */
2701 if (strncmp (buf
, "vCont", 5) == 0)
2704 int support_s
, support_S
, support_c
, support_C
;
2710 while (p
&& *p
== ';')
2713 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2715 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2717 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2719 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
2722 p
= strchr (p
, ';');
2725 /* If s, S, c, and C are not all supported, we can't use vCont. Clearing
2726 BUF will make packet_ok disable the packet. */
2727 if (!support_s
|| !support_S
|| !support_c
|| !support_C
)
2731 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
2734 /* Resume the remote inferior by using a "vCont" packet. The thread
2735 to be resumed is PTID; STEP and SIGGNAL indicate whether the
2736 resumed thread should be single-stepped and/or signalled. If PTID's
2737 PID is -1, then all threads are resumed; the thread to be stepped and/or
2738 signalled is given in the global INFERIOR_PTID. This function returns
2739 non-zero iff it resumes the inferior.
2741 This function issues a strict subset of all possible vCont commands at the
2745 remote_vcont_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2747 struct remote_state
*rs
= get_remote_state ();
2748 int pid
= PIDGET (ptid
);
2749 char *buf
= NULL
, *outbuf
;
2750 struct cleanup
*old_cleanup
;
2752 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_SUPPORT_UNKNOWN
)
2753 remote_vcont_probe (rs
);
2755 if (remote_protocol_packets
[PACKET_vCont
].support
== PACKET_DISABLE
)
2758 /* If we could generate a wider range of packets, we'd have to worry
2759 about overflowing BUF. Should there be a generic
2760 "multi-part-packet" packet? */
2762 if (PIDGET (inferior_ptid
) == MAGIC_NULL_PID
)
2764 /* MAGIC_NULL_PTID means that we don't have any active threads, so we
2765 don't have any PID numbers the inferior will understand. Make sure
2766 to only send forms that do not specify a PID. */
2767 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2768 outbuf
= xstrprintf ("vCont;S%02x", siggnal
);
2770 outbuf
= xstrprintf ("vCont;s");
2771 else if (siggnal
!= TARGET_SIGNAL_0
)
2772 outbuf
= xstrprintf ("vCont;C%02x", siggnal
);
2774 outbuf
= xstrprintf ("vCont;c");
2778 /* Resume all threads, with preference for INFERIOR_PTID. */
2779 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2780 outbuf
= xstrprintf ("vCont;S%02x:%x;c", siggnal
,
2781 PIDGET (inferior_ptid
));
2783 outbuf
= xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid
));
2784 else if (siggnal
!= TARGET_SIGNAL_0
)
2785 outbuf
= xstrprintf ("vCont;C%02x:%x;c", siggnal
,
2786 PIDGET (inferior_ptid
));
2788 outbuf
= xstrprintf ("vCont;c");
2792 /* Scheduler locking; resume only PTID. */
2793 if (step
&& siggnal
!= TARGET_SIGNAL_0
)
2794 outbuf
= xstrprintf ("vCont;S%02x:%x", siggnal
, pid
);
2796 outbuf
= xstrprintf ("vCont;s:%x", pid
);
2797 else if (siggnal
!= TARGET_SIGNAL_0
)
2798 outbuf
= xstrprintf ("vCont;C%02x:%x", siggnal
, pid
);
2800 outbuf
= xstrprintf ("vCont;c:%x", pid
);
2803 gdb_assert (outbuf
&& strlen (outbuf
) < get_remote_packet_size ());
2804 old_cleanup
= make_cleanup (xfree
, outbuf
);
2808 do_cleanups (old_cleanup
);
2813 /* Tell the remote machine to resume. */
2815 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
2817 static int last_sent_step
;
2820 remote_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2822 struct remote_state
*rs
= get_remote_state ();
2824 int pid
= PIDGET (ptid
);
2826 last_sent_signal
= siggnal
;
2827 last_sent_step
= step
;
2829 /* A hook for when we need to do something at the last moment before
2831 if (deprecated_target_resume_hook
)
2832 (*deprecated_target_resume_hook
) ();
2834 /* Update the inferior on signals to silently pass, if they've changed. */
2835 remote_pass_signals ();
2837 /* The vCont packet doesn't need to specify threads via Hc. */
2838 if (remote_vcont_resume (ptid
, step
, siggnal
))
2841 /* All other supported resume packets do use Hc, so call set_thread. */
2843 set_thread (0, 0); /* Run any thread. */
2845 set_thread (pid
, 0); /* Run this thread. */
2848 if (siggnal
!= TARGET_SIGNAL_0
)
2850 buf
[0] = step
? 'S' : 'C';
2851 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
2852 buf
[2] = tohex (((int) siggnal
) & 0xf);
2856 strcpy (buf
, step
? "s" : "c");
2861 /* Same as remote_resume, but with async support. */
2863 remote_async_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2865 remote_resume (ptid
, step
, siggnal
);
2867 /* We are about to start executing the inferior, let's register it
2868 with the event loop. NOTE: this is the one place where all the
2869 execution commands end up. We could alternatively do this in each
2870 of the execution commands in infcmd.c. */
2871 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2872 into infcmd.c in order to allow inferior function calls to work
2873 NOT asynchronously. */
2874 if (target_can_async_p ())
2875 target_async (inferior_event_handler
, 0);
2876 /* Tell the world that the target is now executing. */
2877 /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2878 this? Instead, should the client of target just assume (for
2879 async targets) that the target is going to start executing? Is
2880 this information already found in the continuation block? */
2881 if (target_is_async_p ())
2882 target_executing
= 1;
2886 /* Set up the signal handler for SIGINT, while the target is
2887 executing, ovewriting the 'regular' SIGINT signal handler. */
2889 initialize_sigint_signal_handler (void)
2891 sigint_remote_token
=
2892 create_async_signal_handler (async_remote_interrupt
, NULL
);
2893 signal (SIGINT
, handle_remote_sigint
);
2896 /* Signal handler for SIGINT, while the target is executing. */
2898 handle_remote_sigint (int sig
)
2900 signal (sig
, handle_remote_sigint_twice
);
2901 sigint_remote_twice_token
=
2902 create_async_signal_handler (async_remote_interrupt_twice
, NULL
);
2903 mark_async_signal_handler_wrapper (sigint_remote_token
);
2906 /* Signal handler for SIGINT, installed after SIGINT has already been
2907 sent once. It will take effect the second time that the user sends
2910 handle_remote_sigint_twice (int sig
)
2912 signal (sig
, handle_sigint
);
2913 sigint_remote_twice_token
=
2914 create_async_signal_handler (inferior_event_handler_wrapper
, NULL
);
2915 mark_async_signal_handler_wrapper (sigint_remote_twice_token
);
2918 /* Perform the real interruption of the target execution, in response
2921 async_remote_interrupt (gdb_client_data arg
)
2924 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2929 /* Perform interrupt, if the first attempt did not succeed. Just give
2930 up on the target alltogether. */
2932 async_remote_interrupt_twice (gdb_client_data arg
)
2935 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt_twice called\n");
2936 /* Do something only if the target was not killed by the previous
2938 if (target_executing
)
2941 signal (SIGINT
, handle_remote_sigint
);
2945 /* Reinstall the usual SIGINT handlers, after the target has
2948 cleanup_sigint_signal_handler (void *dummy
)
2950 signal (SIGINT
, handle_sigint
);
2951 if (sigint_remote_twice_token
)
2952 delete_async_signal_handler (&sigint_remote_twice_token
);
2953 if (sigint_remote_token
)
2954 delete_async_signal_handler (&sigint_remote_token
);
2957 /* Send ^C to target to halt it. Target will respond, and send us a
2959 static void (*ofunc
) (int);
2961 /* The command line interface's stop routine. This function is installed
2962 as a signal handler for SIGINT. The first time a user requests a
2963 stop, we call remote_stop to send a break or ^C. If there is no
2964 response from the target (it didn't stop when the user requested it),
2965 we ask the user if he'd like to detach from the target. */
2967 remote_interrupt (int signo
)
2969 /* If this doesn't work, try more severe steps. */
2970 signal (signo
, remote_interrupt_twice
);
2973 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
2978 /* The user typed ^C twice. */
2981 remote_interrupt_twice (int signo
)
2983 signal (signo
, ofunc
);
2985 signal (signo
, remote_interrupt
);
2988 /* This is the generic stop called via the target vector. When a target
2989 interrupt is requested, either by the command line or the GUI, we
2990 will eventually end up here. */
2994 /* Send a break or a ^C, depending on user preference. */
2996 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
2999 serial_send_break (remote_desc
);
3001 serial_write (remote_desc
, "\003", 1);
3004 /* Ask the user what to do when an interrupt is received. */
3007 interrupt_query (void)
3009 target_terminal_ours ();
3011 if (query ("Interrupted while waiting for the program.\n\
3012 Give up (and stop debugging it)? "))
3014 target_mourn_inferior ();
3015 deprecated_throw_reason (RETURN_QUIT
);
3018 target_terminal_inferior ();
3021 /* Enable/disable target terminal ownership. Most targets can use
3022 terminal groups to control terminal ownership. Remote targets are
3023 different in that explicit transfer of ownership to/from GDB/target
3027 remote_async_terminal_inferior (void)
3029 /* FIXME: cagney/1999-09-27: Shouldn't need to test for
3030 sync_execution here. This function should only be called when
3031 GDB is resuming the inferior in the forground. A background
3032 resume (``run&'') should leave GDB in control of the terminal and
3033 consequently should not call this code. */
3034 if (!sync_execution
)
3036 /* FIXME: cagney/1999-09-27: Closely related to the above. Make
3037 calls target_terminal_*() idenpotent. The event-loop GDB talking
3038 to an asynchronous target with a synchronous command calls this
3039 function from both event-top.c and infrun.c/infcmd.c. Once GDB
3040 stops trying to transfer the terminal to the target when it
3041 shouldn't this guard can go away. */
3042 if (!remote_async_terminal_ours_p
)
3044 delete_file_handler (input_fd
);
3045 remote_async_terminal_ours_p
= 0;
3046 initialize_sigint_signal_handler ();
3047 /* NOTE: At this point we could also register our selves as the
3048 recipient of all input. Any characters typed could then be
3049 passed on down to the target. */
3053 remote_async_terminal_ours (void)
3055 /* See FIXME in remote_async_terminal_inferior. */
3056 if (!sync_execution
)
3058 /* See FIXME in remote_async_terminal_inferior. */
3059 if (remote_async_terminal_ours_p
)
3061 cleanup_sigint_signal_handler (NULL
);
3062 add_file_handler (input_fd
, stdin_event_handler
, 0);
3063 remote_async_terminal_ours_p
= 1;
3066 /* If nonzero, ignore the next kill. */
3071 remote_console_output (char *msg
)
3075 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
3078 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
3081 fputs_unfiltered (tb
, gdb_stdtarg
);
3083 gdb_flush (gdb_stdtarg
);
3086 /* Wait until the remote machine stops, then return,
3087 storing status in STATUS just as `wait' would.
3088 Returns "pid", which in the case of a multi-threaded
3089 remote OS, is the thread-id. */
3092 remote_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3094 struct remote_state
*rs
= get_remote_state ();
3095 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3096 ULONGEST thread_num
= -1;
3099 status
->kind
= TARGET_WAITKIND_EXITED
;
3100 status
->value
.integer
= 0;
3106 ofunc
= signal (SIGINT
, remote_interrupt
);
3107 getpkt (&rs
->buf
, &rs
->buf_size
, 1);
3108 signal (SIGINT
, ofunc
);
3112 /* This is a hook for when we need to do something (perhaps the
3113 collection of trace data) every time the target stops. */
3114 if (deprecated_target_wait_loop_hook
)
3115 (*deprecated_target_wait_loop_hook
) ();
3117 remote_stopped_by_watchpoint_p
= 0;
3121 case 'E': /* Error of some sort. */
3122 warning (_("Remote failure reply: %s"), buf
);
3124 case 'F': /* File-I/O request. */
3125 remote_fileio_request (buf
);
3127 case 'T': /* Status with PC, SP, FP, ... */
3129 gdb_byte regs
[MAX_REGISTER_SIZE
];
3131 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3132 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3134 n... = register number
3135 r... = register contents
3137 p
= &buf
[3]; /* after Txx */
3146 /* If the packet contains a register number save it in
3147 pnum and set p1 to point to the character following
3148 it. Otherwise p1 points to p. */
3150 /* If this packet is an awatch packet, don't parse the
3151 'a' as a register number. */
3153 if (strncmp (p
, "awatch", strlen("awatch")) != 0)
3155 /* Read the ``P'' register number. */
3156 pnum
= strtol (p
, &p_temp
, 16);
3162 if (p1
== p
) /* No register number present here. */
3164 p1
= strchr (p
, ':');
3166 error (_("Malformed packet(a) (missing colon): %s\n\
3169 if (strncmp (p
, "thread", p1
- p
) == 0)
3171 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3172 record_currthread (thread_num
);
3175 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3176 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3177 || (strncmp (p
, "awatch", p1
- p
) == 0))
3179 remote_stopped_by_watchpoint_p
= 1;
3180 p
= unpack_varlen_hex (++p1
, &addr
);
3181 remote_watch_data_address
= (CORE_ADDR
)addr
;
3185 /* Silently skip unknown optional info. */
3186 p_temp
= strchr (p1
+ 1, ';');
3193 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3197 error (_("Malformed packet(b) (missing colon): %s\n\
3202 error (_("Remote sent bad register number %s: %s\n\
3204 phex_nz (pnum
, 0), p
, buf
);
3206 fieldsize
= hex2bin (p
, regs
,
3207 register_size (current_gdbarch
,
3210 if (fieldsize
< register_size (current_gdbarch
,
3212 warning (_("Remote reply is too short: %s"), buf
);
3213 regcache_raw_supply (current_regcache
,
3218 error (_("Remote register badly formatted: %s\nhere: %s"),
3223 case 'S': /* Old style status, just signal only. */
3224 status
->kind
= TARGET_WAITKIND_STOPPED
;
3225 status
->value
.sig
= (enum target_signal
)
3226 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3230 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3231 record_currthread (thread_num
);
3234 case 'W': /* Target exited. */
3236 /* The remote process exited. */
3237 status
->kind
= TARGET_WAITKIND_EXITED
;
3238 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3242 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3243 status
->value
.sig
= (enum target_signal
)
3244 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3248 case 'O': /* Console output. */
3249 remote_console_output (buf
+ 1);
3252 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3254 /* Zero length reply means that we tried 'S' or 'C' and
3255 the remote system doesn't support it. */
3256 target_terminal_ours_for_output ();
3258 ("Can't send signals to this remote system. %s not sent.\n",
3259 target_signal_to_name (last_sent_signal
));
3260 last_sent_signal
= TARGET_SIGNAL_0
;
3261 target_terminal_inferior ();
3263 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3264 putpkt ((char *) buf
);
3267 /* else fallthrough */
3269 warning (_("Invalid remote reply: %s"), buf
);
3274 if (thread_num
!= -1)
3276 return pid_to_ptid (thread_num
);
3278 return inferior_ptid
;
3281 /* Async version of remote_wait. */
3283 remote_async_wait (ptid_t ptid
, struct target_waitstatus
*status
)
3285 struct remote_state
*rs
= get_remote_state ();
3286 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3287 ULONGEST thread_num
= -1;
3290 status
->kind
= TARGET_WAITKIND_EXITED
;
3291 status
->value
.integer
= 0;
3293 remote_stopped_by_watchpoint_p
= 0;
3299 if (!target_is_async_p ())
3300 ofunc
= signal (SIGINT
, remote_interrupt
);
3301 /* FIXME: cagney/1999-09-27: If we're in async mode we should
3302 _never_ wait for ever -> test on target_is_async_p().
3303 However, before we do that we need to ensure that the caller
3304 knows how to take the target into/out of async mode. */
3305 getpkt (&rs
->buf
, &rs
->buf_size
, wait_forever_enabled_p
);
3306 if (!target_is_async_p ())
3307 signal (SIGINT
, ofunc
);
3311 /* This is a hook for when we need to do something (perhaps the
3312 collection of trace data) every time the target stops. */
3313 if (deprecated_target_wait_loop_hook
)
3314 (*deprecated_target_wait_loop_hook
) ();
3318 case 'E': /* Error of some sort. */
3319 warning (_("Remote failure reply: %s"), buf
);
3321 case 'F': /* File-I/O request. */
3322 remote_fileio_request (buf
);
3324 case 'T': /* Status with PC, SP, FP, ... */
3326 gdb_byte regs
[MAX_REGISTER_SIZE
];
3328 /* Expedited reply, containing Signal, {regno, reg} repeat. */
3329 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
3331 n... = register number
3332 r... = register contents
3334 p
= &buf
[3]; /* after Txx */
3343 /* If the packet contains a register number, save it
3344 in pnum and set p1 to point to the character
3345 following it. Otherwise p1 points to p. */
3347 /* If this packet is an awatch packet, don't parse the 'a'
3348 as a register number. */
3350 if (!strncmp (p
, "awatch", strlen ("awatch")) != 0)
3352 /* Read the register number. */
3353 pnum
= strtol (p
, &p_temp
, 16);
3359 if (p1
== p
) /* No register number present here. */
3361 p1
= strchr (p
, ':');
3363 error (_("Malformed packet(a) (missing colon): %s\n\
3366 if (strncmp (p
, "thread", p1
- p
) == 0)
3368 p_temp
= unpack_varlen_hex (++p1
, &thread_num
);
3369 record_currthread (thread_num
);
3372 else if ((strncmp (p
, "watch", p1
- p
) == 0)
3373 || (strncmp (p
, "rwatch", p1
- p
) == 0)
3374 || (strncmp (p
, "awatch", p1
- p
) == 0))
3376 remote_stopped_by_watchpoint_p
= 1;
3377 p
= unpack_varlen_hex (++p1
, &addr
);
3378 remote_watch_data_address
= (CORE_ADDR
)addr
;
3382 /* Silently skip unknown optional info. */
3383 p_temp
= strchr (p1
+ 1, ';');
3391 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
3394 error (_("Malformed packet(b) (missing colon): %s\n\
3399 error (_("Remote sent bad register number %ld: %s\n\
3403 fieldsize
= hex2bin (p
, regs
,
3404 register_size (current_gdbarch
,
3407 if (fieldsize
< register_size (current_gdbarch
,
3409 warning (_("Remote reply is too short: %s"), buf
);
3410 regcache_raw_supply (current_regcache
, reg
->regnum
, regs
);
3414 error (_("Remote register badly formatted: %s\nhere: %s"),
3419 case 'S': /* Old style status, just signal only. */
3420 status
->kind
= TARGET_WAITKIND_STOPPED
;
3421 status
->value
.sig
= (enum target_signal
)
3422 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3426 thread_num
= strtol ((const char *) &buf
[4], NULL
, 16);
3427 record_currthread (thread_num
);
3430 case 'W': /* Target exited. */
3432 /* The remote process exited. */
3433 status
->kind
= TARGET_WAITKIND_EXITED
;
3434 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
3438 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
3439 status
->value
.sig
= (enum target_signal
)
3440 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
3444 case 'O': /* Console output. */
3445 remote_console_output (buf
+ 1);
3446 /* Return immediately to the event loop. The event loop will
3447 still be waiting on the inferior afterwards. */
3448 status
->kind
= TARGET_WAITKIND_IGNORE
;
3451 if (last_sent_signal
!= TARGET_SIGNAL_0
)
3453 /* Zero length reply means that we tried 'S' or 'C' and
3454 the remote system doesn't support it. */
3455 target_terminal_ours_for_output ();
3457 ("Can't send signals to this remote system. %s not sent.\n",
3458 target_signal_to_name (last_sent_signal
));
3459 last_sent_signal
= TARGET_SIGNAL_0
;
3460 target_terminal_inferior ();
3462 strcpy ((char *) buf
, last_sent_step
? "s" : "c");
3463 putpkt ((char *) buf
);
3466 /* else fallthrough */
3468 warning (_("Invalid remote reply: %s"), buf
);
3473 if (thread_num
!= -1)
3475 return pid_to_ptid (thread_num
);
3477 return inferior_ptid
;
3480 /* Fetch a single register using a 'p' packet. */
3483 fetch_register_using_p (struct packet_reg
*reg
)
3485 struct remote_state
*rs
= get_remote_state ();
3487 char regp
[MAX_REGISTER_SIZE
];
3490 if (remote_protocol_packets
[PACKET_p
].support
== PACKET_DISABLE
)
3493 if (reg
->pnum
== -1)
3498 p
+= hexnumstr (p
, reg
->pnum
);
3500 remote_send (&rs
->buf
, &rs
->buf_size
);
3504 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
3508 case PACKET_UNKNOWN
:
3511 error (_("Could not fetch register \"%s\""),
3512 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3515 /* If this register is unfetchable, tell the regcache. */
3518 regcache_raw_supply (current_regcache
, reg
->regnum
, NULL
);
3519 set_register_cached (reg
->regnum
, -1);
3523 /* Otherwise, parse and supply the value. */
3529 error (_("fetch_register_using_p: early buf termination"));
3531 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3534 regcache_raw_supply (current_regcache
, reg
->regnum
, regp
);
3538 /* Fetch the registers included in the target's 'g' packet. */
3541 send_g_packet (void)
3543 struct remote_state
*rs
= get_remote_state ();
3548 sprintf (rs
->buf
, "g");
3549 remote_send (&rs
->buf
, &rs
->buf_size
);
3551 /* We can get out of synch in various cases. If the first character
3552 in the buffer is not a hex character, assume that has happened
3553 and try to fetch another packet to read. */
3554 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
3555 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
3556 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
3557 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
3560 fprintf_unfiltered (gdb_stdlog
,
3561 "Bad register packet; fetching a new packet\n");
3562 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3565 buf_len
= strlen (rs
->buf
);
3567 /* Sanity check the received packet. */
3568 if (buf_len
% 2 != 0)
3569 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
3575 process_g_packet (void)
3577 struct remote_state
*rs
= get_remote_state ();
3578 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3583 buf_len
= strlen (rs
->buf
);
3585 /* Further sanity checks, with knowledge of the architecture. */
3586 if (REGISTER_BYTES_OK_P () && !REGISTER_BYTES_OK (buf_len
/ 2))
3587 error (_("Remote 'g' packet reply is wrong length: %s"), rs
->buf
);
3588 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
3589 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
3591 /* Save the size of the packet sent to us by the target. It is used
3592 as a heuristic when determining the max size of packets that the
3593 target can safely receive. */
3594 if (rsa
->actual_register_packet_size
== 0)
3595 rsa
->actual_register_packet_size
= buf_len
;
3597 /* If this is smaller than we guessed the 'g' packet would be,
3598 update our records. A 'g' reply that doesn't include a register's
3599 value implies either that the register is not available, or that
3600 the 'p' packet must be used. */
3601 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
3603 rsa
->sizeof_g_packet
= buf_len
/ 2;
3605 for (i
= 0; i
< NUM_REGS
; i
++)
3607 if (rsa
->regs
[i
].pnum
== -1)
3610 if (rsa
->regs
[i
].offset
>= rsa
->sizeof_g_packet
)
3611 rsa
->regs
[i
].in_g_packet
= 0;
3613 rsa
->regs
[i
].in_g_packet
= 1;
3617 regs
= alloca (rsa
->sizeof_g_packet
);
3619 /* Unimplemented registers read as all bits zero. */
3620 memset (regs
, 0, rsa
->sizeof_g_packet
);
3622 /* Reply describes registers byte by byte, each byte encoded as two
3623 hex characters. Suck them all up, then supply them to the
3624 register cacheing/storage mechanism. */
3627 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
3629 if (p
[0] == 0 || p
[1] == 0)
3630 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
3631 internal_error (__FILE__
, __LINE__
,
3632 "unexpected end of 'g' packet reply");
3634 if (p
[0] == 'x' && p
[1] == 'x')
3635 regs
[i
] = 0; /* 'x' */
3637 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
3643 for (i
= 0; i
< NUM_REGS
; i
++)
3645 struct packet_reg
*r
= &rsa
->regs
[i
];
3648 if (r
->offset
* 2 >= strlen (rs
->buf
))
3649 /* This shouldn't happen - we adjusted in_g_packet above. */
3650 internal_error (__FILE__
, __LINE__
,
3651 "unexpected end of 'g' packet reply");
3652 else if (rs
->buf
[r
->offset
* 2] == 'x')
3654 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
3655 /* The register isn't available, mark it as such (at
3656 the same time setting the value to zero). */
3657 regcache_raw_supply (current_regcache
, r
->regnum
, NULL
);
3658 set_register_cached (i
, -1);
3661 regcache_raw_supply (current_regcache
, r
->regnum
,
3669 fetch_registers_using_g (void)
3672 process_g_packet ();
3676 remote_fetch_registers (int regnum
)
3678 struct remote_state
*rs
= get_remote_state ();
3679 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3682 set_thread (PIDGET (inferior_ptid
), 1);
3686 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3687 gdb_assert (reg
!= NULL
);
3689 /* If this register might be in the 'g' packet, try that first -
3690 we are likely to read more than one register. If this is the
3691 first 'g' packet, we might be overly optimistic about its
3692 contents, so fall back to 'p'. */
3693 if (reg
->in_g_packet
)
3695 fetch_registers_using_g ();
3696 if (reg
->in_g_packet
)
3700 if (fetch_register_using_p (reg
))
3703 /* This register is not available. */
3704 regcache_raw_supply (current_regcache
, reg
->regnum
, NULL
);
3705 set_register_cached (reg
->regnum
, -1);
3710 fetch_registers_using_g ();
3712 for (i
= 0; i
< NUM_REGS
; i
++)
3713 if (!rsa
->regs
[i
].in_g_packet
)
3714 if (!fetch_register_using_p (&rsa
->regs
[i
]))
3716 /* This register is not available. */
3717 regcache_raw_supply (current_regcache
, i
, NULL
);
3718 set_register_cached (i
, -1);
3722 /* Prepare to store registers. Since we may send them all (using a
3723 'G' request), we have to read out the ones we don't want to change
3727 remote_prepare_to_store (void)
3729 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3731 gdb_byte buf
[MAX_REGISTER_SIZE
];
3733 /* Make sure the entire registers array is valid. */
3734 switch (remote_protocol_packets
[PACKET_P
].support
)
3736 case PACKET_DISABLE
:
3737 case PACKET_SUPPORT_UNKNOWN
:
3738 /* Make sure all the necessary registers are cached. */
3739 for (i
= 0; i
< NUM_REGS
; i
++)
3740 if (rsa
->regs
[i
].in_g_packet
)
3741 regcache_raw_read (current_regcache
, rsa
->regs
[i
].regnum
, buf
);
3748 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
3749 packet was not recognized. */
3752 store_register_using_P (struct packet_reg
*reg
)
3754 struct remote_state
*rs
= get_remote_state ();
3755 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3756 /* Try storing a single register. */
3757 char *buf
= rs
->buf
;
3758 gdb_byte regp
[MAX_REGISTER_SIZE
];
3761 if (remote_protocol_packets
[PACKET_P
].support
== PACKET_DISABLE
)
3764 if (reg
->pnum
== -1)
3767 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
3768 p
= buf
+ strlen (buf
);
3769 regcache_raw_collect (current_regcache
, reg
->regnum
, regp
);
3770 bin2hex (regp
, p
, register_size (current_gdbarch
, reg
->regnum
));
3771 remote_send (&rs
->buf
, &rs
->buf_size
);
3773 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
3778 error (_("Could not write register \"%s\""),
3779 gdbarch_register_name (current_gdbarch
, reg
->regnum
));
3780 case PACKET_UNKNOWN
:
3783 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
3787 /* Store register REGNUM, or all registers if REGNUM == -1, from the
3788 contents of the register cache buffer. FIXME: ignores errors. */
3791 store_registers_using_G (void)
3793 struct remote_state
*rs
= get_remote_state ();
3794 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3798 /* Extract all the registers in the regcache copying them into a
3802 regs
= alloca (rsa
->sizeof_g_packet
);
3803 memset (regs
, 0, rsa
->sizeof_g_packet
);
3804 for (i
= 0; i
< NUM_REGS
; i
++)
3806 struct packet_reg
*r
= &rsa
->regs
[i
];
3808 regcache_raw_collect (current_regcache
, r
->regnum
, regs
+ r
->offset
);
3812 /* Command describes registers byte by byte,
3813 each byte encoded as two hex characters. */
3816 /* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
3818 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
3819 remote_send (&rs
->buf
, &rs
->buf_size
);
3822 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3823 of the register cache buffer. FIXME: ignores errors. */
3826 remote_store_registers (int regnum
)
3828 struct remote_state
*rs
= get_remote_state ();
3829 struct remote_arch_state
*rsa
= get_remote_arch_state ();
3832 set_thread (PIDGET (inferior_ptid
), 1);
3836 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
3837 gdb_assert (reg
!= NULL
);
3839 /* Always prefer to store registers using the 'P' packet if
3840 possible; we often change only a small number of registers.
3841 Sometimes we change a larger number; we'd need help from a
3842 higher layer to know to use 'G'. */
3843 if (store_register_using_P (reg
))
3846 /* For now, don't complain if we have no way to write the
3847 register. GDB loses track of unavailable registers too
3848 easily. Some day, this may be an error. We don't have
3849 any way to read the register, either... */
3850 if (!reg
->in_g_packet
)
3853 store_registers_using_G ();
3857 store_registers_using_G ();
3859 for (i
= 0; i
< NUM_REGS
; i
++)
3860 if (!rsa
->regs
[i
].in_g_packet
)
3861 if (!store_register_using_P (&rsa
->regs
[i
]))
3862 /* See above for why we do not issue an error here. */
3867 /* Return the number of hex digits in num. */
3870 hexnumlen (ULONGEST num
)
3874 for (i
= 0; num
!= 0; i
++)
3880 /* Set BUF to the minimum number of hex digits representing NUM. */
3883 hexnumstr (char *buf
, ULONGEST num
)
3885 int len
= hexnumlen (num
);
3886 return hexnumnstr (buf
, num
, len
);
3890 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
3893 hexnumnstr (char *buf
, ULONGEST num
, int width
)
3899 for (i
= width
- 1; i
>= 0; i
--)
3901 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
3908 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3911 remote_address_masked (CORE_ADDR addr
)
3913 if (remote_address_size
> 0
3914 && remote_address_size
< (sizeof (ULONGEST
) * 8))
3916 /* Only create a mask when that mask can safely be constructed
3917 in a ULONGEST variable. */
3919 mask
= (mask
<< remote_address_size
) - 1;
3925 /* Convert BUFFER, binary data at least LEN bytes long, into escaped
3926 binary data in OUT_BUF. Set *OUT_LEN to the length of the data
3927 encoded in OUT_BUF, and return the number of bytes in OUT_BUF
3928 (which may be more than *OUT_LEN due to escape characters). The
3929 total number of bytes in the output buffer will be at most
3933 remote_escape_output (const gdb_byte
*buffer
, int len
,
3934 gdb_byte
*out_buf
, int *out_len
,
3937 int input_index
, output_index
;
3940 for (input_index
= 0; input_index
< len
; input_index
++)
3942 gdb_byte b
= buffer
[input_index
];
3944 if (b
== '$' || b
== '#' || b
== '}')
3946 /* These must be escaped. */
3947 if (output_index
+ 2 > out_maxlen
)
3949 out_buf
[output_index
++] = '}';
3950 out_buf
[output_index
++] = b
^ 0x20;
3954 if (output_index
+ 1 > out_maxlen
)
3956 out_buf
[output_index
++] = b
;
3960 *out_len
= input_index
;
3961 return output_index
;
3964 /* Convert BUFFER, escaped data LEN bytes long, into binary data
3965 in OUT_BUF. Return the number of bytes written to OUT_BUF.
3966 Raise an error if the total number of bytes exceeds OUT_MAXLEN.
3968 This function reverses remote_escape_output. It allows more
3969 escaped characters than that function does, in particular because
3970 '*' must be escaped to avoid the run-length encoding processing
3971 in reading packets. */
3974 remote_unescape_input (const gdb_byte
*buffer
, int len
,
3975 gdb_byte
*out_buf
, int out_maxlen
)
3977 int input_index
, output_index
;
3982 for (input_index
= 0; input_index
< len
; input_index
++)
3984 gdb_byte b
= buffer
[input_index
];
3986 if (output_index
+ 1 > out_maxlen
)
3988 warning (_("Received too much data from remote target;"
3989 " ignoring overflow."));
3990 return output_index
;
3995 out_buf
[output_index
++] = b
^ 0x20;
4001 out_buf
[output_index
++] = b
;
4005 error (_("Unmatched escape character in target response."));
4007 return output_index
;
4010 /* Determine whether the remote target supports binary downloading.
4011 This is accomplished by sending a no-op memory write of zero length
4012 to the target at the specified address. It does not suffice to send
4013 the whole packet, since many stubs strip the eighth bit and
4014 subsequently compute a wrong checksum, which causes real havoc with
4017 NOTE: This can still lose if the serial line is not eight-bit
4018 clean. In cases like this, the user should clear "remote
4022 check_binary_download (CORE_ADDR addr
)
4024 struct remote_state
*rs
= get_remote_state ();
4026 switch (remote_protocol_packets
[PACKET_X
].support
)
4028 case PACKET_DISABLE
:
4032 case PACKET_SUPPORT_UNKNOWN
:
4038 p
+= hexnumstr (p
, (ULONGEST
) addr
);
4040 p
+= hexnumstr (p
, (ULONGEST
) 0);
4044 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4045 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4047 if (rs
->buf
[0] == '\0')
4050 fprintf_unfiltered (gdb_stdlog
,
4051 "binary downloading NOT suppported by target\n");
4052 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
4057 fprintf_unfiltered (gdb_stdlog
,
4058 "binary downloading suppported by target\n");
4059 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
4066 /* Write memory data directly to the remote machine.
4067 This does not inform the data cache; the data cache uses this.
4068 HEADER is the starting part of the packet.
4069 MEMADDR is the address in the remote memory space.
4070 MYADDR is the address of the buffer in our space.
4071 LEN is the number of bytes.
4072 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
4073 should send data as binary ('X'), or hex-encoded ('M').
4075 The function creates packet of the form
4076 <HEADER><ADDRESS>,<LENGTH>:<DATA>
4078 where encoding of <DATA> is termined by PACKET_FORMAT.
4080 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
4083 Returns the number of bytes transferred, or 0 (setting errno) for
4084 error. Only transfer a single packet. */
4087 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
4088 const gdb_byte
*myaddr
, int len
,
4089 char packet_format
, int use_length
)
4091 struct remote_state
*rs
= get_remote_state ();
4101 if (packet_format
!= 'X' && packet_format
!= 'M')
4102 internal_error (__FILE__
, __LINE__
,
4103 "remote_write_bytes_aux: bad packet format");
4105 /* Should this be the selected frame? */
4106 gdbarch_remote_translate_xfer_address (current_gdbarch
,
4114 payload_size
= get_memory_write_packet_size ();
4116 /* The packet buffer will be large enough for the payload;
4117 get_memory_packet_size ensures this. */
4120 /* Compute the size of the actual payload by subtracting out the
4121 packet header and footer overhead: "$M<memaddr>,<len>:...#nn".
4123 payload_size
-= strlen ("$,:#NN");
4125 /* The comma won't be used. */
4127 header_length
= strlen (header
);
4128 payload_size
-= header_length
;
4129 payload_size
-= hexnumlen (memaddr
);
4131 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
4133 strcat (rs
->buf
, header
);
4134 p
= rs
->buf
+ strlen (header
);
4136 /* Compute a best guess of the number of bytes actually transfered. */
4137 if (packet_format
== 'X')
4139 /* Best guess at number of bytes that will fit. */
4140 todo
= min (len
, payload_size
);
4142 payload_size
-= hexnumlen (todo
);
4143 todo
= min (todo
, payload_size
);
4147 /* Num bytes that will fit. */
4148 todo
= min (len
, payload_size
/ 2);
4150 payload_size
-= hexnumlen (todo
);
4151 todo
= min (todo
, payload_size
/ 2);
4155 internal_error (__FILE__
, __LINE__
,
4156 _("minumum packet size too small to write data"));
4158 /* If we already need another packet, then try to align the end
4159 of this packet to a useful boundary. */
4160 if (todo
> 2 * REMOTE_ALIGN_WRITES
&& todo
< len
)
4161 todo
= ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
4163 /* Append "<memaddr>". */
4164 memaddr
= remote_address_masked (memaddr
);
4165 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4172 /* Append <len>. Retain the location/size of <len>. It may need to
4173 be adjusted once the packet body has been created. */
4175 plenlen
= hexnumstr (p
, (ULONGEST
) todo
);
4183 /* Append the packet body. */
4184 if (packet_format
== 'X')
4186 /* Binary mode. Send target system values byte by byte, in
4187 increasing byte addresses. Only escape certain critical
4189 payload_length
= remote_escape_output (myaddr
, todo
, p
, &nr_bytes
,
4192 /* If not all TODO bytes fit, then we'll need another packet. Make
4193 a second try to keep the end of the packet aligned. Don't do
4194 this if the packet is tiny. */
4195 if (nr_bytes
< todo
&& nr_bytes
> 2 * REMOTE_ALIGN_WRITES
)
4199 new_nr_bytes
= (((memaddr
+ nr_bytes
) & ~(REMOTE_ALIGN_WRITES
- 1))
4201 if (new_nr_bytes
!= nr_bytes
)
4202 payload_length
= remote_escape_output (myaddr
, new_nr_bytes
,
4207 p
+= payload_length
;
4208 if (use_length
&& nr_bytes
< todo
)
4210 /* Escape chars have filled up the buffer prematurely,
4211 and we have actually sent fewer bytes than planned.
4212 Fix-up the length field of the packet. Use the same
4213 number of characters as before. */
4214 plen
+= hexnumnstr (plen
, (ULONGEST
) nr_bytes
, plenlen
);
4215 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
4220 /* Normal mode: Send target system values byte by byte, in
4221 increasing byte addresses. Each byte is encoded as a two hex
4223 nr_bytes
= bin2hex (myaddr
, p
, todo
);
4227 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
4228 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4230 if (rs
->buf
[0] == 'E')
4232 /* There is no correspondance between what the remote protocol
4233 uses for errors and errno codes. We would like a cleaner way
4234 of representing errors (big enough to include errno codes,
4235 bfd_error codes, and others). But for now just return EIO. */
4240 /* Return NR_BYTES, not TODO, in case escape chars caused us to send
4241 fewer bytes than we'd planned. */
4245 /* Write memory data directly to the remote machine.
4246 This does not inform the data cache; the data cache uses this.
4247 MEMADDR is the address in the remote memory space.
4248 MYADDR is the address of the buffer in our space.
4249 LEN is the number of bytes.
4251 Returns number of bytes transferred, or 0 (setting errno) for
4252 error. Only transfer a single packet. */
4255 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
4257 char *packet_format
= 0;
4259 /* Check whether the target supports binary download. */
4260 check_binary_download (memaddr
);
4262 switch (remote_protocol_packets
[PACKET_X
].support
)
4265 packet_format
= "X";
4267 case PACKET_DISABLE
:
4268 packet_format
= "M";
4270 case PACKET_SUPPORT_UNKNOWN
:
4271 internal_error (__FILE__
, __LINE__
,
4272 _("remote_write_bytes: bad internal state"));
4274 internal_error (__FILE__
, __LINE__
, _("bad switch"));
4277 return remote_write_bytes_aux (packet_format
,
4278 memaddr
, myaddr
, len
, packet_format
[0], 1);
4281 /* Read memory data directly from the remote machine.
4282 This does not use the data cache; the data cache uses this.
4283 MEMADDR is the address in the remote memory space.
4284 MYADDR is the address of the buffer in our space.
4285 LEN is the number of bytes.
4287 Returns number of bytes transferred, or 0 for error. */
4289 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
4290 remote targets) shouldn't attempt to read the entire buffer.
4291 Instead it should read a single packet worth of data and then
4292 return the byte size of that packet to the caller. The caller (its
4293 caller and its callers caller ;-) already contains code for
4294 handling partial reads. */
4297 remote_read_bytes (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
4299 struct remote_state
*rs
= get_remote_state ();
4300 int max_buf_size
; /* Max size of packet output buffer. */
4303 /* Should this be the selected frame? */
4304 gdbarch_remote_translate_xfer_address (current_gdbarch
,
4312 max_buf_size
= get_memory_read_packet_size ();
4313 /* The packet buffer will be large enough for the payload;
4314 get_memory_packet_size ensures this. */
4323 todo
= min (len
, max_buf_size
/ 2); /* num bytes that will fit */
4325 /* construct "m"<memaddr>","<len>" */
4326 /* sprintf (rs->buf, "m%lx,%x", (unsigned long) memaddr, todo); */
4327 memaddr
= remote_address_masked (memaddr
);
4330 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
4332 p
+= hexnumstr (p
, (ULONGEST
) todo
);
4336 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4338 if (rs
->buf
[0] == 'E'
4339 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
4340 && rs
->buf
[3] == '\0')
4342 /* There is no correspondance between what the remote
4343 protocol uses for errors and errno codes. We would like
4344 a cleaner way of representing errors (big enough to
4345 include errno codes, bfd_error codes, and others). But
4346 for now just return EIO. */
4351 /* Reply describes memory byte by byte,
4352 each byte encoded as two hex characters. */
4355 if ((i
= hex2bin (p
, myaddr
, todo
)) < todo
)
4357 /* Reply is short. This means that we were able to read
4358 only part of what we wanted to. */
4359 return i
+ (origlen
- len
);
4368 /* Read or write LEN bytes from inferior memory at MEMADDR,
4369 transferring to or from debugger address BUFFER. Write to inferior
4370 if SHOULD_WRITE is nonzero. Returns length of data written or
4371 read; 0 for error. TARGET is unused. */
4374 remote_xfer_memory (CORE_ADDR mem_addr
, gdb_byte
*buffer
, int mem_len
,
4375 int should_write
, struct mem_attrib
*attrib
,
4376 struct target_ops
*target
)
4381 res
= remote_write_bytes (mem_addr
, buffer
, mem_len
);
4383 res
= remote_read_bytes (mem_addr
, buffer
, mem_len
);
4388 /* Sends a packet with content determined by the printf format string
4389 FORMAT and the remaining arguments, then gets the reply. Returns
4390 whether the packet was a success, a failure, or unknown. */
4393 remote_send_printf (const char *format
, ...)
4395 struct remote_state
*rs
= get_remote_state ();
4396 int max_size
= get_remote_packet_size ();
4399 va_start (ap
, format
);
4402 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
4403 internal_error (__FILE__
, __LINE__
, "Too long remote packet.");
4405 if (putpkt (rs
->buf
) < 0)
4406 error (_("Communication problem with target."));
4409 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4411 return packet_check_result (rs
->buf
);
4415 restore_remote_timeout (void *p
)
4417 int value
= *(int *)p
;
4418 remote_timeout
= value
;
4421 /* Flash writing can take quite some time. We'll set
4422 effectively infinite timeout for flash operations.
4423 In future, we'll need to decide on a better approach. */
4424 static const int remote_flash_timeout
= 1000;
4427 remote_flash_erase (struct target_ops
*ops
,
4428 ULONGEST address
, LONGEST length
)
4430 int saved_remote_timeout
= remote_timeout
;
4431 enum packet_result ret
;
4433 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4434 &saved_remote_timeout
);
4435 remote_timeout
= remote_flash_timeout
;
4437 ret
= remote_send_printf ("vFlashErase:%s,%s",
4442 case PACKET_UNKNOWN
:
4443 error (_("Remote target does not support flash erase"));
4445 error (_("Error erasing flash with vFlashErase packet"));
4450 do_cleanups (back_to
);
4454 remote_flash_write (struct target_ops
*ops
,
4455 ULONGEST address
, LONGEST length
,
4456 const gdb_byte
*data
)
4458 int saved_remote_timeout
= remote_timeout
;
4460 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4461 &saved_remote_timeout
);
4463 remote_timeout
= remote_flash_timeout
;
4464 ret
= remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 'X', 0);
4465 do_cleanups (back_to
);
4471 remote_flash_done (struct target_ops
*ops
)
4473 int saved_remote_timeout
= remote_timeout
;
4475 struct cleanup
*back_to
= make_cleanup (restore_remote_timeout
,
4476 &saved_remote_timeout
);
4478 remote_timeout
= remote_flash_timeout
;
4479 ret
= remote_send_printf ("vFlashDone");
4480 do_cleanups (back_to
);
4484 case PACKET_UNKNOWN
:
4485 error (_("Remote target does not support vFlashDone"));
4487 error (_("Error finishing flash operation"));
4494 remote_files_info (struct target_ops
*ignore
)
4496 puts_filtered ("Debugging a target over a serial line.\n");
4499 /* Stuff for dealing with the packets which are part of this protocol.
4500 See comment at top of file for details. */
4502 /* Read a single character from the remote end. */
4505 readchar (int timeout
)
4509 ch
= serial_readchar (remote_desc
, timeout
);
4514 switch ((enum serial_rc
) ch
)
4517 target_mourn_inferior ();
4518 error (_("Remote connection closed"));
4521 perror_with_name (_("Remote communication error"));
4523 case SERIAL_TIMEOUT
:
4529 /* Send the command in *BUF to the remote machine, and read the reply
4530 into *BUF. Report an error if we get an error reply. Resize
4531 *BUF using xrealloc if necessary to hold the result, and update
4535 remote_send (char **buf
,
4539 getpkt (buf
, sizeof_buf
, 0);
4541 if ((*buf
)[0] == 'E')
4542 error (_("Remote failure reply: %s"), *buf
);
4545 /* Display a null-terminated packet on stdout, for debugging, using C
4549 print_packet (char *buf
)
4551 puts_filtered ("\"");
4552 fputstr_filtered (buf
, '"', gdb_stdout
);
4553 puts_filtered ("\"");
4559 return putpkt_binary (buf
, strlen (buf
));
4562 /* Send a packet to the remote machine, with error checking. The data
4563 of the packet is in BUF. The string in BUF can be at most
4564 get_remote_packet_size () - 5 to account for the $, # and checksum,
4565 and for a possible /0 if we are debugging (remote_debug) and want
4566 to print the sent packet as a string. */
4569 putpkt_binary (char *buf
, int cnt
)
4572 unsigned char csum
= 0;
4573 char *buf2
= alloca (cnt
+ 6);
4579 /* Copy the packet into buffer BUF2, encapsulating it
4580 and giving it a checksum. */
4585 for (i
= 0; i
< cnt
; i
++)
4591 *p
++ = tohex ((csum
>> 4) & 0xf);
4592 *p
++ = tohex (csum
& 0xf);
4594 /* Send it over and over until we get a positive ack. */
4598 int started_error_output
= 0;
4603 fprintf_unfiltered (gdb_stdlog
, "Sending packet: ");
4604 fputstrn_unfiltered (buf2
, p
- buf2
, 0, gdb_stdlog
);
4605 fprintf_unfiltered (gdb_stdlog
, "...");
4606 gdb_flush (gdb_stdlog
);
4608 if (serial_write (remote_desc
, buf2
, p
- buf2
))
4609 perror_with_name (_("putpkt: write failed"));
4611 /* Read until either a timeout occurs (-2) or '+' is read. */
4614 ch
= readchar (remote_timeout
);
4622 case SERIAL_TIMEOUT
:
4624 if (started_error_output
)
4626 putchar_unfiltered ('\n');
4627 started_error_output
= 0;
4636 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
4640 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
4641 case SERIAL_TIMEOUT
:
4645 break; /* Retransmit buffer. */
4649 fprintf_unfiltered (gdb_stdlog
,
4650 "Packet instead of Ack, ignoring it\n");
4651 /* It's probably an old response sent because an ACK
4652 was lost. Gobble up the packet and ack it so it
4653 doesn't get retransmitted when we resend this
4656 serial_write (remote_desc
, "+", 1);
4657 continue; /* Now, go look for +. */
4662 if (!started_error_output
)
4664 started_error_output
= 1;
4665 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
4667 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
4671 break; /* Here to retransmit. */
4675 /* This is wrong. If doing a long backtrace, the user should be
4676 able to get out next time we call QUIT, without anything as
4677 violent as interrupt_query. If we want to provide a way out of
4678 here without getting to the next QUIT, it should be based on
4679 hitting ^C twice as in remote_wait. */
4689 /* Come here after finding the start of a frame when we expected an
4690 ack. Do our best to discard the rest of this packet. */
4699 c
= readchar (remote_timeout
);
4702 case SERIAL_TIMEOUT
:
4703 /* Nothing we can do. */
4706 /* Discard the two bytes of checksum and stop. */
4707 c
= readchar (remote_timeout
);
4709 c
= readchar (remote_timeout
);
4712 case '*': /* Run length encoding. */
4713 /* Discard the repeat count. */
4714 c
= readchar (remote_timeout
);
4719 /* A regular character. */
4725 /* Come here after finding the start of the frame. Collect the rest
4726 into *BUF, verifying the checksum, length, and handling run-length
4727 compression. NUL terminate the buffer. If there is not enough room,
4728 expand *BUF using xrealloc.
4730 Returns -1 on error, number of characters in buffer (ignoring the
4731 trailing NULL) on success. (could be extended to return one of the
4732 SERIAL status indications). */
4735 read_frame (char **buf_p
,
4748 c
= readchar (remote_timeout
);
4751 case SERIAL_TIMEOUT
:
4753 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
4757 fputs_filtered ("Saw new packet start in middle of old one\n",
4759 return -1; /* Start a new packet, count retries. */
4762 unsigned char pktcsum
;
4768 check_0
= readchar (remote_timeout
);
4770 check_1
= readchar (remote_timeout
);
4772 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
4775 fputs_filtered ("Timeout in checksum, retrying\n",
4779 else if (check_0
< 0 || check_1
< 0)
4782 fputs_filtered ("Communication error in checksum\n",
4787 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
4788 if (csum
== pktcsum
)
4793 fprintf_filtered (gdb_stdlog
,
4794 "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4796 fputstrn_filtered (buf
, bc
, 0, gdb_stdlog
);
4797 fputs_filtered ("\n", gdb_stdlog
);
4799 /* Number of characters in buffer ignoring trailing
4803 case '*': /* Run length encoding. */
4808 c
= readchar (remote_timeout
);
4810 repeat
= c
- ' ' + 3; /* Compute repeat count. */
4812 /* The character before ``*'' is repeated. */
4814 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
4816 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
4818 /* Make some more room in the buffer. */
4819 *sizeof_buf
+= repeat
;
4820 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4824 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
4830 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
4834 if (bc
>= *sizeof_buf
- 1)
4836 /* Make some more room in the buffer. */
4838 *buf_p
= xrealloc (*buf_p
, *sizeof_buf
);
4849 /* Read a packet from the remote machine, with error checking, and
4850 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4851 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4852 rather than timing out; this is used (in synchronous mode) to wait
4853 for a target that is is executing user code to stop. */
4854 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4855 don't have to change all the calls to getpkt to deal with the
4856 return value, because at the moment I don't know what the right
4857 thing to do it for those. */
4865 timed_out
= getpkt_sane (buf
, sizeof_buf
, forever
);
4869 /* Read a packet from the remote machine, with error checking, and
4870 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
4871 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
4872 rather than timing out; this is used (in synchronous mode) to wait
4873 for a target that is is executing user code to stop. If FOREVER ==
4874 0, this function is allowed to time out gracefully and return an
4875 indication of this to the caller. Otherwise return the number
4878 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
4885 strcpy (*buf
, "timeout");
4889 timeout
= watchdog
> 0 ? watchdog
: -1;
4893 timeout
= remote_timeout
;
4897 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
4899 /* This can loop forever if the remote side sends us characters
4900 continuously, but if it pauses, we'll get a zero from
4901 readchar because of timeout. Then we'll count that as a
4904 /* Note that we will only wait forever prior to the start of a
4905 packet. After that, we expect characters to arrive at a
4906 brisk pace. They should show up within remote_timeout
4911 c
= readchar (timeout
);
4913 if (c
== SERIAL_TIMEOUT
)
4915 if (forever
) /* Watchdog went off? Kill the target. */
4918 target_mourn_inferior ();
4919 error (_("Watchdog has expired. Target detached."));
4922 fputs_filtered ("Timed out.\n", gdb_stdlog
);
4928 /* We've found the start of a packet, now collect the data. */
4930 val
= read_frame (buf
, sizeof_buf
);
4936 fprintf_unfiltered (gdb_stdlog
, "Packet received: ");
4937 fputstrn_unfiltered (*buf
, val
, 0, gdb_stdlog
);
4938 fprintf_unfiltered (gdb_stdlog
, "\n");
4940 serial_write (remote_desc
, "+", 1);
4944 /* Try the whole thing again. */
4946 serial_write (remote_desc
, "-", 1);
4949 /* We have tried hard enough, and just can't receive the packet.
4952 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
4953 serial_write (remote_desc
, "+", 1);
4960 /* For some mysterious reason, wait_for_inferior calls kill instead of
4961 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4965 target_mourn_inferior ();
4969 /* Use catch_errors so the user can quit from gdb even when we aren't on
4970 speaking terms with the remote system. */
4971 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4973 /* Don't wait for it to die. I'm not really sure it matters whether
4974 we do or not. For the existing stubs, kill is a noop. */
4975 target_mourn_inferior ();
4978 /* Async version of remote_kill. */
4980 remote_async_kill (void)
4982 /* Unregister the file descriptor from the event loop. */
4983 if (target_is_async_p ())
4984 serial_async (remote_desc
, NULL
, 0);
4986 /* For some mysterious reason, wait_for_inferior calls kill instead of
4987 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
4991 target_mourn_inferior ();
4995 /* Use catch_errors so the user can quit from gdb even when we
4996 aren't on speaking terms with the remote system. */
4997 catch_errors ((catch_errors_ftype
*) putpkt
, "k", "", RETURN_MASK_ERROR
);
4999 /* Don't wait for it to die. I'm not really sure it matters whether
5000 we do or not. For the existing stubs, kill is a noop. */
5001 target_mourn_inferior ();
5007 remote_mourn_1 (&remote_ops
);
5011 remote_async_mourn (void)
5013 remote_mourn_1 (&remote_async_ops
);
5017 extended_remote_mourn (void)
5019 /* We do _not_ want to mourn the target like this; this will
5020 remove the extended remote target from the target stack,
5021 and the next time the user says "run" it'll fail.
5023 FIXME: What is the right thing to do here? */
5025 remote_mourn_1 (&extended_remote_ops
);
5029 /* Worker function for remote_mourn. */
5031 remote_mourn_1 (struct target_ops
*target
)
5033 unpush_target (target
);
5034 generic_mourn_inferior ();
5037 /* In the extended protocol we want to be able to do things like
5038 "run" and have them basically work as expected. So we need
5039 a special create_inferior function.
5041 FIXME: One day add support for changing the exec file
5042 we're debugging, arguments and an environment. */
5045 extended_remote_create_inferior (char *exec_file
, char *args
,
5046 char **env
, int from_tty
)
5048 /* Rip out the breakpoints; we'll reinsert them after restarting
5049 the remote server. */
5050 remove_breakpoints ();
5052 /* Now restart the remote server. */
5053 extended_remote_restart ();
5055 /* NOTE: We don't need to recheck for a target description here; but
5056 if we gain the ability to switch the remote executable we may
5057 need to, if for instance we are running a process which requested
5058 different emulated hardware from the operating system. A
5059 concrete example of this is ARM GNU/Linux, where some binaries
5060 will have a legacy FPA coprocessor emulated and others may have
5061 access to a hardware VFP unit. */
5063 /* Now put the breakpoints back in. This way we're safe if the
5064 restart function works via a unix fork on the remote side. */
5065 insert_breakpoints ();
5067 /* Clean up from the last time we were running. */
5068 clear_proceed_status ();
5071 /* Async version of extended_remote_create_inferior. */
5073 extended_remote_async_create_inferior (char *exec_file
, char *args
,
5074 char **env
, int from_tty
)
5076 /* Rip out the breakpoints; we'll reinsert them after restarting
5077 the remote server. */
5078 remove_breakpoints ();
5080 /* If running asynchronously, register the target file descriptor
5081 with the event loop. */
5082 if (target_can_async_p ())
5083 target_async (inferior_event_handler
, 0);
5085 /* Now restart the remote server. */
5086 extended_remote_restart ();
5088 /* NOTE: We don't need to recheck for a target description here; but
5089 if we gain the ability to switch the remote executable we may
5090 need to, if for instance we are running a process which requested
5091 different emulated hardware from the operating system. A
5092 concrete example of this is ARM GNU/Linux, where some binaries
5093 will have a legacy FPA coprocessor emulated and others may have
5094 access to a hardware VFP unit. */
5096 /* Now put the breakpoints back in. This way we're safe if the
5097 restart function works via a unix fork on the remote side. */
5098 insert_breakpoints ();
5100 /* Clean up from the last time we were running. */
5101 clear_proceed_status ();
5105 /* On some machines, e.g. 68k, we may use a different breakpoint
5106 instruction than other targets; in those use
5107 DEPRECATED_REMOTE_BREAKPOINT instead of just BREAKPOINT_FROM_PC.
5108 Also, bi-endian targets may define
5109 DEPRECATED_LITTLE_REMOTE_BREAKPOINT and
5110 DEPRECATED_BIG_REMOTE_BREAKPOINT. If none of these are defined, we
5111 just call the standard routines that are in mem-break.c. */
5113 /* NOTE: cagney/2003-06-08: This is silly. A remote and simulator
5114 target should use an identical BREAKPOINT_FROM_PC. As for native,
5115 the ARCH-OS-tdep.c code can override the default. */
5117 #if defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && defined (DEPRECATED_BIG_REMOTE_BREAKPOINT) && !defined(DEPRECATED_REMOTE_BREAKPOINT)
5118 #define DEPRECATED_REMOTE_BREAKPOINT
5121 #ifdef DEPRECATED_REMOTE_BREAKPOINT
5123 /* If the target isn't bi-endian, just pretend it is. */
5124 #if !defined (DEPRECATED_LITTLE_REMOTE_BREAKPOINT) && !defined (DEPRECATED_BIG_REMOTE_BREAKPOINT)
5125 #define DEPRECATED_LITTLE_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
5126 #define DEPRECATED_BIG_REMOTE_BREAKPOINT DEPRECATED_REMOTE_BREAKPOINT
5129 static unsigned char big_break_insn
[] = DEPRECATED_BIG_REMOTE_BREAKPOINT
;
5130 static unsigned char little_break_insn
[] = DEPRECATED_LITTLE_REMOTE_BREAKPOINT
;
5132 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
5134 /* Insert a breakpoint. On targets that have software breakpoint
5135 support, we ask the remote target to do the work; on targets
5136 which don't, we insert a traditional memory breakpoint. */
5139 remote_insert_breakpoint (struct bp_target_info
*bp_tgt
)
5141 CORE_ADDR addr
= bp_tgt
->placed_address
;
5142 struct remote_state
*rs
= get_remote_state ();
5143 #ifdef DEPRECATED_REMOTE_BREAKPOINT
5147 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
5148 If it succeeds, then set the support to PACKET_ENABLE. If it
5149 fails, and the user has explicitly requested the Z support then
5150 report an error, otherwise, mark it disabled and go on. */
5152 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5159 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5160 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5161 p
+= hexnumstr (p
, addr
);
5162 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5165 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5167 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
5173 case PACKET_UNKNOWN
:
5178 #ifdef DEPRECATED_REMOTE_BREAKPOINT
5179 bp_tgt
->placed_size
= bp_tgt
->shadow_len
= sizeof big_break_insn
;
5180 val
= target_read_memory (addr
, bp_tgt
->shadow_contents
, bp_tgt
->shadow_len
);
5184 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
5185 val
= target_write_memory (addr
, (char *) big_break_insn
,
5186 sizeof big_break_insn
);
5188 val
= target_write_memory (addr
, (char *) little_break_insn
,
5189 sizeof little_break_insn
);
5194 return memory_insert_breakpoint (bp_tgt
);
5195 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
5199 remote_remove_breakpoint (struct bp_target_info
*bp_tgt
)
5201 CORE_ADDR addr
= bp_tgt
->placed_address
;
5202 struct remote_state
*rs
= get_remote_state ();
5205 if (remote_protocol_packets
[PACKET_Z0
].support
!= PACKET_DISABLE
)
5213 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
5214 p
+= hexnumstr (p
, addr
);
5215 sprintf (p
, ",%d", bp_tgt
->placed_size
);
5218 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5220 return (rs
->buf
[0] == 'E');
5223 #ifdef DEPRECATED_REMOTE_BREAKPOINT
5224 return target_write_memory (bp_tgt
->placed_address
, bp_tgt
->shadow_contents
,
5225 bp_tgt
->shadow_len
);
5227 return memory_remove_breakpoint (bp_tgt
);
5228 #endif /* DEPRECATED_REMOTE_BREAKPOINT */
5232 watchpoint_to_Z_packet (int type
)
5237 return Z_PACKET_WRITE_WP
;
5240 return Z_PACKET_READ_WP
;
5243 return Z_PACKET_ACCESS_WP
;
5246 internal_error (__FILE__
, __LINE__
,
5247 _("hw_bp_to_z: bad watchpoint type %d"), type
);
5252 remote_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
5254 struct remote_state
*rs
= get_remote_state ();
5256 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5258 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5261 sprintf (rs
->buf
, "Z%x,", packet
);
5262 p
= strchr (rs
->buf
, '\0');
5263 addr
= remote_address_masked (addr
);
5264 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5265 sprintf (p
, ",%x", len
);
5268 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5270 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5273 case PACKET_UNKNOWN
:
5278 internal_error (__FILE__
, __LINE__
,
5279 _("remote_insert_watchpoint: reached end of function"));
5284 remote_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
5286 struct remote_state
*rs
= get_remote_state ();
5288 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
5290 if (remote_protocol_packets
[PACKET_Z0
+ packet
].support
== PACKET_DISABLE
)
5293 sprintf (rs
->buf
, "z%x,", packet
);
5294 p
= strchr (rs
->buf
, '\0');
5295 addr
= remote_address_masked (addr
);
5296 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5297 sprintf (p
, ",%x", len
);
5299 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5301 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
5304 case PACKET_UNKNOWN
:
5309 internal_error (__FILE__
, __LINE__
,
5310 _("remote_remove_watchpoint: reached end of function"));
5314 int remote_hw_watchpoint_limit
= -1;
5315 int remote_hw_breakpoint_limit
= -1;
5318 remote_check_watch_resources (int type
, int cnt
, int ot
)
5320 if (type
== bp_hardware_breakpoint
)
5322 if (remote_hw_breakpoint_limit
== 0)
5324 else if (remote_hw_breakpoint_limit
< 0)
5326 else if (cnt
<= remote_hw_breakpoint_limit
)
5331 if (remote_hw_watchpoint_limit
== 0)
5333 else if (remote_hw_watchpoint_limit
< 0)
5337 else if (cnt
<= remote_hw_watchpoint_limit
)
5344 remote_stopped_by_watchpoint (void)
5346 return remote_stopped_by_watchpoint_p
;
5349 extern int stepped_after_stopped_by_watchpoint
;
5352 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
5355 if (remote_stopped_by_watchpoint ()
5356 || stepped_after_stopped_by_watchpoint
)
5358 *addr_p
= remote_watch_data_address
;
5367 remote_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5370 struct remote_state
*rs
= get_remote_state ();
5373 /* The length field should be set to the size of a breakpoint
5374 instruction, even though we aren't inserting one ourselves. */
5376 BREAKPOINT_FROM_PC (&bp_tgt
->placed_address
, &bp_tgt
->placed_size
);
5378 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5385 addr
= remote_address_masked (bp_tgt
->placed_address
);
5386 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5387 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5390 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5392 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5395 case PACKET_UNKNOWN
:
5400 internal_error (__FILE__
, __LINE__
,
5401 _("remote_insert_hw_breakpoint: reached end of function"));
5406 remote_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
5409 struct remote_state
*rs
= get_remote_state ();
5412 if (remote_protocol_packets
[PACKET_Z1
].support
== PACKET_DISABLE
)
5419 addr
= remote_address_masked (bp_tgt
->placed_address
);
5420 p
+= hexnumstr (p
, (ULONGEST
) addr
);
5421 sprintf (p
, ",%x", bp_tgt
->placed_size
);
5424 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5426 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
5429 case PACKET_UNKNOWN
:
5434 internal_error (__FILE__
, __LINE__
,
5435 _("remote_remove_hw_breakpoint: reached end of function"));
5438 /* Some targets are only capable of doing downloads, and afterwards
5439 they switch to the remote serial protocol. This function provides
5440 a clean way to get from the download target to the remote target.
5441 It's basically just a wrapper so that we don't have to expose any
5442 of the internal workings of remote.c.
5444 Prior to calling this routine, you should shutdown the current
5445 target code, else you will get the "A program is being debugged
5446 already..." message. Usually a call to pop_target() suffices. */
5449 push_remote_target (char *name
, int from_tty
)
5451 printf_filtered (_("Switching to remote protocol\n"));
5452 remote_open (name
, from_tty
);
5455 /* Table used by the crc32 function to calcuate the checksum. */
5457 static unsigned long crc32_table
[256] =
5460 static unsigned long
5461 crc32 (unsigned char *buf
, int len
, unsigned int crc
)
5463 if (!crc32_table
[1])
5465 /* Initialize the CRC table and the decoding table. */
5469 for (i
= 0; i
< 256; i
++)
5471 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
5472 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
5479 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buf
) & 255];
5485 /* compare-sections command
5487 With no arguments, compares each loadable section in the exec bfd
5488 with the same memory range on the target, and reports mismatches.
5489 Useful for verifying the image on the target against the exec file.
5490 Depends on the target understanding the new "qCRC:" request. */
5492 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5493 target method (target verify memory) and generic version of the
5494 actual command. This will allow other high-level code (especially
5495 generic_load()) to make use of this target functionality. */
5498 compare_sections_command (char *args
, int from_tty
)
5500 struct remote_state
*rs
= get_remote_state ();
5502 unsigned long host_crc
, target_crc
;
5503 extern bfd
*exec_bfd
;
5504 struct cleanup
*old_chain
;
5507 const char *sectname
;
5514 error (_("command cannot be used without an exec file"));
5515 if (!current_target
.to_shortname
||
5516 strcmp (current_target
.to_shortname
, "remote") != 0)
5517 error (_("command can only be used with remote target"));
5519 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5521 if (!(s
->flags
& SEC_LOAD
))
5522 continue; /* skip non-loadable section */
5524 size
= bfd_get_section_size (s
);
5526 continue; /* skip zero-length section */
5528 sectname
= bfd_get_section_name (exec_bfd
, s
);
5529 if (args
&& strcmp (args
, sectname
) != 0)
5530 continue; /* not the section selected by user */
5532 matched
= 1; /* do this section */
5534 /* FIXME: assumes lma can fit into long. */
5535 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
5536 (long) lma
, (long) size
);
5539 /* Be clever; compute the host_crc before waiting for target
5541 sectdata
= xmalloc (size
);
5542 old_chain
= make_cleanup (xfree
, sectdata
);
5543 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
5544 host_crc
= crc32 ((unsigned char *) sectdata
, size
, 0xffffffff);
5546 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5547 if (rs
->buf
[0] == 'E')
5548 error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
5549 sectname
, paddr (lma
), paddr (lma
+ size
));
5550 if (rs
->buf
[0] != 'C')
5551 error (_("remote target does not support this operation"));
5553 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
5554 target_crc
= target_crc
* 16 + fromhex (*tmp
);
5556 printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5557 sectname
, paddr (lma
), paddr (lma
+ size
));
5558 if (host_crc
== target_crc
)
5559 printf_filtered ("matched.\n");
5562 printf_filtered ("MIS-MATCHED!\n");
5566 do_cleanups (old_chain
);
5569 warning (_("One or more sections of the remote executable does not match\n\
5570 the loaded file\n"));
5571 if (args
&& !matched
)
5572 printf_filtered (_("No loaded section named '%s'.\n"), args
);
5575 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
5576 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
5577 number of bytes read is returned, or 0 for EOF, or -1 for error.
5578 The number of bytes read may be less than LEN without indicating an
5579 EOF. PACKET is checked and updated to indicate whether the remote
5580 target supports this object. */
5583 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
5585 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
5586 struct packet_config
*packet
)
5588 static char *finished_object
;
5589 static char *finished_annex
;
5590 static ULONGEST finished_offset
;
5592 struct remote_state
*rs
= get_remote_state ();
5593 unsigned int total
= 0;
5594 LONGEST i
, n
, packet_len
;
5596 if (packet
->support
== PACKET_DISABLE
)
5599 /* Check whether we've cached an end-of-object packet that matches
5601 if (finished_object
)
5603 if (strcmp (object_name
, finished_object
) == 0
5604 && strcmp (annex
? annex
: "", finished_annex
) == 0
5605 && offset
== finished_offset
)
5608 /* Otherwise, we're now reading something different. Discard
5610 xfree (finished_object
);
5611 xfree (finished_annex
);
5612 finished_object
= NULL
;
5613 finished_annex
= NULL
;
5616 /* Request only enough to fit in a single packet. The actual data
5617 may not, since we don't know how much of it will need to be escaped;
5618 the target is free to respond with slightly less data. We subtract
5619 five to account for the response type and the protocol frame. */
5620 n
= min (get_remote_packet_size () - 5, len
);
5621 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
5622 object_name
, annex
? annex
: "",
5623 phex_nz (offset
, sizeof offset
),
5624 phex_nz (n
, sizeof n
));
5625 i
= putpkt (rs
->buf
);
5630 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
5631 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
5634 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
5635 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
5637 /* 'm' means there is (or at least might be) more data after this
5638 batch. That does not make sense unless there's at least one byte
5639 of data in this reply. */
5640 if (rs
->buf
[0] == 'm' && packet_len
== 1)
5641 error (_("Remote qXfer reply contained no data."));
5643 /* Got some data. */
5644 i
= remote_unescape_input (rs
->buf
+ 1, packet_len
- 1, readbuf
, n
);
5646 /* 'l' is an EOF marker, possibly including a final block of data,
5647 or possibly empty. Record it to bypass the next read, if one is
5649 if (rs
->buf
[0] == 'l')
5651 finished_object
= xstrdup (object_name
);
5652 finished_annex
= xstrdup (annex
? annex
: "");
5653 finished_offset
= offset
+ i
;
5660 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5661 const char *annex
, gdb_byte
*readbuf
,
5662 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5664 struct remote_state
*rs
= get_remote_state ();
5669 /* Handle memory using the standard memory routines. */
5670 if (object
== TARGET_OBJECT_MEMORY
)
5675 if (writebuf
!= NULL
)
5676 xfered
= remote_write_bytes (offset
, writebuf
, len
);
5678 xfered
= remote_read_bytes (offset
, readbuf
, len
);
5682 else if (xfered
== 0 && errno
== 0)
5688 /* Only handle flash writes. */
5689 if (writebuf
!= NULL
)
5695 case TARGET_OBJECT_FLASH
:
5696 xfered
= remote_flash_write (ops
, offset
, len
, writebuf
);
5700 else if (xfered
== 0 && errno
== 0)
5710 /* Map pre-existing objects onto letters. DO NOT do this for new
5711 objects!!! Instead specify new query packets. */
5714 case TARGET_OBJECT_AVR
:
5718 case TARGET_OBJECT_AUXV
:
5719 gdb_assert (annex
== NULL
);
5720 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
5721 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
5723 case TARGET_OBJECT_AVAILABLE_FEATURES
:
5724 return remote_read_qxfer
5725 (ops
, "features", annex
, readbuf
, offset
, len
,
5726 &remote_protocol_packets
[PACKET_qXfer_features
]);
5728 case TARGET_OBJECT_MEMORY_MAP
:
5729 gdb_assert (annex
== NULL
);
5730 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
5731 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
5737 /* Note: a zero OFFSET and LEN can be used to query the minimum
5739 if (offset
== 0 && len
== 0)
5740 return (get_remote_packet_size ());
5741 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
5742 large enough let the caller deal with it. */
5743 if (len
< get_remote_packet_size ())
5745 len
= get_remote_packet_size ();
5747 /* Except for querying the minimum buffer size, target must be open. */
5749 error (_("remote query is only available after target open"));
5751 gdb_assert (annex
!= NULL
);
5752 gdb_assert (readbuf
!= NULL
);
5758 /* We used one buffer char for the remote protocol q command and
5759 another for the query type. As the remote protocol encapsulation
5760 uses 4 chars plus one extra in case we are debugging
5761 (remote_debug), we have PBUFZIZ - 7 left to pack the query
5764 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
5766 /* Bad caller may have sent forbidden characters. */
5767 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
5772 gdb_assert (annex
[i
] == '\0');
5774 i
= putpkt (rs
->buf
);
5778 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5779 strcpy ((char *) readbuf
, rs
->buf
);
5781 return strlen ((char *) readbuf
);
5785 remote_rcmd (char *command
,
5786 struct ui_file
*outbuf
)
5788 struct remote_state
*rs
= get_remote_state ();
5792 error (_("remote rcmd is only available after target open"));
5794 /* Send a NULL command across as an empty command. */
5795 if (command
== NULL
)
5798 /* The query prefix. */
5799 strcpy (rs
->buf
, "qRcmd,");
5800 p
= strchr (rs
->buf
, '\0');
5802 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/) > get_remote_packet_size ())
5803 error (_("\"monitor\" command ``%s'' is too long."), command
);
5805 /* Encode the actual command. */
5806 bin2hex ((gdb_byte
*) command
, p
, 0);
5808 if (putpkt (rs
->buf
) < 0)
5809 error (_("Communication problem with target."));
5811 /* get/display the response */
5816 /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
5818 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5821 error (_("Target does not support this command."));
5822 if (buf
[0] == 'O' && buf
[1] != 'K')
5824 remote_console_output (buf
+ 1); /* 'O' message from stub. */
5827 if (strcmp (buf
, "OK") == 0)
5829 if (strlen (buf
) == 3 && buf
[0] == 'E'
5830 && isdigit (buf
[1]) && isdigit (buf
[2]))
5832 error (_("Protocol error with Rcmd"));
5834 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
5836 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
5837 fputc_unfiltered (c
, outbuf
);
5843 static VEC(mem_region_s
) *
5844 remote_memory_map (struct target_ops
*ops
)
5846 VEC(mem_region_s
) *result
= NULL
;
5847 char *text
= target_read_stralloc (¤t_target
,
5848 TARGET_OBJECT_MEMORY_MAP
, NULL
);
5852 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
5853 result
= parse_memory_map (text
);
5854 do_cleanups (back_to
);
5861 packet_command (char *args
, int from_tty
)
5863 struct remote_state
*rs
= get_remote_state ();
5866 error (_("command can only be used with remote target"));
5869 error (_("remote-packet command requires packet text as argument"));
5871 puts_filtered ("sending: ");
5872 print_packet (args
);
5873 puts_filtered ("\n");
5876 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5877 puts_filtered ("received: ");
5878 print_packet (rs
->buf
);
5879 puts_filtered ("\n");
5883 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
5885 static void display_thread_info (struct gdb_ext_thread_info
*info
);
5887 static void threadset_test_cmd (char *cmd
, int tty
);
5889 static void threadalive_test (char *cmd
, int tty
);
5891 static void threadlist_test_cmd (char *cmd
, int tty
);
5893 int get_and_display_threadinfo (threadref
*ref
);
5895 static void threadinfo_test_cmd (char *cmd
, int tty
);
5897 static int thread_display_step (threadref
*ref
, void *context
);
5899 static void threadlist_update_test_cmd (char *cmd
, int tty
);
5901 static void init_remote_threadtests (void);
5903 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
5906 threadset_test_cmd (char *cmd
, int tty
)
5908 int sample_thread
= SAMPLE_THREAD
;
5910 printf_filtered (_("Remote threadset test\n"));
5911 set_thread (sample_thread
, 1);
5916 threadalive_test (char *cmd
, int tty
)
5918 int sample_thread
= SAMPLE_THREAD
;
5920 if (remote_thread_alive (pid_to_ptid (sample_thread
)))
5921 printf_filtered ("PASS: Thread alive test\n");
5923 printf_filtered ("FAIL: Thread alive test\n");
5926 void output_threadid (char *title
, threadref
*ref
);
5929 output_threadid (char *title
, threadref
*ref
)
5933 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
5935 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
5939 threadlist_test_cmd (char *cmd
, int tty
)
5942 threadref nextthread
;
5943 int done
, result_count
;
5944 threadref threadlist
[3];
5946 printf_filtered ("Remote Threadlist test\n");
5947 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
5948 &result_count
, &threadlist
[0]))
5949 printf_filtered ("FAIL: threadlist test\n");
5952 threadref
*scan
= threadlist
;
5953 threadref
*limit
= scan
+ result_count
;
5955 while (scan
< limit
)
5956 output_threadid (" thread ", scan
++);
5961 display_thread_info (struct gdb_ext_thread_info
*info
)
5963 output_threadid ("Threadid: ", &info
->threadid
);
5964 printf_filtered ("Name: %s\n ", info
->shortname
);
5965 printf_filtered ("State: %s\n", info
->display
);
5966 printf_filtered ("other: %s\n\n", info
->more_display
);
5970 get_and_display_threadinfo (threadref
*ref
)
5974 struct gdb_ext_thread_info threadinfo
;
5976 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
5977 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
5978 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
5979 display_thread_info (&threadinfo
);
5984 threadinfo_test_cmd (char *cmd
, int tty
)
5986 int athread
= SAMPLE_THREAD
;
5990 int_to_threadref (&thread
, athread
);
5991 printf_filtered ("Remote Threadinfo test\n");
5992 if (!get_and_display_threadinfo (&thread
))
5993 printf_filtered ("FAIL cannot get thread info\n");
5997 thread_display_step (threadref
*ref
, void *context
)
5999 /* output_threadid(" threadstep ",ref); *//* simple test */
6000 return get_and_display_threadinfo (ref
);
6004 threadlist_update_test_cmd (char *cmd
, int tty
)
6006 printf_filtered ("Remote Threadlist update test\n");
6007 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
6011 init_remote_threadtests (void)
6013 add_com ("tlist", class_obscure
, threadlist_test_cmd
, _("\
6014 Fetch and print the remote list of thread identifiers, one pkt only"));
6015 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
6016 _("Fetch and display info about one thread"));
6017 add_com ("tset", class_obscure
, threadset_test_cmd
,
6018 _("Test setting to a different thread"));
6019 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
6020 _("Iterate through updating all remote thread info"));
6021 add_com ("talive", class_obscure
, threadalive_test
,
6022 _(" Remote thread alive test "));
6027 /* Convert a thread ID to a string. Returns the string in a static
6031 remote_pid_to_str (ptid_t ptid
)
6033 static char buf
[32];
6035 xsnprintf (buf
, sizeof buf
, "Thread %d", ptid_get_pid (ptid
));
6039 /* Get the address of the thread local variable in OBJFILE which is
6040 stored at OFFSET within the thread local storage for thread PTID. */
6043 remote_get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
6045 if (remote_protocol_packets
[PACKET_qGetTLSAddr
].support
!= PACKET_DISABLE
)
6047 struct remote_state
*rs
= get_remote_state ();
6049 enum packet_result result
;
6051 strcpy (p
, "qGetTLSAddr:");
6053 p
+= hexnumstr (p
, PIDGET (ptid
));
6055 p
+= hexnumstr (p
, offset
);
6057 p
+= hexnumstr (p
, lm
);
6061 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6062 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
6063 if (result
== PACKET_OK
)
6067 unpack_varlen_hex (rs
->buf
, &result
);
6070 else if (result
== PACKET_UNKNOWN
)
6071 throw_error (TLS_GENERIC_ERROR
,
6072 _("Remote target doesn't support qGetTLSAddr packet"));
6074 throw_error (TLS_GENERIC_ERROR
,
6075 _("Remote target failed to process qGetTLSAddr request"));
6078 throw_error (TLS_GENERIC_ERROR
,
6079 _("TLS not supported or disabled on this target"));
6084 /* Support for inferring a target description based on the current
6085 architecture and the size of a 'g' packet. While the 'g' packet
6086 can have any size (since optional registers can be left off the
6087 end), some sizes are easily recognizable given knowledge of the
6088 approximate architecture. */
6090 struct remote_g_packet_guess
6093 const struct target_desc
*tdesc
;
6095 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
6096 DEF_VEC_O(remote_g_packet_guess_s
);
6098 struct remote_g_packet_data
6100 VEC(remote_g_packet_guess_s
) *guesses
;
6103 static struct gdbarch_data
*remote_g_packet_data_handle
;
6106 remote_g_packet_data_init (struct obstack
*obstack
)
6108 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
6112 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
6113 const struct target_desc
*tdesc
)
6115 struct remote_g_packet_data
*data
6116 = gdbarch_data (gdbarch
, remote_g_packet_data_handle
);
6117 struct remote_g_packet_guess new_guess
, *guess
;
6120 gdb_assert (tdesc
!= NULL
);
6123 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6125 if (guess
->bytes
== bytes
)
6126 internal_error (__FILE__
, __LINE__
,
6127 "Duplicate g packet description added for size %d",
6130 new_guess
.bytes
= bytes
;
6131 new_guess
.tdesc
= tdesc
;
6132 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
6135 static const struct target_desc
*
6136 remote_read_description (struct target_ops
*target
)
6138 struct remote_g_packet_data
*data
6139 = gdbarch_data (current_gdbarch
, remote_g_packet_data_handle
);
6141 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
6143 struct remote_g_packet_guess
*guess
;
6145 int bytes
= send_g_packet ();
6148 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
6150 if (guess
->bytes
== bytes
)
6151 return guess
->tdesc
;
6153 /* We discard the g packet. A minor optimization would be to
6154 hold on to it, and fill the register cache once we have selected
6155 an architecture, but it's too tricky to do safely. */
6162 init_remote_ops (void)
6164 remote_ops
.to_shortname
= "remote";
6165 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
6167 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6168 Specify the serial device it is connected to\n\
6169 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
6170 remote_ops
.to_open
= remote_open
;
6171 remote_ops
.to_close
= remote_close
;
6172 remote_ops
.to_detach
= remote_detach
;
6173 remote_ops
.to_disconnect
= remote_disconnect
;
6174 remote_ops
.to_resume
= remote_resume
;
6175 remote_ops
.to_wait
= remote_wait
;
6176 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
6177 remote_ops
.to_store_registers
= remote_store_registers
;
6178 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6179 remote_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6180 remote_ops
.to_files_info
= remote_files_info
;
6181 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6182 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6183 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6184 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6185 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6186 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6187 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6188 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6189 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6190 remote_ops
.to_kill
= remote_kill
;
6191 remote_ops
.to_load
= generic_load
;
6192 remote_ops
.to_mourn_inferior
= remote_mourn
;
6193 remote_ops
.to_thread_alive
= remote_thread_alive
;
6194 remote_ops
.to_find_new_threads
= remote_threads_info
;
6195 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
6196 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6197 remote_ops
.to_stop
= remote_stop
;
6198 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
6199 remote_ops
.to_rcmd
= remote_rcmd
;
6200 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
6201 remote_ops
.to_stratum
= process_stratum
;
6202 remote_ops
.to_has_all_memory
= 1;
6203 remote_ops
.to_has_memory
= 1;
6204 remote_ops
.to_has_stack
= 1;
6205 remote_ops
.to_has_registers
= 1;
6206 remote_ops
.to_has_execution
= 1;
6207 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6208 remote_ops
.to_magic
= OPS_MAGIC
;
6209 remote_ops
.to_memory_map
= remote_memory_map
;
6210 remote_ops
.to_flash_erase
= remote_flash_erase
;
6211 remote_ops
.to_flash_done
= remote_flash_done
;
6212 remote_ops
.to_read_description
= remote_read_description
;
6215 /* Set up the extended remote vector by making a copy of the standard
6216 remote vector and adding to it. */
6219 init_extended_remote_ops (void)
6221 extended_remote_ops
= remote_ops
;
6223 extended_remote_ops
.to_shortname
= "extended-remote";
6224 extended_remote_ops
.to_longname
=
6225 "Extended remote serial target in gdb-specific protocol";
6226 extended_remote_ops
.to_doc
=
6227 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6228 Specify the serial device it is connected to (e.g. /dev/ttya).",
6229 extended_remote_ops
.to_open
= extended_remote_open
;
6230 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
6231 extended_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6235 remote_can_async_p (void)
6237 /* We're async whenever the serial device is. */
6238 return (current_target
.to_async_mask_value
) && serial_can_async_p (remote_desc
);
6242 remote_is_async_p (void)
6244 /* We're async whenever the serial device is. */
6245 return (current_target
.to_async_mask_value
) && serial_is_async_p (remote_desc
);
6248 /* Pass the SERIAL event on and up to the client. One day this code
6249 will be able to delay notifying the client of an event until the
6250 point where an entire packet has been received. */
6252 static void (*async_client_callback
) (enum inferior_event_type event_type
,
6254 static void *async_client_context
;
6255 static serial_event_ftype remote_async_serial_handler
;
6258 remote_async_serial_handler (struct serial
*scb
, void *context
)
6260 /* Don't propogate error information up to the client. Instead let
6261 the client find out about the error by querying the target. */
6262 async_client_callback (INF_REG_EVENT
, async_client_context
);
6266 remote_async (void (*callback
) (enum inferior_event_type event_type
,
6267 void *context
), void *context
)
6269 if (current_target
.to_async_mask_value
== 0)
6270 internal_error (__FILE__
, __LINE__
,
6271 _("Calling remote_async when async is masked"));
6273 if (callback
!= NULL
)
6275 serial_async (remote_desc
, remote_async_serial_handler
, NULL
);
6276 async_client_callback
= callback
;
6277 async_client_context
= context
;
6280 serial_async (remote_desc
, NULL
, NULL
);
6283 /* Target async and target extended-async.
6285 This are temporary targets, until it is all tested. Eventually
6286 async support will be incorporated int the usual 'remote'
6290 init_remote_async_ops (void)
6292 remote_async_ops
.to_shortname
= "async";
6293 remote_async_ops
.to_longname
=
6294 "Remote serial target in async version of the gdb-specific protocol";
6295 remote_async_ops
.to_doc
=
6296 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
6297 Specify the serial device it is connected to (e.g. /dev/ttya).";
6298 remote_async_ops
.to_open
= remote_async_open
;
6299 remote_async_ops
.to_close
= remote_close
;
6300 remote_async_ops
.to_detach
= remote_detach
;
6301 remote_async_ops
.to_disconnect
= remote_disconnect
;
6302 remote_async_ops
.to_resume
= remote_async_resume
;
6303 remote_async_ops
.to_wait
= remote_async_wait
;
6304 remote_async_ops
.to_fetch_registers
= remote_fetch_registers
;
6305 remote_async_ops
.to_store_registers
= remote_store_registers
;
6306 remote_async_ops
.to_prepare_to_store
= remote_prepare_to_store
;
6307 remote_async_ops
.deprecated_xfer_memory
= remote_xfer_memory
;
6308 remote_async_ops
.to_files_info
= remote_files_info
;
6309 remote_async_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
6310 remote_async_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
6311 remote_async_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
6312 remote_async_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
6313 remote_async_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
6314 remote_async_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
6315 remote_async_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
6316 remote_async_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
6317 remote_async_ops
.to_stopped_data_address
= remote_stopped_data_address
;
6318 remote_async_ops
.to_terminal_inferior
= remote_async_terminal_inferior
;
6319 remote_async_ops
.to_terminal_ours
= remote_async_terminal_ours
;
6320 remote_async_ops
.to_kill
= remote_async_kill
;
6321 remote_async_ops
.to_load
= generic_load
;
6322 remote_async_ops
.to_mourn_inferior
= remote_async_mourn
;
6323 remote_async_ops
.to_thread_alive
= remote_thread_alive
;
6324 remote_async_ops
.to_find_new_threads
= remote_threads_info
;
6325 remote_async_ops
.to_pid_to_str
= remote_pid_to_str
;
6326 remote_async_ops
.to_extra_thread_info
= remote_threads_extra_info
;
6327 remote_async_ops
.to_stop
= remote_stop
;
6328 remote_async_ops
.to_xfer_partial
= remote_xfer_partial
;
6329 remote_async_ops
.to_rcmd
= remote_rcmd
;
6330 remote_async_ops
.to_stratum
= process_stratum
;
6331 remote_async_ops
.to_has_all_memory
= 1;
6332 remote_async_ops
.to_has_memory
= 1;
6333 remote_async_ops
.to_has_stack
= 1;
6334 remote_async_ops
.to_has_registers
= 1;
6335 remote_async_ops
.to_has_execution
= 1;
6336 remote_async_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
6337 remote_async_ops
.to_can_async_p
= remote_can_async_p
;
6338 remote_async_ops
.to_is_async_p
= remote_is_async_p
;
6339 remote_async_ops
.to_async
= remote_async
;
6340 remote_async_ops
.to_async_mask_value
= 1;
6341 remote_async_ops
.to_magic
= OPS_MAGIC
;
6342 remote_async_ops
.to_memory_map
= remote_memory_map
;
6343 remote_async_ops
.to_flash_erase
= remote_flash_erase
;
6344 remote_async_ops
.to_flash_done
= remote_flash_done
;
6345 remote_ops
.to_read_description
= remote_read_description
;
6348 /* Set up the async extended remote vector by making a copy of the standard
6349 remote vector and adding to it. */
6352 init_extended_async_remote_ops (void)
6354 extended_async_remote_ops
= remote_async_ops
;
6356 extended_async_remote_ops
.to_shortname
= "extended-async";
6357 extended_async_remote_ops
.to_longname
=
6358 "Extended remote serial target in async gdb-specific protocol";
6359 extended_async_remote_ops
.to_doc
=
6360 "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
6361 Specify the serial device it is connected to (e.g. /dev/ttya).",
6362 extended_async_remote_ops
.to_open
= extended_remote_async_open
;
6363 extended_async_remote_ops
.to_create_inferior
= extended_remote_async_create_inferior
;
6364 extended_async_remote_ops
.to_mourn_inferior
= extended_remote_mourn
;
6368 set_remote_cmd (char *args
, int from_tty
)
6370 help_list (remote_set_cmdlist
, "set remote ", -1, gdb_stdout
);
6374 show_remote_cmd (char *args
, int from_tty
)
6376 /* We can't just use cmd_show_list here, because we want to skip
6377 the redundant "show remote Z-packet" and the legacy aliases. */
6378 struct cleanup
*showlist_chain
;
6379 struct cmd_list_element
*list
= remote_show_cmdlist
;
6381 showlist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "showlist");
6382 for (; list
!= NULL
; list
= list
->next
)
6383 if (strcmp (list
->name
, "Z-packet") == 0)
6385 else if (list
->type
== not_set_cmd
)
6386 /* Alias commands are exactly like the original, except they
6387 don't have the normal type. */
6391 struct cleanup
*option_chain
6392 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
6393 ui_out_field_string (uiout
, "name", list
->name
);
6394 ui_out_text (uiout
, ": ");
6395 if (list
->type
== show_cmd
)
6396 do_setshow_command ((char *) NULL
, from_tty
, list
);
6398 cmd_func (list
, NULL
, from_tty
);
6399 /* Close the tuple. */
6400 do_cleanups (option_chain
);
6403 /* Close the tuple. */
6404 do_cleanups (showlist_chain
);
6408 build_remote_gdbarch_data (void)
6410 remote_address_size
= TARGET_ADDR_BIT
;
6413 /* Saved pointer to previous owner of the new_objfile event. */
6414 static void (*remote_new_objfile_chain
) (struct objfile
*);
6416 /* Function to be called whenever a new objfile (shlib) is detected. */
6418 remote_new_objfile (struct objfile
*objfile
)
6420 if (remote_desc
!= 0) /* Have a remote connection. */
6422 remote_check_symbols (objfile
);
6424 /* Call predecessor on chain, if any. */
6425 if (remote_new_objfile_chain
)
6426 remote_new_objfile_chain (objfile
);
6430 _initialize_remote (void)
6432 struct remote_state
*rs
;
6434 /* architecture specific data */
6435 remote_gdbarch_data_handle
=
6436 gdbarch_data_register_post_init (init_remote_state
);
6437 remote_g_packet_data_handle
=
6438 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
6440 /* Old tacky stuff. NOTE: This comes after the remote protocol so
6441 that the remote protocol has been initialized. */
6442 DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size
);
6443 deprecated_register_gdbarch_swap (NULL
, 0, build_remote_gdbarch_data
);
6445 /* Initialize the per-target state. At the moment there is only one
6446 of these, not one per target. Only one target is active at a
6447 time. The default buffer size is unimportant; it will be expanded
6448 whenever a larger buffer is needed. */
6449 rs
= get_remote_state_raw ();
6451 rs
->buf
= xmalloc (rs
->buf_size
);
6454 add_target (&remote_ops
);
6456 init_extended_remote_ops ();
6457 add_target (&extended_remote_ops
);
6459 init_remote_async_ops ();
6460 add_target (&remote_async_ops
);
6462 init_extended_async_remote_ops ();
6463 add_target (&extended_async_remote_ops
);
6465 /* Hook into new objfile notification. */
6466 remote_new_objfile_chain
= deprecated_target_new_objfile_hook
;
6467 deprecated_target_new_objfile_hook
= remote_new_objfile
;
6470 init_remote_threadtests ();
6473 /* set/show remote ... */
6475 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
6476 Remote protocol specific variables\n\
6477 Configure various remote-protocol specific variables such as\n\
6478 the packets being used"),
6479 &remote_set_cmdlist
, "set remote ",
6480 0 /* allow-unknown */, &setlist
);
6481 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
6482 Remote protocol specific variables\n\
6483 Configure various remote-protocol specific variables such as\n\
6484 the packets being used"),
6485 &remote_show_cmdlist
, "show remote ",
6486 0 /* allow-unknown */, &showlist
);
6488 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
6489 Compare section data on target to the exec file.\n\
6490 Argument is a single section name (default: all loaded sections)."),
6493 add_cmd ("packet", class_maintenance
, packet_command
, _("\
6494 Send an arbitrary packet to a remote target.\n\
6495 maintenance packet TEXT\n\
6496 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6497 this command sends the string TEXT to the inferior, and displays the\n\
6498 response packet. GDB supplies the initial `$' character, and the\n\
6499 terminating `#' character and checksum."),
6502 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
6503 Set whether to send break if interrupted."), _("\
6504 Show whether to send break if interrupted."), _("\
6505 If set, a break, instead of a cntrl-c, is sent to the remote target."),
6506 NULL
, NULL
, /* FIXME: i18n: Whether to send break if interrupted is %s. */
6507 &setlist
, &showlist
);
6509 /* Install commands for configuring memory read/write packets. */
6511 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
6512 Set the maximum number of bytes per memory write packet (deprecated)."),
6514 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
6515 Show the maximum number of bytes per memory write packet (deprecated)."),
6517 add_cmd ("memory-write-packet-size", no_class
,
6518 set_memory_write_packet_size
, _("\
6519 Set the maximum number of bytes per memory-write packet.\n\
6520 Specify the number of bytes in a packet or 0 (zero) for the\n\
6521 default packet size. The actual limit is further reduced\n\
6522 dependent on the target. Specify ``fixed'' to disable the\n\
6523 further restriction and ``limit'' to enable that restriction."),
6524 &remote_set_cmdlist
);
6525 add_cmd ("memory-read-packet-size", no_class
,
6526 set_memory_read_packet_size
, _("\
6527 Set the maximum number of bytes per memory-read packet.\n\
6528 Specify the number of bytes in a packet or 0 (zero) for the\n\
6529 default packet size. The actual limit is further reduced\n\
6530 dependent on the target. Specify ``fixed'' to disable the\n\
6531 further restriction and ``limit'' to enable that restriction."),
6532 &remote_set_cmdlist
);
6533 add_cmd ("memory-write-packet-size", no_class
,
6534 show_memory_write_packet_size
,
6535 _("Show the maximum number of bytes per memory-write packet."),
6536 &remote_show_cmdlist
);
6537 add_cmd ("memory-read-packet-size", no_class
,
6538 show_memory_read_packet_size
,
6539 _("Show the maximum number of bytes per memory-read packet."),
6540 &remote_show_cmdlist
);
6542 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
6543 &remote_hw_watchpoint_limit
, _("\
6544 Set the maximum number of target hardware watchpoints."), _("\
6545 Show the maximum number of target hardware watchpoints."), _("\
6546 Specify a negative limit for unlimited."),
6547 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware watchpoints is %s. */
6548 &remote_set_cmdlist
, &remote_show_cmdlist
);
6549 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
6550 &remote_hw_breakpoint_limit
, _("\
6551 Set the maximum number of target hardware breakpoints."), _("\
6552 Show the maximum number of target hardware breakpoints."), _("\
6553 Specify a negative limit for unlimited."),
6554 NULL
, NULL
, /* FIXME: i18n: The maximum number of target hardware breakpoints is %s. */
6555 &remote_set_cmdlist
, &remote_show_cmdlist
);
6557 add_setshow_integer_cmd ("remoteaddresssize", class_obscure
,
6558 &remote_address_size
, _("\
6559 Set the maximum size of the address (in bits) in a memory packet."), _("\
6560 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
6562 NULL
, /* FIXME: i18n: */
6563 &setlist
, &showlist
);
6565 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
6566 "X", "binary-download", 1);
6568 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
6569 "vCont", "verbose-resume", 0);
6571 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
6572 "QPassSignals", "pass-signals", 0);
6574 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
6575 "qSymbol", "symbol-lookup", 0);
6577 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
6578 "P", "set-register", 1);
6580 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
6581 "p", "fetch-register", 1);
6583 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
6584 "Z0", "software-breakpoint", 0);
6586 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
6587 "Z1", "hardware-breakpoint", 0);
6589 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
6590 "Z2", "write-watchpoint", 0);
6592 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
6593 "Z3", "read-watchpoint", 0);
6595 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
6596 "Z4", "access-watchpoint", 0);
6598 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
6599 "qXfer:auxv:read", "read-aux-vector", 0);
6601 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
6602 "qXfer:features:read", "target-features", 0);
6604 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
6605 "qXfer:memory-map:read", "memory-map", 0);
6607 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
6608 "qGetTLSAddr", "get-thread-local-storage-address",
6611 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
6612 "qSupported", "supported-packets", 0);
6614 /* Keep the old ``set remote Z-packet ...'' working. Each individual
6615 Z sub-packet has its own set and show commands, but users may
6616 have sets to this variable in their .gdbinit files (or in their
6618 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
6619 &remote_Z_packet_detect
, _("\
6620 Set use of remote protocol `Z' packets"), _("\
6621 Show use of remote protocol `Z' packets "), _("\
6622 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
6624 set_remote_protocol_Z_packet_cmd
,
6625 show_remote_protocol_Z_packet_cmd
, /* FIXME: i18n: Use of remote protocol `Z' packets is %s. */
6626 &remote_set_cmdlist
, &remote_show_cmdlist
);
6628 /* Eventually initialize fileio. See fileio.c */
6629 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);